#ReleaseWednesday — Extracted & extended the LISP-like DSL from an existing #ThingUmbrella example[1] as new small package for better/direct re-use in other projects:

https://thi.ng/lispy

The core language is kept intentionally minimal, aimed at simple sandboxed data transformations/derivations, small code snippets/expressions in GUIs or config settings. However, the language is very easy to extend/customize with new functions or control flow constructs etc. Currently, the language is interpreted and has the following builtins (see screenshots). There's no macro support so far (and not sure if that's even desired here)...

[1] The original #HowToThing example browser REPL this was extracted from (and which has now been updated to use the new package):

https://demo.thi.ng/umbrella/lispy-repl/

#ThingUmbrella #Lisp #DSL #FunctionalProgramming #REPL

#programming #gamedev #devlog #commonLisp #series #lazyEvaluation #functionalprogramming https://screwlisp.small-web.org/lispgames/cl-series-for-game-logic/ #lispgamejam
Since cl-series generates native common lisp code by working at macro expansion time, I consider it suitable for my software individuals (who want only clos-less common lisp and their own logic (which they have an introspective theory of).

In particular, I use series to cut out rectangular subsequence of sequences -s

SERIES DOC UPDATE FROM RTOY https://gitlab.common-lisp.net/rtoy/cl-series/-/wikis/Series-User's-Guide

#MoonBit looks like a really interesting new #ProgrammingLanguage

https://www.moonbitlang.com/

Especially its functional, data-oriented design and #WASM support stand out to me.

Looks _a lot_ like #Rust, but more functional in style.

It is expected to reach 1.0 this year.

This took me three months (a month longer than I had hoped), but I finally have merged it into the main branch!

This patch rewrites the Emacs Lisp lexer and parser in Scheme using Scheme code that is 100% compliant with the #R7RS standard, so it should now work across all compliant Scheme implementations. Previously the old parser relied on #Guile -specific regular expressions.

This patch also implements a new feature where a stack trace is printed when an error occurs. This of course makes debugging much, much easier. Previously the old parser did not keep track of where code evaluation was happening, it simply produced lists without source location information. The new parser constructs an abstract syntax tree (AST) and source locations are attached to the branches of the tree which can be used in error reporting and stack traces.

Next I will make whatever minor tweaks might be necessary to get my Emacs Lisp interpreter run on other Scheme implementations, in particular MIT Scheme, Gambit, Stklos, and Gauche. I would also like to try to get it running on Chicken and Chez, although these are going to be a bit more tricky.

Then I will continue with the task of implementing a new declarative GUI library.

Andy is convinced that functional programming isn’t boring. Listen to find out if he’s right!

https://www.linuxdevtime.com/linux-dev-time-episode-123/

The minimal megaparsec tutorial. ~ Clément Hurlin. https://www.tweag.io/blog/2025-04-24-minimal-megaparsec-tutorial/ #Haskell #FunctionalProgramming

F* (fstar) Interactive Tutorial:

https://fstar-lang.org/tutorial/

I'm only like 10% into the tutorial, but this language is CRAZY (fun)!

I try to learn the fundamentals of it, so I can use the backend of it in #Aeneas... so I can ultimately formally verify my #Rust crate (former attempts with #Creusot and #Kani failed for me).

Aeneas:
https://github.com/AeneasVerif/aeneas

See part two of toot for a toy example of proving function equivalence

1/2

Added a new convenience transducer for clipping and binning values, e.g. as preparation step for histogram generation whilst working in the REPL. New release forthcoming. A small code example attached (actually taken from the doc string of the new `binned()` transducer).

Resources for learning and using #recursion schemes:

https://github.com/passy/awesome-recursion-schemes

Come and see me talk about #FunctionalProgramming in #Java at #Devoxx UK in May?

Today's Gren Twig is about Pretty Nice, my full stack web framework for Gren:

https://www.youtube.com/watch?v=gZCOZ9tuArU&list=PLflA5Q354D42Zxi6KiLmNVNzQHINQ51U-&index=21

Today's Gren Twigs video is about Gren Tui, a package for writing terminal UIs in a pure, functional, type-safe way using The Elm Architecture. I am very excited about this one and would love if you shared it!

https://www.youtube.com/watch?v=zBrjKJiy6rI&list=PLflA5Q354D42Zxi6KiLmNVNzQHINQ51U-&index=19

Why I program in Lisp. ~ Joe Marshall. https://funcall.blogspot.com/2025/04/why-i-program-in-lisp.html #CommonLisp #FunctionalProgramming

Just published a longform article on parallel collectors in Java Streams.

Covers correctness, performance, pitfalls
Custom collectors with CONCURRENT semantics
JMH benchmark

TL;DR: .parallelStream() is not a magic wand.

https://svenruppert.com/2025/04/08/synchronous-in-chaos-how-parallel-collectors-bring-order-to-java-streams/

Functional Programming for the Object-Oriented Programmer by Brian Marick is free with a Leanpub Reader membership! Or you can buy it for $7.99! http://leanpub.com/fp-oo #Software #FunctionalProgramming

Ready to geek out over functional programming? Join us for the upcoming FPIndia Bangalore meetup!
https://hasgeek.com/fpindia/bangalore-fp-april-meetup/

#Bangalore #FunctionalProgramming #FPIndia #Meetup #India #Haskell #PureScript #OCaml #Elixir #Clojure #Scala

An introduction to typeclass metaprogramming. ~ Alexis King. https://lexi-lambda.github.io/blog/2021/03/25/an-introduction-to-typeclass-metaprogramming/ #Haskell #FunctionalProgramming

A #monad is when you know how to convert $M (M a)$ to $M a$, but not $M a$ to $a$.

Category theory using Haskell (An introduction with Moggi and Yoneda). ~ Shuichi Yukita. https://books.google.com/books?id=4Xc2EQAAQBAJ #CategoryTheory #Math #Haskell #FunctionalProgramming

Why F#?

https://batsov.com/articles/2025/03/30/why-fsharp/