Tlen Lisp ❲Direct Link❳

(defn add [x : Int, y : Int] -> Int (+ x y)) But this also works:

But after a weekend of tinkering, I’m genuinely excited. Tlen Lisp isn’t trying to be the fastest or the most purely functional. Instead, it’s focused on something most Lisps overlook: . What Makes Tlen Different? Tlen Lisp keeps the classic homoiconic syntax (function args...) but introduces a few opinionated changes: 1. Pipeline-first semantics Inspired by Clojure’s -> and Elixir’s |> , Tlen makes the pipeline operator a core syntactic element , not just a macro. tlen lisp

I’ll admit it — I’m a sucker for Lisp dialects. Over the years, I’ve spent countless hours with Common Lisp, Clojure, Racket, and even Emacs Lisp (begrudgingly, at times). So when I stumbled across Tlen Lisp — whose name comes from the Polish word for “oxygen” — I was curious. Another Lisp? Really? (defn add [x : Int, y : Int]

Have you tried Tlen? What’s your favorite “modern Lisp”? Let me know in the comments. What Makes Tlen Different

(-> data (filter even?) (map square) (reduce + 0)) But here’s the twist — in Tlen, every function call is implicitly pipeable. You can write:

(compute-stats data | log-result | write-to-db) It reads left-to-right, no nesting, no parentheses confusion. Like Clojure, Tlen’s data structures are persistent and immutable. But Tlen adds a lightweight ! annotation for local, controlled mutation when it actually makes code clearer.

(let !counter 0 (each! [1 2 3] (fn [x] (set! counter (+ counter x)))) counter) ;; returns 6 The ! is a visual signal — no hidden side effects. Type systems are great, but they can interrupt flow. Tlen introduces soft types — optional, gradual, and runtime-erasable . You can add them when you need confidence, ignore them when prototyping.