Hacker News with Generative AI: Functional Programming

Demystifying monads in Rust through property-based testing (sunshowers.io)
In programming pedagogy, monads have a place as a mystical object from the functional programming world that’s hard to understand and even harder to explain.
Jill – a functional programming language for the Nand2Tetris platform (github.com/mpatajac)
Jill is a functional programming language built for the Nand2Tetris platform, as an alternative to the original Jack high-level language.
Having an Effect (2016) (okmij.org)
This research has been a journey following the tantalizing lead: the founding papers on monads, monad transformers, free monads and extensible-effects were all about extensible interpreters.
Is NixOS truly reproducible? (luj.fr)
Build reproducibility is often considered as a de facto feature provided by functional package managers like Nix. Although the functional package manager model has important assets in the quest for build reproducibility (like reproducibility of build environments for example1), it is clear among practitioners that Nix does not guarantee that all its builds achieve bitwise reproducibility. In fact, it is not complicated to write a Nix package that builds an artifact non-deterministically:
Turner, Bird, Eratosthenes: An eternal burning thread (cambridge.org)
Functional programmers have many things for which to thank the late David Turner: design decisions he made in his languages SASL, KRC, and Miranda over the last 50 years are still influential and inspirational now. In particular, Turner was a strong advocate of lazy evaluation and of list comprehensions. As an illustration of these techniques, he popularized a one-line recursive “sieve” to generate the infinite list of prime numbers.
Invisible State Machines in Rust: Navigating Rust's Impl Future Return Types (hackintoshrao.com)
"What Type Is This, Anyway?"
Dualities in functional programming (dicioccio.fr)
Functional programming has taught me to simplify superfluous concepts: identify what are primitive concepts and what are constructions on top these primitives. The constructions themselves need not be multiplied out of proportion: it is better to stick to few ways of combining entities and concepts. Overall, I think I found some internal peace with programming languages when I could recognize enough of such primitives and how to make use of them in various programming styles.
Hyperbole: Haskell interactive serverside web framework inspired by Htmx, Elm (github.com/seanhess)
Create interactive HTML applications with type-safe serverside Haskell. Inspired by HTMX, Elm, and Phoenix LiveView
A Proper x86 Assembler in Haskell Using the Escardó-Oliva Functional (vmchale.com)
Writing an assembler turns out to be an interesting example: one needs to calculate distances between jumps and their target labels, and the target may appear after the label. It turns out that one can write a one-pass assembler using the tardis monad or in Curry, using logic programming.
Open Dylan (opendylan.org)
Dylan is an object-functional language originally created by Apple for the Newton.
Show HN: Pyper – Concurrent Python Made Simple (github.com/pyper-dev)
Pyper is a flexible framework for concurrent and parallel data-processing, based on functional programming patterns. Used for 🔀 ETL Systems, ⚙️ Data Microservices, and 🌐 Data Collection
Gleam v1.7 (gleam.run)
Gleam is a type-safe and scalable language for the Erlang virtual machine and JavaScript runtimes. Today Gleam v1.7.0 has been published, featuring an array of wonderful improvements. Let’s take a look!
Fold-... and Monoids (blogspot.com)
Gleam v1.7 (gleam.run)
Gleam is a type-safe and scalable language for the Erlang virtual machine and JavaScript runtimes. Today Gleam v1.7.0 has been published, featuring an array of wonderful improvements. Let’s take a look!
K/Simple in OCaml (uwaterloo.ca)
Rohlang3: A point-free, homoiconic, and dependently typed "SK calculus" (rohan.ga)
I’ve long been obsessed with minimalistic languages that still manage to have expressive power. My usual approach: start with a bare-bones combinator calculus (like SK), then keep adding “one more extension” until it looks suspiciously like a full-blown typed language. rohlang3 is exactly that experiment. It’s a small language built in Rust that tries to be point-free, homoiconic, and (somewhat) dependently typed, all on top of an SK-like foundation—plus reflection, partial evaluation, and a weird environment reordering system.
Overloading the lambda abstraction in Haskell (2022) (acatalepsie.fr)
Into CPS, Never to Return (bernsteinbear.com)
CPS, or continuation-passing style, is an intermediate representation for programs, particularly functional programs. It’s used in compilers for languages such as SML and Scheme.
F*: A proof oriented general purpose programming language (fstar-lang.org)
F* (pronounced F star) is a general-purpose proof-oriented programming language, supporting both purely functional and effectful programming.
Better Scala Builds with the Mill Build Tool, Functional Scala Online 2024 [video] (youtube.com)
How types make hard problems easy (mayhul.com)
Over the last couple years, my programming brain has become increasingly warped around types, functional programming principles & Typescript.
Relational Lisp – AP5 (ap5.com)
AP5 is an extension to commonlisp which allows users to "program" at a more "specificational" level.
Fault Report – and alternative to Result in F# (blasuc.ci)
This blog post is late. Not just days or weeks late. And not just because I promised Vlad and Jimmy I'd write up something back in early 2023 (sorry, gents). No, it's very much later: the approach described herein should have been presented to the FSharp.Core maintainers way back in 2016. After all, that's where this all began.
Array Languages for Clojurians (2020) (appliedscience.studio)
A discussion in the Clojure data science Zulip led me to Slobodan Blazeski’s enlightening article Array languages for Lisp programmers in the journal of the British APL Association. He quotes Alan Perlis:
John Carmack on Functional Programming in C++ (sevangelatos.com)
Probably everyone reading this has heard “functional programming” put forth as something that is supposed to bring benefits to software development, or even heard it touted as a silver bullet.
Ad-Hoc Effects in Rust (hannobraun.com)
Let's talk about Rust today, because it has ad-hoc effects, no principled effect system, and has real problems because of that.
The humble for loop in Rust (startifact.com)
Rust has some really nice functional programming facilities built in, all around an iterator concept.
Show HN: Lfi – a lazy functional sync, async, and concurrent iteration library (lfi.dev)
lfi is a lazy functional sync, async, and concurrent iteration library
Functional Core, Imperative Shell – Scott Wlaschin (youtube.com)
A Novel Idea About `Functor` in Rust? (wolfgirl.dev)
So. In my last post about this compiler project, I wrote out the following trait definition, explaining that it’s what I was using to do type-safe AST transformations: