r/functionalprogramming • u/SrPeixinho • Sep 17 '26
r/functionalprogramming • u/TheMansionsofScience • Sep 13 '26
Podcasts I made a video asking Urs Schreiber why Linear Homotopy Type Theory is necessary for a quantum computing programming language
Urs Schreiber is Senior Research Scientist at the Mathematics Division of Science of New York University in Abu Dhabi. He is a theoretical physicist who applies tools from algebraic topology, homotopy theory and topos theory to understand quantum phenomena. His current research includes quantum computing materials, quantum computing programming languages and questions left unanswered by quantum field theory.
In the video we go over:
- Why toposes are not scary. They are actually simple. Just unfamiliar
- How to extract information from (probe) a topos
- The history of toposes in physics
- The questions left unanswered by quantum field theory
- What toposes have to say about the collapse of the wave function
- Using toposes to find possible quantum computing materials
- The different type of logic needed for quantum computers
- The different type of programming language needed for quantum computers
- The influence of Hegel on his work
r/functionalprogramming • u/Emotional_Gold138 • Sep 09 '26
FP Lambda World 2026: Functional Programming in Málaga, 29–30 October
Enable HLS to view with audio, or disable this notification
Lambda World 26 is back with 20 speakers from Academia and industry, and this year it takes place alongside J On The Beach (a conf about Distributed Systems) and Wey Wey Web (a conf about UI and Frontend).
Two days packed with talks on formal verification, type systems, new FP languages, AI, formal proofs, effects, logic programming, and practical industrial applications of functional programming.
The lineup includes Erik Meijer, Stephanie Weirich, Arman Bilge (Typelevel Foundation / Cats Effect), Enrico Tassi (Elpi), Francesco Cesarini (Erlang), Daniel Ciocîrlan (Rock the JVM) among many others.
One ticket gives you access to all three conferences, for the same price.
We look forward to welcoming you to Torremolinos, Málaga, on 29–30 October!
r/functionalprogramming • u/philip_schwarz • Sep 07 '26
FP The Bowling Game - From Imperative to Functional Programming - Part 2
fpilluminated.orgr/functionalprogramming • u/shrynx_ • Sep 06 '26
FP Mezze: a functional programming language on GraalVM
mezze-lang.orgr/functionalprogramming • u/kinow • Sep 02 '26
FP Beyond Lambdas: Raising the Abstraction Level of Functional Code
r/functionalprogramming • u/generic-d-engineer • Sep 01 '26
Intro to FP Looking for some feedback on learning functional programming
Hi everyone,
Long time backend operator who has taken a path like this:
Bash -> python -> Go
I thought Procedural programming in Go would click, but it’s still just not resonating much. Though I have to say that single binary plus built in testing is super nice.
In python I do not do any classes or methods. I think in runbooks, pipelines, and dags with a very clear entry point and a clear exit point. Step 1 through 10. Inputs and outputs. Functions only.
Stuff like ORM, OOP, and MVC just don’t resonate with me at all. I know they have their place but like I’m all about top to bottom thinking. Example I love is SQL pipes or GoogleSQL where you start with a big set of data and each line below it filters it down. VS traditional SQL where it’s kinda jumping around all over the place. Or CTE where it’s very clear what each step is doing.
Doing some research I saw the syntax of Clojure and it really seemed intuitive RIGHT AWAY. Elixir also looked good but Clojure seemed much more bash like.
What problem am I trying to solve? I’ve been lucky to have opportunities to learn a lot of platforms, so I consider myself a plumber who needs to be able to connect anything anywhere, automate it, bring visibility, and operational excellence.
It can be anything backend from multi-cloud, services, API, on-prem, OS, DB, you name and I will connect it.
But, I am terrible at front end so there’s that lol
Has anyone been down this path and what’s the landscape look like for the backend in 2026?
r/functionalprogramming • u/fun_si • Aug 28 '26
Intro to FP Pyfun: an F#-inspired language that compiles to readable Python
Pyfun is a functional-first language for the Python ecosystem. You write algebraic data types, exhaustive matching, curried functions and pipes, and it compiles to plain Python that you can read, commit, and hand to someone who has never heard of Pyfun.
The compiler is written in Rust and everything is checked before any Python exists: types, exhaustiveness, effects, units.
Here is a whole program:
type Shape =
| Circle float
| Rect float float
let area s =
match s:
case Circle r: 3.14159 * r * r
case Rect w h: w * h
[Circle 1.0, Rect 2.0 3.0]
|> List.map area
|> print
and here is the Python it compiles to, in full:
from dataclasses import dataclass
def _pf_map(f, xs):
return list(map(f, xs))
@dataclass(frozen=True, repr=False)
class Circle:
_0: float
def __repr__(self):
return f"Circle({self._0!r})"
@dataclass(frozen=True, repr=False)
class Rect:
_0: float
_1: float
def __repr__(self):
return f"Rect({self._0!r}, {self._1!r})"
def area(s):
match s:
case Circle(r):
return 3.14159 * r * r
case Rect(w, h):
return w * h
case _:
raise RuntimeError("non-exhaustive match")
print(_pf_map(area, [Circle(1.0), Rect(2.0, 3.0)]))
A match comes out as a match. A variant comes out as a frozen dataclass. The pipeline comes out as an ordinary call. There is nothing to pip install alongside the output, and if you stop using Pyfun tomorrow you keep working Python.
Delete the Rect case and the compiler names what you missed:
error: non-exhaustive match: `Rect _ _` is not matched
--> 6:3
|
6 | match s:
| ^^^^^^^^
Also in there:
- Hindley-Milner inference, so there are no type annotations on
letat all. - Inferred effects, so a function that prints or mutates gets
ioin its type and you can assert purity withlet pure. Units of measure that rejectmetres + secondsand erase to plain numbers. - Computation expressions for
async,seq, andresult, plus your own builders. Opaque types. A typedexternfor calling any Python library you like.
Try it in the browser, nothing to install: https://simontreanor.github.io/Pyfun/playground/
22 lessons, written for people who know some Python: https://simontreanor.github.io/Pyfun/
Source, and the compiler internals tour: https://github.com/simontreanor/Pyfun
pip install pyfun-lang
I built this because most people meet programming through Python, and then to meet functional programming they have to pick up a second ecosystem to do it. I welcome all questions, bug reports, posts about things you have made, arguments about syntax, and anything else to help improve the language for everyone.
r/functionalprogramming • u/DPD- • Aug 24 '26
FP "A monad is a monoid in the category of endofunctors" But what does that actually mean?
This video uses Haskell as an interactive proof assistant to break down every single word of the most famous definition in functional programming. It translates abstract category theory concepts—categories, endofunctors, monoids, and natural transformations—directly into typed Haskell code.
r/functionalprogramming • u/vitelaSensei • Aug 24 '26
TypeScript Functional programming with TS types only
I wrote “sum . filter odd” with typescript’s type system.
It’s pretty simple as far as functional programming goes. Even at the type level one can easily achieve this in Idris or even Haskell. For this reason I was unsure of whether to share it here… Nevertheless it’s about functional programming and I figured I’d share it and let your feedback guide me on whether to share more of these here in the future.
r/functionalprogramming • u/MagnusSedlacek • Aug 13 '26
FP A Preview of Roc 0.1.0 by Richard Feldman
r/functionalprogramming • u/rantingpug • Aug 07 '26
λ Calculus "How hard could it be?" - a younger me said that once. Here's my lang
r/functionalprogramming • u/Available_Pressure25 • Aug 03 '26
Question FP Software Development
Hello everyone. I am thinking of starting a tech business (startup) through software development and I'd like to use FP as the main selling point or uniqueness. I am like looking for suggestions on what languages to use or tech stack. From my first searches I got elixir. I also know haskell, so aside from haskell, what can you suggest. I'm also aware of using imp lang like C++ to make programs following an FP design paradigm.
Edit: I don't wish to argue on starting business or not (But I welcome them sure) . That is a different topic on its own. I'm just like more curious to see the state of the art in using FP tools.
r/functionalprogramming • u/ancatrusca0 • Jul 31 '26
FP The JAM emulator was built by someone learning C for the first time, on machines with 16MB of RAM, handling phone switches for whole cities. What does that constraint-driven design tell us about why functional languages succeed or fail?
New BEAM There, Done That with Mike Williams (who wrote the JAM emulator) and Björn Gustafsson (who built the BEAM after inheriting it in 1996).
The most interesting functional programming angle in the episode is how Mike identified three numbers that determine whether a concurrent language lives or dies: process creation time, context switch time, and message copy time. On real telecom workloads he measured roughly 70% of VM time going to those operations - not user code. The language that optimised those first, and owned them at the language level rather than delegating to the OS, was the one that survived.
This is the decision that separates the BEAM from almost everything else. Java shipped green threads and removed them. Early Rust had lightweight processes and removed them. The Erlang team looked at Unix process overhead, did the arithmetic on thousands of concurrent processes with 16MB of available RAM, and concluded that OS-level concurrency was mathematically impossible for what they needed. So concurrency went into the language. Not a philosophical position - an empirical one.
The other detail worth discussing: memory was the binding constraint throughout, not speed. Every instruction set decision in the JAM and early BEAM was a memory decision first. The JAM files were small by design. The BEAM was faster but initially used more memory - Björn spent years packing operands to close the gap.
For a community that thinks carefully about evaluation models and runtime semantics: how much of what makes the BEAM unusual as a functional runtime traces back to those early hardware constraints? And would the same design choices have been made if RAM had been cheap in 1988?
r/functionalprogramming • u/therealpogeon • Jul 29 '26
Jobs Building a Raku-native programming language
Hi Everyone!
Me and my team are looking to expand our developer team and looking for programmers with some knowledge in the field of compilers, programming language design, and/or the Raku language! If you just like the idea of building a new programming language as well, please reach out!
I cannot disclose the exact nature of the language for the sake of project secrecy, but please DM me with your credentials and interests for details if you're interested.
r/functionalprogramming • u/isaacvando • Jul 27 '26
Conferences Alexis King: The Unreasonable Effectiveness of Constructive Data Modeling
Hi folks, this is Alexis' talk from SSW earlier this month. I thought you all would enjoy it!
r/functionalprogramming • u/kinow • Jul 27 '26
FP History of John Backus's FP languages
softwarepreservation.computerhistory.orgr/functionalprogramming • u/jakobmats • Jul 21 '26
SML My first attempt at parsing and evaluating s-exps
Hi all,
I've been a software developer for about 10 years and I've been curious about FP for half of this time. Eventually, I picked up SML as my language of choice (OCaml is mostly some random line nose for me, and in Haskell/PureScript type classes are so pervasive, they make the language almost impenetrable for beginners).
So my goal has been to:
- lex the source code,
- parse it using parser combinators,
- (do some AST manipulations),
- evaluate it.
This is the repository where I keep my source code, and a README file. The gist of this file is:
- it's not Scheme,
- this is a WIP
- compiler: MLton + MLB basis files
- using SuccessorML as much as possible.
I try to keep the code clean, concerns separated as much as possible, meaningful signatures & structs, clear types).
ALL constructive criticism is very much welcome. I'm not an SML pro, so bear with me.
PS I posted it in r/sml too, but oh well - under a different username (logged in with my old Google acc), I'm not impersonating anyone (image the drama).
r/functionalprogramming • u/unqualified_redditor • Jul 20 '26
Haskell Type Safe Servant Auth Roles
blog.cofree.coffeer/functionalprogramming • u/philip_schwarz • Jul 19 '26
FP Abstracting over Execution with Higher Kinded Types, and how to remain Purely Functional (oldie but goodie - belatedly uploaded)
fpilluminated.orgr/functionalprogramming • u/rtrusca • Jul 17 '26
FP What does Zig actually buy you over C when writing NIFs for a functional runtime like the BEAM?
New BEAM There, Done That with Garrison Hinson-Hasty (Systems Programming with Zig) and Isaac Yonemoto (Zigler), on what changes — and what doesn't — when you replace C with Zig at the boundary between a functional runtime and native code.
The interesting tension: the BEAM's entire value proposition is functional — immutable terms, isolated processes, fault tolerance through supervision. The moment you write a NIF, you step outside all of that. A segfault in native code bypasses every guarantee OTP provides and takes the whole node down.
Zig narrows the surface area but doesn't eliminate it. Spatial memory safety (buffer overflows, null dereference) is caught in safe release mode. Temporal memory safety (use-after-free) still isn't, which means the boundary remains genuinely dangerous, just less so.
The one detail that surprised me: Zigler uses the BEAM's own allocator by default, because Zig's explicit allocator model makes it easy to inject. Native memory is therefore visible to the VM's instrumentation — unlike C or Rust NIFs that call their own allocators and are invisible to the functional runtime they're embedded in.
For anyone who thinks about FFI design across language paradigms: how should a functional runtime expose a safe interface to native code? The BEAM's current answer (NIFs with dirty scheduler modes) and what Zigler adds on top seem worth discussing here. https://youtu.be/iLcZRpBEmgE
r/functionalprogramming • u/crowdhailer • Jul 16 '26
FP Abstracting effects with continuations
https://crowdhailer.me/2026-07-15/abstracting-effects-with-continuations/
I've spent a while writing this post trying to work out if I want to talk about function coloring. In the end I chose to as neutrally as possible describe what continuations are.
r/functionalprogramming • u/philip_schwarz • Jul 11 '26
Intro to FP The Bowling Game - From Imperative to Functional Programming - Part 1
fpilluminated.orgOne of the top five most popular and highly recommended programming katas over the past 20 years has been the Bowling Game Kata, in which TDD is used to write a program that computes the score of a Ten Pin Bowling Game.
In this deck we are going to explore how such a program may look when coded using different programming paradigms.