Notices by Anupam 《ミ》λ≡ (haskman@functional.cafe), page 3

It's not a new year's resolution - I break those as a rule - I'm going to be fitter in #2024

#HappyNewYear

Are there any good magazines for children (pre-teen / teens) in #India?

"Target" was the magazine that defined my childhood. I still vividly and bitterly remember the day the #IndiaToday group shut it down and started the ridiculous "TeensToday" which was full of fashion and celebrity gossip.

I would pay good money to get my hands on a few issues of Target.

#Nostalgia

https://en.wikipedia.org/wiki/Target_(magazine)

Occasionally hopping back to #Twitter to see what's up.

#Cryptocurrency grifters every..where..

The world if, instead of `data`, `type`, and `newtype`, we had `type struct`, `type alias`, and `type wrapper`

#Haskell

Bring back the small internet

@BoydStephenSmithJr @hongminhee Tooling with #PureScript is *way* better than #Haskell's. IDEs work flawlessly, and spago is more like cargo than cabal. I find PureScript development much more soothing than when I have to write Haskell.

The only caveat is that the tooling is currently being upgraded (new registry, spago-next) so there may be some teething troubles if you use the new infra.

@hongminhee How does the "choose language" thing work? I just followed you using the web interface but didn't get any options to choose languages.

The way I write #Rust is by first thinking of the code in #Haskell and then translating it to Rust, while praying that the #BorrowChecker doesn't get in the way!

#FunctionalProgramming #RustLang

Coming from a #Haskell background, I'm very sad that #Rust makes it so hard to avoid mutable references.

I don't want to mutate things in place, I want to write functions that consume their arguments and then return an entirely newly constructed result, but that will often land you in trouble in Rust. This is not about performance, I mean you will find it difficult to even structure your programs.

For example, there's an entire cottage industry of *solutions* around updating a mutable value wholesale, i.e. where you compute the replacement by consuming the original value.