Potato44

@DLosc <*> is ap, <$> is map, >>= is bind. I don't know of one for =<< but I tend to think of it as "reverse bind"

@flawr yes, A vector of vectors is reasonable.

@flawr If you need to index there are data structures better suited for that, such Vectors from the Vector package, or if you also need efficient cons there is Seq from contianers

@JonathanFrech I have very little idea, I've never actually written a parser before. Megaparsec apparatnly has some source position stuff: hackage.haskell.org/package/megaparsec-8.0.0/docs/…

note: the lexer can also be imlpemented as a monadic parser, that just outputs a stream of tokens

@JonathanFrech it is usually better to token with a lexer first, but if what you are doing is very simple, that might be too much hassle.

and I just realized some small errors in my first description, both in the omegaPlusOne example and the OmegaTimesTwoPlusOne the last 0 should be a 1

@KritixiLithos yes, Homotopy type theory. That last part was mostly me thinking out loud to myself.

I'm not sure which of those two representations is easier to use for this problem.

three = O [O [], O [], O[]]

In this representation an empty list represents zero, we can represnt an integer by specifying that many times the power 0 in the cantor normal form.

@WheatWizard I believe that is the case. I think you need access to some kind of continuation-like behavior to be able to have constructs that would loop in lazy eveluation, but not eager evaluation.

Paper I learned this from: pdfs.semanticscholar.org/3a68/…

Hm, I thought lazy evaluation always terminates more often than eager evaluation, turn out that is not the case. Consider the expression let _ = raise k in loop for some infinite loop loop. This will loop in a lazy language, but exit non-locally in an eager one.

If you have Data.List imported. You can use f l=nub l==l

The linearity thing you are probably thinking of is whether folding over a list with (++) as the operation is linear or quadratic. foldr (++) [] xs is linear wheras as foldl (++) [] xs is quadratic because the prefixes keep getting reprocessed in the latter case.

@FrownyFrog if has a has length l, b length n, and c length m. a ++ (b ++ c) takes time proportional to l+m whereas the (a ++ b) ++ c takes time proportional to l+(l+m) = 2l+m (assuming everything gets forced). So these are both linear in some sense. The first is more efficient because it doesn't prcess the a twice.

@EsolangingFruit no, I actually simplified the code to work out what it was doing: tio.run/##S0oszvj/…

@EsolangingFruit I haven't run it to check, but I believe that is an infinite list containing the Fibonacci sequence.

stackoverflow.com/questions/11466284/… and stackoverflow.com/questions/3951012/…

there is a question on stack overflow that is essentially about when that does or doesn't memoize of the exact example you used, I will see if I can find it

@Οurous does eta-reducing n help?

@EsolangingFruit does that collect runs of list elements not equal to t?

@EsolangingFruit That sounds like a question you should ask at computer science stack exchange. Actually that is something that I would be interested in an answer to as well.

@user21820 thanks for the link to the zoo of ordinals. There are many ordinals between the first recursively Mahlo and the first ordinal such that L_alpha models ZFC that I was not aware of.

Found it. It was actually in Simply Beautifal Art's chatroom: chat.stackexchange.com/transcript/message/44141809#44141809

It was posted here as either an image or a link to a short PDF.

@MaliceVidrine The table I'm thinking of was laid out like the one on the nLab, but much larger.

I remember a huge table that that was posted here a long time ago. It compared the strength of various logical systems (type theories, set theories, theories of inductive definitions, etc.). I have been unable to find it by using the chat search. Does anyone remember it and possibly have a link?

@KritixiLithos no, ⍵×⍵ + ⍵×⍵ is the same as ⍵×⍵×2 which is different from ⍵×⍵ = 2×⍵×⍵

The naive way of just picking positions for each each card randomly and trying again if it overlaps can fail in some situations. Example: the large rectangle is 4 cards wide and 1 card tall, we want to place 3 cards. The first card(s top-left corner) gets placed at (2/3,0) the second card at (7/3,0). but now we don;t have a large enough space to place the 3rd card.

Are all small rectangles the same size?

oops, my fault, I had an empty string as a compiler argument

@Dennis yes, the error code 1 is a bug, as of a few hours ago there is a patch from upstream located here: bugzilla.redhat.com/show_bug.cgi?id=1729682#add_comment

That also makes more sense, because you were using Fedora 27 then, which actually had bc 1.07

ooh, dc version 1.4 from bc 1.07 has an exit code of 0, so this has changed between 1.07 and 1.07.1

@Dennis yes, current version of GNU dc and the fedora dc are 1.4.1 from bc 1.07.1. Both have an exit code of 1 on the q command. I just downloaded bc 1.06 from source which has dc 1.3. That has an exit code of 0 on the q command.

looking at bc versions in fedora, you might have had version 1.06.95 installed at that time

@Dennis I just downloaded version 1.06 of GNU dc, that has an exit code of 0

I have found the source code for a non-gnu dc lying around on my computer, that dc has an exit code of 0 when I use the quit commend.

@Dennis You made this comment a few days before stasoid commented out dc in the polyglot driver, probably related.

@Dennis yes same (exit code 1) behavior on my machine (Fedora 29), but it worked (exit code 0) a bit over a year ago on TIO.

more specifically the exit code

@Dennis Something is going wrong with dc. codegolf.stackexchange.com/questions/102370/…

@Dennis do you prefer to link to the home page of the language like you do for GCC or the code repository like you do for a lot of esolangs? If the first, the ATS website is ats-lang.org/Home.html

@Dennis maybe that should be a bug report