functional programming

Bilingual

Show HN: Fuse – statically typed functional programming language
2 months ago
- Fuse is a statically typed, purely functional language with higher-kinded types and ad-hoc polymorphism.
- It compiles to the GRIN whole-program optimizer, producing LLVM-generated native code.
- Features: statically typed (based on System F with higher-order polymorphism, algebraic data types, generics, traits).
- Purely functional: every function is pure, supports pattern matching, higher-order functions, and do notation.
- Type inference: bidirectional type checking, only function type signatures required.
- Clean syntax: inspired by Rust, Python, Scala, and Haskell, using indentation-based blocks and lambda expressions.
- Compiles to GRIN: whole-program optimization and LLVM code generation for fast, small native binaries.
- Installation: use curl command on Linux (x86_64) or macOS (ARM64).
EYG: A Programming Language for Humans
2 months ago
- EYG (Eat Your Greens) is a statically typed functional programming language designed for makers (non-professional developers).
- It aims to remove infrastructure and deployment complexities so users can focus on describing problem logic.
- Key features include sound type inference without upfront type definitions, hashed dependencies to avoid dependency hell, and effect typing for side effect management.
- The language targets home-cooked software like glue problems, personal dashboards, and automations.
- The author's measure of 'better' is how well the language enables makers to build reliable, sharable programs.
History of John Backus's functional programming project (draft)
2 months ago
- John Backus began exploring functional programming languages before 1969, motivated by the software crisis and his earlier success with FORTRAN.
- He developed the Red language (1972) as a variable-free, reduction-based system using combining forms and function composition.
- His 1977 ACM Turing Award lecture introduced FP (Functional Programming) and an algebra of programs, criticizing the von Neumann bottleneck in conventional languages.
- The project involved collaborations with researchers like Dines Bjørner, Paul McJones, John H. Williams, and Edward L. Wimmers, leading to languages such as FL.
- Despite mixed reactions from Dijkstra and others, Backus's work influenced many areas including parallel computation, database querying, and VLSI design, with over 2000 citations by 2026.
A Road to Lisp: Which Lisp
2 months ago
- Lisp is a family of programming languages with many dialects, unlike single-language evolutions like Python or Java.
- Beginners should focus on learning Lisp's programming concepts rather than worrying about which dialect to choose, as switching later is relatively easy.
- Common Lisp (CL) is mature, standardized since 1994, with multiple implementations like SBCL, offering high performance, a powerful REPL, and comprehensive features including CLOS for OOP.
- Clojure is a modern Lisp on the JVM, emphasizing functional programming with immutable data structures, and is widely used in production by companies like Nubank and Netflix.
- Racket is a language-oriented dialect ideal for creating new languages, with features like hygienic macros and Typed Racket, and comes with the DrRacket IDE.
- Elisp is specialized for customizing Emacs and extends editor functionality in real time.
- Choosing a dialect depends on needs: Clojure for modern syntax and JVM integration, Common Lisp for native performance and interactivity, Racket for language design and GUIs, and Elisp for Emacs customization.
Abstracting Effects with Continuations
2 months ago
- Continuations abstract over computation details like asynchrony or error handling.
- They allow representing 'before and after' relationships generically across effect types.
- Filinski (1994) showed continuations can express any monad, such as Result or Promise.
- A generic task using continuations separates business logic from effectful fetching.
- Runners (interpreters) implement specific effects like fallible or async computations.
- This approach avoids duplicating logic for different effect combinations.
Gleam for Python Programmers
2 months ago
- Gleam is a programming language designed for Python programmers to learn functional programming concepts.
- The curriculum includes lessons from basics like types and functions to advanced topics like state machines and property-based testing.
- There are several project-based lessons, such as building a key-value store, a virtual machine, and web APIs.
- The appendices emphasize a pragmatic approach: start where you are, use available resources, and help others when possible.
Prism: An Impure Functional Language With Typed Effects
3 months ago
- Prism is a functional programming language that models effects using modern type systems inspired by OCaml 5, Haskell, and Koka, emphasizing typed and composable effects.
- Effects are handled via algebraic effect handlers, allowing operations like yield, choose, and reject to be defined and managed with typed rows, enabling composition without monad transformers.
- The language unifies multiple language features (exceptions, generators, lenses, mutable state, failure handling) under one mechanism using effect rows, providing zero-cost abstractions via evidence passing and Perceus reference counting.
- Prism supports modern type features including higher-rank polymorphism, ad-hoc polymorphism with type classes (Lean-style instances), and row polymorphism for effects, enabling polymorphic functions over effects.
- It compiles to LLVM IR and MLIR with a tiny C runtime, uses deterministic reference counting for memory management, and includes a Lean 4 model for formal verification and replayable execution.
- Prism includes a web-based playground via WASM, allowing interactive experimentation, and is designed as a proof-of-concept that prioritizes typed effects and compiler optimizations over purity.
Functional Programming in hica
3 months ago
- Functional programming in hica emphasizes composing functions rather than changing state, with everything as an expression.
- Immutability is default using 'let'; mutation uses 'var' locally, promoting pure functions without side effects.
- Functions are first-class values, supporting higher-order functions, closures, and combinators like map, filter, and fold.
- Key operations include flat_map for flattening lists and and_then for Maybe/Result, with the pipe operator '|>' for chaining.
- Algebraic data types (structs and enums) model data, with exhaustive pattern matching and safe failure handling via Maybe and Result.
- Recursion is used for tree-shaped data, with ADTs enabling recursive structures like Tree.
- The '?' operator allows early returns in fallible functions, constrained by return type annotations and wrapper type matching.
- A program example integrates structs, pure functions, closures, pipes, and pattern matching to process student data.

functional programming

Show HN: Fuse – statically typed functional programming language

EYG: A Programming Language for Humans

History of John Backus's functional programming project (draft)

A Road to Lisp: Which Lisp

Abstracting Effects with Continuations

Gleam for Python Programmers

Prism: An Impure Functional Language With Typed Effects

Functional Programming in hica