travv0

See https://news.ycombinator.com/item?id=31416448

I assumed those were aliases for `git a` and `git cp` which are in the config file.

What tools? That's a git config file.

> The fact most kids dont have a relationship with their parents or guardians where they can talk to them about anything is highlighted with metadata like you have highlighted.

You have a source for that? The statistics you're referring certainly don't say anything at all to back your claim.

I also haven't seen an ad on the Gmail web client in years. Maybe because I pay for extra storage through Google One?

Edit: It looks like it doesn't happen in the primary tab and I have all the other tabs disabled which would explain it.

Reading through the GitHub issue, it seems like the one place it makes sense in my eyes is that you can refer to stuff in external libraries with your convention even if the library uses a different one. I'm not sure if there's something I'm not thinking of, but to me it'd make sense if the library boundary was the only place it let you do it.

Thanks, but an answer from someone that knows the language that they're talking about would be much more productive.

> Lately when I search for something like "recipe for borgelnuski" I get a page of links to sites with names like "Molly and Audrey" that first tell you a long story about their grandmothers pet kangaroo, then go through a very long a tedious explanations about ingredients, then vaguely go through the recipe step by step with a lot of pictures, but if you don't mind scrolling for 20 or 30 minutes, you get a very good recipe for borgelnuski.

So what you're saying is Google took you to a page that had a very good version of the thing you were searching for?

> FP is terrible at logging

Um, what? You can't just drop this without elaborating. I've never seen anybody have problems logging in a functional language.

You still haven't shown me any data to back up your assertion, but you're welcome I guess.

Here's one more file than you listed without BangPatterns enabled:

https://github.com/rainbyte/frag/blob/master/src/BitSet.hs

https://github.com/rainbyte/frag/blob/master/src/Command.hs

https://github.com/rainbyte/frag/blob/master/src/Curves.hs

BangPatterns is a normal language extension to have enabled, was this used heavily? (hint: it's not enabled on "every source file.") You listed two of 28 files there, I'm assuming to try to show that the vast majority of the code in that repository is in the IO monad? You went from "vast majority" from one file to now two files. I'm looking for objectivity here, as you seem to be into. Let's see some numbers. I think anyone that glances at that repo would need some convincing of your claims.

Render.hs is 211 of 5580 lines of Haskell in the repository, by the way.

> The vast majority of the code in that repository is in the IO monad and uses carefully placed “!” eager evaluation annotations.

This is the claim we're talking about. Since you're into facts, not subjective opinions, show some evidence that the vast majority of the code in the repository is in the IO monad and uses carefully placed "!" eager evaluation annotations. Just to be clear, you haven't done that yet. That's a fact, not a subjective opinion.

Yes, rendering is by definition I/O. That's also one file. You stated:

> The vast majority of the code in that repository is in the IO monad and uses carefully placed “!” eager evaluation annotations.

Do you have anything to back that up?

> The vast majority of the code in that repository is in the IO monad and uses carefully placed “!” eager evaluation annotations.

Looking through that repository, I believe we have extremely different definitions of "vast majority."

I find VS Code with the Haskell extension to be very good for displaying type signatures, code completion and navigation, etc. Holes (which are covered by the article) are the go-to way to see what's possible at the current location. You type an underscore in your code and the compiler tells you a bunch of information about what goes there including things you could put there that would typecheck.

It's absolutely not peculiar to Python, it's something that every single language implementation has to make a decision on one way or the other.

Here's an SO answer from 2008 about how to enable TCO in various C and C++ compilers: https://stackoverflow.com/questions/34125/which-if-any-c-com...

There are many things both you and I have never heard of before. That's normal.

I'm not sure, so here are a couple examples.

    def f() =
       g()

In a language implementation that doesn't optimize tail calls, the stack would look like the following after the call to g:

    g
    f
    main

In a language implementation that does optimize tail calls, the stack would look like this, because the result of f is whatever the result of g is so f is no longer needed:

    g
    main

If a language implementation doesn't optimize recursive tail calls, the following code will quickly overflow the stack and the program will crash:

    def loop() =
        do something...
        loop()

In a language implementation that does optimize recursive tail calls, this code can run forever because loop's stack frame gets replaced with the stack frame of the new call to loop.

The reason people want recursive tail calls optimized out is at a much higher level than anything to do with the actual CPU instructions being used, they just want to have a way to write recursive functions without worrying about the stack overflowing.

What's my age group, by the way?

Tail call optimization has nothing to do with optimizing for different CPUs, it's about dropping a function's stack frame when it's evaluating its return expression and its stack frame isn't needed anymore.

What problem? I'm looking for an example of where poor scalability has been a problem in a Haskell codebase.

I'd also be interested in a Haskell example.

You almost never use List<T>? Dictionary<TKey, TValue>? IEnumerable<T>?

> - oh, it's not "just a bind operator"

It is though, it's a function/operator that is defined in userland.

> - oh, you need special syntax

> - oh, you need a third party library that may or may not have support for that special syntax

No, you don't need either of these things. These just add a convenient syntax that desugars to the aforementioned bind function. These PPXs aren't special keywords specifically for async/await that had to be added into the language's syntax itself. Note that I know nothing about ReScript and this reply is not about ReScript, as that's not what this comment chain is about.

> Even Haskell has dot notation to chain functions since it's just so much easier to read and write...

Are you referring to function composition?

The people that would want to know about a new version of some software are surely already familiar with that software, no?

> Everyone who could possibly care about Lisp already knows everything they care to know about it.

I think you're in a bit of an HN bubble if you honestly believe this to be true.

> But what is purpose of `Maybe`?

In this case, it's to provide a better error message in case there's an empty list than `fromList` would provide.

> You never have to worry about that value in this case because... well... that's the benefit of using `Maybe`.

But you do, your entire program doesn't live in `Maybe` so at some point you have to check whether it's `Just a` or `Nothing`. Once again, the whole point of the post is to argue that getting out of the `Maybe` as close to parsing time as possible is preferable so you have a more specific type to work with after that. You also see right away what didn't parse instead of just knowing that something didn't parse, which is what would happen if you stayed in the `Maybe` monad for all your parsing.

The very first property testing library was written in Haskell, as far as I know.

Lexi absolutely understands how to properly use the Maybe monad. What you're saying to do here is the exact opposite of what this post is advocating for. You're talking about pushing the handling of the Maybe till later and the post is all about the advantages of handling it upfront and not having to worry about it anymore. You might want to read it one more time.

Just to elaborate a bit, in CL, numbers are FIXNUMs by default but are promoted to BIGNUMs if needed. CL also has rational and complex numbers, which it probably got from Scheme but I'm not familiar with that history.

The "Embeddable" in Embeddable Common Lisp means that you can embed your CL code in C programs, not that it's for embedded programming. Probably a poor naming choice because a lot of people have this perception about it.