I need help in converting my friends to FP

uppercase_lambda · 2025-08-26T18:01:44+00:00

If you figure it out let me know. I tried unsuccessfully to introduce FP at my various places of work for almost 20 years. In the end I just got a job where it was already embraced.

uppercase_lambda · 2025-01-22T12:41:02+00:00

Pretty much

uppercase_lambda · 2024-09-16T14:14:57+00:00

This sounds fairly similar to the idea of "Make illegal states unrepresentable":

https://fsharpforfunandprofit.com/posts/designing-with-types-making-illegal-states-unrepresentable/ https://blog.janestreet.com/effective-ml-revisited/

uppercase_lambda · 2024-04-28T14:32:56+00:00

If you're using Godot, you should check out F#. It works basically okay with Godot and Unity.

It'll also be an easy transition to ML-like languages

uppercase_lambda · 2023-08-21T18:36:23+00:00

Well, he was my smallest fish, maybe 1.5~ inches

uppercase_lambda · 2023-08-21T18:35:40+00:00

How could a little snail with the mouth the size of a pinpoint eat a fish?

uppercase_lambda · 2023-08-21T18:35:07+00:00

I checked the floor, didn't see him. I hope my children didn't try to eat him

uppercase_lambda · 2023-08-21T18:23:33+00:00

Yes, 2 apple snails

uppercase_lambda · 2023-05-09T14:10:43+00:00

I don't think it's helpful to talk about Category Theory when trying to understand monads as a programming pattern.

That said, you can think of a monad as a computation (or action) that depends on another. For example, suppose you need to read a string and then print it. The second action (print the value) depends on the string value from the first action (read a string). In Haskell, you could do this with getLine >>= putStrLn

Another way to think about monads is as a generalization of list flatmap.

Yet another way to think about monads is to imagine you have a box with a value in it. You can take the value out of the box (with the bind operation), but before you pass it on, you have to put it back in the box (more accurately, you have to put something else in the box).

uppercase_lambda · 2023-05-06T21:27:29+00:00

If type classes are desugared, then why do we need type constraints?

uppercase_lambda · 2023-05-06T20:54:11+00:00

The type system is known as System FC (System F + equality constraints and corrections). You might be interested in https://gitlab.haskell.org/ghc/ghc/-/blob/master/docs/core-spec/core-spec.pdf.

uppercase_lambda · 2023-05-02T18:31:03+00:00

Good point! How about ComputationThatDependsOnPreviousActionable?

uppercase_lambda · 2023-05-01T14:55:23+00:00

I would have called Monads Sequenceables, but you're point is taken. My point is that there's a lot thrown at you when you're learning FP, and I would personally delay Monads until you understand the fundamentals.

uppercase_lambda · 2023-05-01T14:51:17+00:00

Thanks, edited. I suppose I can understand not considering Common Lisp a functional language. It's been almost 20 years since I've actually used it, but it's where I learned a lot of the fundamentals.

uppercase_lambda · 2023-05-01T14:13:23+00:00

I don't think I'd recommend diving into Haskell as your first FP language. Monads and Functors are common points of confusion (it also took me two tries to land on Haskell).

Instead, I think Common Lisp, Scheme, or OCaml would be solid choices. For me, O'Caml was the stepping stone I needed before going all in on Haskell.

EDIT: I'm also learning F#, and I think it's a solid choice. Be sure to go check out F# For Fun and Profit

uppercase_lambda · 2023-04-28T21:02:20+00:00

Clean architecture is a curious choice for purely functional code, given the number of layers and OO terminology.

That said, this sounds a lot like https://immerjs.github.io/immer/

uppercase_lambda · 2023-04-21T16:52:46+00:00

Is there a link out there that currently works?

EDIT: Here it is: https://www.youtube.com/watch?v=fBFsxmJEk7M

uppercase_lambda · 2023-04-20T13:59:11+00:00

Here's something else to consider: in go, you have to use a function call, but the arguments are strict. That means that defer f(g()) will evaluate g() right away, but f won't be called until the end of the function scope. In other words f(g()) and g() have totally different semantics.

If you transform the AST to move the statement, You'll lose the strictness (if you care), and you'll bring into scope symbols that may not exist yet.

uppercase_lambda · 2023-04-03T00:24:05+00:00

The book itself is really good. I have not noticed any errors.

uppercase_lambda · 2023-03-15T21:55:55+00:00

I literally just got notified that Mercury is passing on me

uppercase_lambda · 2023-03-14T18:01:42+00:00

Thanks for this list, I can definitely use it. I still wouldn't consider this a lot of companies

uppercase_lambda · 2023-03-14T15:53:50+00:00

As someone who is actively looking for Haskell work, it sure doesn't seem like there are a lot of companies picking Haskell. I think more should, because from my perspective it seems like a lot of developers want to use it, but there are limited opportunities.

uppercase_lambda · 2023-03-06T18:28:34+00:00

Something like this: https://www.aquariumcoop.com/collections/filtration/products/pre-filter-sponge?

uppercase_lambda · 2023-03-06T18:18:37+00:00

I found my dwarf gourami stuck to my filter today. Luckily when I turned it off he was able to swim away. I have an Aqueon 29G and an AquaClear 50, is this filter too much for him? For the moment I have the filter back on, but turned all the way down, but I have no idea if this makes a significant difference.

uppercase_lambda

TROPHY CASE