Honestly, since I found Lemmy, I mostly ignore (or don’t even see) Reddit news. Rarely it still shows up when I search things, but I just view those without logging in and don’t vote / comment.

I think my Reddit account still exists, but I haven’t logged in since 3rd party apps stopped working. It took me a bit to find Lemmy, and I’m still not on it was frequently as I was on Reddit.

I deleted my Twitter account when they announced they would be training grok on my tweets. I hadn’t logged into it since Elmu mass-banned a bunch of journalists for retweeting the “Elon’s Jet” account. I decided Mastodon was more likely to not get between me and the journalists I wanted to see microblogs from.

I’m not hardcore. I an still well-entrenched in the Google ecosystem (primarily YT). I still have a Facebook account, and occasionally login to un-tag myself. I use Amazon Pay / Paypal whenever I can, tho I at least stopped paying for Prime when they decided to start putting ads in Prime Video stuff.

It’s like intraoffice e-mail.

That’s why Elmu wants to go to Mars.

I think the subway stabbing is the main focus of the Cracked video I linked. But, maybe it’s a different subway stabbing.

Honestly, I don’t like either programmability approach (vimscript/lua OR emacs-lisp), but I’ll probably just stick with neovim, because when I’m on a system without my configuration, I’ve more productive there, and I don’t want to learn enough emacs-lisp “APIs” to reproduce my somewhat small vim configuration.

“protect and serve” is copaganda, since SCOTUS ruled on https://en.wikipedia.org/wiki/Warren_v._District_of_Columbia in late 1981. “Fun” animated video to describe same: https://www.youtube.com/watch?v=jAfUI_hETy0

• In https://lemm.ee/comment/20947041 they claimed “implicit type coercion” and showed many examples; they did NOT claim “string concatenation”.
• However, that was in reply to https://lemmy.world/comment/17473361 which was talking about “implicit conversion to string” which is a specific type of “implicit type coercion”; NONE of the examples given involved a conversion to string.
• But also, that was in reply to https://lemm.ee/comment/20939144 which only mentions “implicit type coercion” in general.

So, I think probably everyone in the thread is “correct”, but you are actually talking past one another.

I think the JS behavior is a bad design choice, but it is well documented and consistent across implementations.

I think it’s less about type system, and more about lack of a separate compilation step.

With a compilation step, you can have error messages that developers see, but users don’t. (Hopefully, these errors enable the developers to reduce the errors that users see, and just generally improve the UX, but that’s NOT guaranteed.)

Without a compilation step, you have to assign some semantics to whatever random source string your interpreter gets. And, while you can certainly make that an error, that would rarely be helpful for the user. JS instead made the choice to, as much as possible, avoid error semantics in favor of silent coercions, conversions, and conflations in order to make every attempt to not “error-out” on the user.

It would be a very painful decade indeed to now change the semantics for some JS source text.

Purescript is a great option. Typescript is okay. You could also introduce a JS-to-JS “compilation” step that DID reject (or at least warn the developer) for source text that “should” be given an error semantic, but I don’t know an “off-the-shelf” approach for that – other than JSLint.

(.) is a valid expression in Haskell. Normally it is the prefix form of the infix operator . that does function composition. (.) (2*) (1+) 3 = ((2*) . (1+)) 3 = 2 * (1 + 3) = 8.

But, the most common use of the word “boob” in my experience in Haskell is the “boobs operator”: (.)(.). It’s usage in Haskell is limited (tho valid), but it’s appearance in racy ASCII art predates even the first versions on Haskell.

Oddly enough, in Haskell (as defined by the report), length is monomorphic, so it just doesn’t work on tuples (type error).

Due to the way kinds (types of types) work in Haskell, Foldable instances can only operate over (i.e. length only counts) elements of the last/final type argument. So, for (,) it only counts the second part, which is always there exactly once. If you provided a Foldable for (,) it would also have length of 1.

This is my favorite language: GHC Haskell

GHC Haskell:

GHCi> length (2, "foo")
1