Not yet, officially, though it should be at least possible with not too much hacking. The biggest obstacle is that the libraries do not have any ability to do dynamic loading yet. Here’s a potential strategy to make it work (on Rust’s incoming branch). Link to the rustc crate to drive the compiler programmatically. Be … Read more
Enumerating the ADT constructors The most straightforward way to get the representation you want is to use generic derivation for the case classes but explicitly defined instances for the ADT type: import cats.syntax.functor._ import io.circe.{ Decoder, Encoder }, io.circe.generic.auto._ import io.circe.syntax._ sealed trait Event case class Foo(i: Int) extends Event case class Bar(s: String) extends … Read more
Yes, you are correct, you are looking for algebraic data types. There is a great tutorial on them at Learn You a Haskell. For the record, the concept of an abstract class from OOP actually has three different translations into Haskell, and ADTs are just one. Here is a quick overview of the techniques. Algebraic … Read more
You can use record patterns like this: data X = A | B {name :: String} | C {x::Int, y::Int, name::String} myfn :: X -> Int myfn A = 50 myfn B{} = 200 myfn C{} = 500 Record patterns allow you to give names to the fields of the constructors. you can also do … Read more
What are the traditional sums-and-products data structures he is referring to? In type theory, regular data structures can be described in terms of sums, products and recursive types. This leads to an algebra for describing data structures (and so-called algebraic data types). Such data types are common in statically typed functional languages, such as ML … Read more
Python 3.10 version Here is a Python 3.10 version of Brent’s answer with pattern-matching and prettier union type syntax: from dataclasses import dataclass @dataclass class Point: x: float y: float @dataclass class Circle: x: float y: float r: float @dataclass class Rectangle: x: float y: float w: float h: float Shape = Point | Circle … Read more
Make Either an abstract class with no fields and only one constructor (private, no-args, empty) and nest your “data constructors” (left and right static factory methods) inside the class so that they can see the private constructor but nothing else can, effectively sealing the type. Use an abstract method either to simulate exhaustive pattern matching, … Read more
Haskell’s algebraic data types are named such since they correspond to an initial algebra in category theory, giving us some laws, some operations and some symbols to manipulate. We may even use algebraic notation for describing regular data structures, where: + represents sum types (disjoint unions, e.g. Either). • represents product types (e.g. structs or … Read more
Kotlin’s sealed class approach to that problem is extremely similar to the Scala sealed class and sealed trait. Example (taken from the linked Kotlin article): sealed class Expr { class Const(val number: Double) : Expr() class Sum(val e1: Expr, val e2: Expr) : Expr() object NotANumber : Expr() }
Well let’s start with the basics Kinds Kinds are the types of types*, for example Int :: * Bool :: * Maybe :: * -> * Notice that -> is overloaded to mean “function” at the kind level too. So * is the kind of a normal Haskell type. We can ask GHCi to print … Read more