I've been actively working on my language / compiler for a couple of years now (https://github.com/taolson/Admiran). My goal in its development was to learn in a deep sense how to efficiently compile a pure functional language down to low-level assembly-language, so I haven't used LLMs at all -- using them would negate the learning experience. Plus it's fun to puzzle through these things by yourself!
I actively use it for most programming, these days (command-line only), and use it every year during Advent of Code.
That may be true for functions which operate on a generic Monad typeclass, but typeclasses (Higher kinded types) aren't required to implement concrete Functor / Applicative / Monad instances for a particular type, e.g. Maybe:
fmap f Nothing = Nothing
fmap f (Just x) = Just (f x)
pure x = Just x
Nothing >>= f = Nothing
Just x >>= f = f x
Agreed. But there's a big difference between parametric polymorphism (List<A>) and ad-hoc polymorphism like typeclasses. It would be very painful to have to write a new list type for any kind of value type it might hold, but with monads you have many fewer distinct implementations (mainly just Maybe / Either / List / State / IO) and their actions are so different that you almost have to know exactly which monad you are using in the code, so "generic" code that can operate with any monad is less useful.
In a lazy language like Haskell, the order in which things are actually evaluated is f -> g -> h -> x, because arguments to a function are only evaluated when the are needed, rather than before they are called. But even so, I still prefer writing it as x |> h |> g |> f.
You're probably thinking of Ian Piumarta's COLA project (Combined Object Lambda Architecture), which had parts named after cola soft-drinks (Coke was a lisp-like language, Pepsi was a Smalltalk-like language, and Jolt was an early implementation of Coke):
Congrats to the Squeak 6.1 team! I was an early contributor to Squeak from when Alan Kay's group was at Apple (I see that SameGame, the first game implemented in Morphic is still in the image), and still enjoy following the progress of Squeak and all of its spinoffs.
Ocaml was very simple to program in to be honest, and has very minimal rules as well so i can be productive with the development of the language, Rust also used ocaml in it's early versions for bootstrapping
The registers could also be partitioned into fixed sizes and protected, to allow for a banked register file that allowed for amazingly fast context switches in RTOS systems.
> Well that was basically an am29000 but with an x86 instruction decoder front end.
The K5 was based upon a 29K-family design, but it was actually an un-released superscalar project code-named "Jaguar", rather than just a 29K with an x86 decoder.
.jpg){kind=link}
I actively use it for most programming, these days (command-line only), and use it every year during Advent of Code.
reply