kubuszok.com

Sanely-automatic derivation - or how type class derivation works and why everyone else is doing it wrong

Mon, 03 Nov 2025 16:37:00 +0100

In Scala, we generate quite a lot of code. A lot of that involves the compiler generating so-called type class instances. This mechanism is quite widespread, yet, very few people actually understand it. As a result, we, the community, settled for suboptimal practices, resulting in suboptimal performance and user experience.

Modeling in Scala, part 1: modeling your domain

Thu, 12 Dec 2024 13:30:00 +0100

Scala gives us a lot of power. We can easily model things with classes and OOP, we can pull in functional libraries and model everything with functions and values, we can implement a stateless monolith or a distributed system. And today we have a lot of books and tutorials that cover these topics: how to glue the code together to create a maintainable application with raw Futures/Akka/Cats ecosystem/Zio ecosystem/Scala as typed Python.

IO monad: which, why and how

Mon, 27 May 2019 00:00:00 +0200

In many discussions about FP - especially about purely functional programming - there are talks about IO monad, IO type and so on. Its users argue that it is better than your standard imperative approach, that it helps reason, encapsulate side-effects and design more elegant programs. On the other hand, its opponents argue that programs are side-effectful by nature, so you would end up with something that needs IO for like 80% of the codebase while learning curve for newcomers would go up, so what’s the benefit? Let’s try to figure out.

AST playground: recursion schemes and recursive data

Mon, 06 May 2019 00:00:00 +0200

So, we parsed an input - file, stream of characters or string - and we got nicely structured data in the form of a tree and/or an algebraic data type. What now?

From String to AST: parsing

Mon, 29 Apr 2019 00:00:00 +0200

Whether you have to do with data in the form of CSV, JSON or a full-blooded programming language like C, JavaScript, Scala, or maybe a query language like SQL, you always transform some sequence of characters (or binary values) into a structured representation. Whatever you’ll do with that representation depends on your domain and business goals, and is quite often the core value of whatever you are doing. With a plethora of tools doing the parsing for us (including the error-handling), we might easily overlook how complex and interesting a process it is.

ADT through the looking glass - lenses, prims and other optics

Mon, 24 Dec 2018 00:00:00 +0100

Algebraic data structures are invaluable in functional programming. With immutable data structures reasoning about the code is easy. Concurrency requires little effort as you don’t have to be worried about locking, mutexes and semaphores - nobody can change your data anyway. If you need to update something you can just create an updated copy and use it from now on. Except if you have a nested structure and need to update something deep, deep inside.

Different ways to understand a monad

Mon, 17 Dec 2018 00:00:00 +0100

As soon as you start mentioning functional programming, monads pop out as something that you have to know. However, hardly anyone is good at explaining what a monad is. That is why we’ll try to get some intuition about it without defining it.

The F-words: functor and friends

Mon, 10 Dec 2018 00:00:00 +0100

While algebras are something we (programmers) rely on in our everyday work, we don’t always use them knowingly. Functional programming, however, has a relatively high number of programmers who care about correctness and mathematical formalism, that leads to it. It is no surprise that it was FP that explored the idea that if you perceive your program as a pipeline of operations, you could provide stronger guarantees if you had tools to define such pipelines mathematically.

Algebras we love

Mon, 03 Dec 2018 00:00:00 +0100

If you work with anything that can be modeled mathematically, you most likely know that many things you work on can be expressed with algebras. However, if you are not a graduate of a computer science course or similar you might not know how ubiquitous they are and how often you rely on some of them. (And I don’t mean F-algebras and FP-concepts). So what are algebras and where can we meet some most common of them?

It's all about relations

Mon, 26 Nov 2018 00:00:00 +0100

In FP we talk a lot about algebras, functions, and types. But types are sets, and functions are also sets. Algebras are types with operations that fulfill some conditions, which means they are also sets. So how low should we get if we want to start from the beginning? I would say we should start with finitary relations.