I sometimes work on a repository accumulating functional algorithms. These are functional versions of commonly used algorithms, like depth-first search, breadth-first search, and so on.

• Guile Algorithms

I like to work on Advent of Code (AoC) puzzles, when it is the season. I sometimes use AoC puzzles sometimes as a vehicle for learning interesting programming languages. My fallback option is GNU Guile, a Scheme, my favorite programming language currently.

• AoC 2020/2019/2018
• AoC 2021
• AoC 2022
• AoC 2023

I maintain a repository of examples of things Scheme or GNU Guile as a reference for myself, when working on other projects, but also as a place where I explore parts of the language.

• Guile Examples

My explorations in the realm of Scheme and metaprogramming have led me to discover CK-macros, which in turn enabled me to write a function contracts library.

This library does not merely provide a wrapper to define functions. It defines a new define form, which is a syntax for defining function contracts. The macro takes care of creating define forms, which check contracts and report any violated contract including the arguments, which violated a contract. The form also allows referencing the return value of a function, so that contracts about the return values of functions can be defined.

The library also defines lambda forms, for defining contracts for anonymous functions.

Documentation could be better, but there is an extensive set of tests which demonstrate the usage.

To summarize, my library is written using CK-macros and for that reason composes well. It is also written in a way, that I believe is quite readable, considering its macro nature. This has been an attempt to see where I can go using the CK-macros. I have used my library sometimes in my own projects and it works well. I also consider it an example for a macro that does not diminish readability of the code it is used in. While my library is neat, there are other function contract libraries out there, which might offer different sets of features or even additional features and might be more battle tested:

• Racket has a more advanced library, offering additional concepts like impersonators and chaperones and defining contracts on the module level, in separate forms. It does way more than my little library. Its code seems quite a bit less penetrable than my library as well.
• There is an old implementation of Racket's function contracts library for Guile.
• Also there are other implementations of function contracts by other people: guildhall/guile-contract

Guile has an implementation of CK-macros already, which can be imported using (use-modules (system base ck)). I did not know about this, and instead used the one found on Oleg Kiselyov's website, which I heavily annotated, to make it easier to understand for myself, my future self, and anyone who might want to have a look at how it works. Mind-blowing stuff.

• my own Guile function contracts library

I played some games of Risk with friends. At some point I was thinking, perhaps I can build a tool, that tells me what the odds are, that various moves will be successful. So I started to implement simple probability calculations for moves. However, I soon hit a mathematical wall of formulas becoming more and more complicated. This is when I got the idea, that perhaps a simulation approach is simpler to implement. That is what I implemented and it proved to be sufficiently accurate for my purposes.

• guile-risk-calculator

guile-docker was an experiment in using metaprogramming to automatically define procedures for an API, in this case the docker REST API. It is not (yet) a full docker client library. It merely implements one or two routes. However, it reduces the amount of effort needed to define an interface to docker to a few macro calls looking like (define-api-route /containers/json GET application/x-www-form-urlencoded). Goal reached. Does anyone want to build a complete docker library on top?

• guile-docker