algebras in programming - harrylaou · •a calculus for lazy functional programming based on...

Algebras in ProgrammingWhat do we mean by algerbra

Harry Laoulakos@harrylaou

• Senior Scala Consultant

• Functional Programming

• Check Cost vs Benefit

Algebras in Programming 2

For absolute beginners

• not necessary to know scala

• stay focussed on semantics

• build a vocabulary to communicate with fellow programmers

• "touches" mathematical concepts, but doesn't go deep


Slideshttps://www.harrylaou.com/slides/AlgebrasInProgramming.pdf


Areas of Mathematics• Elementary algebra

• Abstract algebra

• Linear algebra

• Boolean algebra

• Commutative algebra

• Homological algebra


more areas• Universal algebra

• Algebraic number theory

• Algebraic geometry

• Algebraic combinatorics

• Relational algebra


Algebras can also be mathematical structuresFor example in category theory

• F-algebra

• F-coalgebra

• T-algebra


When we are talking about algebra, it is not necessarily one or even similar things.


In Programming

• ADTs: algebraic data types

• GADTs: Generalized algebraic data types

• Tagless Final Algebra

• Free Μonads Algebra

• Recursion Schemes Algebra


ADTAlgebraic data type


ADTis a composite type of - Product Types (or Tagged Unions)- Sum Types (or Co-Product or Unions)


Product Type

• case class

• tuple

• HList


Product Type

case class User(id:Long, username:String, ...)


Product Type

case class User(id:Long, username:String, ...)

Think AND


Sum Type

• Either

• sealed trait

• Coproduct


Sum Type

sealed trait Animalcase class Cat(name:String) extends Animalcase class Dog(name: String) extends Animal


Sum Type

sealed trait Animalcase class Cat(name:String) extends Animalcase class Dog(name: String) extends Animal

Think OR


Note

It is a different than inheritance.There are GADTs in Rust, which doesn't support inheritance.


Product TypeRust

struct User { id: u64, name: String}


Sum TypeRust

enum Animal { Cat(String), Dog(String)}


Union TypeScala 3

case class Cat(name:String) case class Dog(name: String)type Animal = Cat | Dog

or even

def func(a: Cat | Dog ) : String = ???


Enums as ADTScala 3

enum Color(val rgb: Int) { case Red extends Color(0xFF0000) case Green extends Color(0x00FF00) case Blue extends Color(0x0000FF) case Mix(mix: Int) extends Color(mix)}


Very common ADTs

• Option

• Either


Option

(more or less)

sealed trait Option[+A] final case class Some[+A](value: A) extends Option[A]case object None extends Option[Nothing]


Either

(more or less)

sealed trait Either[+A, +B] extendsfinal case class Left[+A, +B] (value: A) extends Either[A, B] final case class Right[+A, +B]( value: B) extends Either[A, B]


ADT• Parametrized : They can have type parameters

• Product Types: Think AND

• Sum Types: Think OR


GADTGeneralized Algebraic Data Type

• A generalization of parametric algebraic data types.


GADTExample

sealed trait Expr[T]case class Num(i: Int) extends Expr[Int]case class Bool(b: Boolean) extends Expr[Boolean]case class Add(x: Expr[Int], y: Expr[Int]) extends Expr[Int]case class Mult(x: Expr[Int], y: Expr[Int]) extends Expr[Int]case class Eq[A](x: Expr[A], y: Expr[A]) extends Expr[Boolean]


GADTExample

def eval[T](e: Expr[T]): T = e match { case Num(i) => i case Bool(b) => b case Add(x,y) => eval(x)+eval(y) case Mult(x,y) => eval(x)*eval(y) case Eq(x,y) => eval(x) == eval(y) }


GADTExample

val expr1 = Mult(Add(Num(1),Num(2)),Num(4))val expr2 = Num(12)val expr3 = Eq(expr1,expr2)

eval(expr3) true: Boolean


GADT• Type-safe business logic

• Type-safe DSLs


Coool, but...where the heck is the Algebra?


Sum Type

sealed trait VehicleTypecase object Car extends VehicleTypecase object Moto extends VehicleType


Sum Type


How many VehicleTypes?


Sum Type

sealed trait Colour case object Red extends Colourcase object Yellow extends Colourcase object Blue extends Colour


Sum Type


How many Colours?


Sum Type


2 VehicleTypes


3 Colours


Product Type

case class Vehicle (vehicleType:VehicleType, colour:Colour)


Product Type


How many vehicles? If 2 VehicleTypes and 3 Colours?


Product Type


If 2 VehicleTypes and 3 Colours?2 * 3 = 6 Vehicles


Product Type

case class Vehicle (vehicleType:VehicleType, colour:Colour, isUsed:Boolean)

If 2 VehicleTypes, 3 Colours and 2 Boolean types?


Product Type

case class Vehicle (vehicleType:VehicleType, colour:Colour, isSecondHand:Boolean)

If 2 VehicleTypes, 3 Colours and 2 Boolean types?2 * 3 * 2 = 12 Vehicles


ADTAs in elementary algebra

• Sum is the result of addition

• Product is the result of multiplication.


Function TypeFunction is a type in Scala

def like(colour:Colour) :Boolean

or

val like : Colour => Boolean

also

type Like = Colour => Boolean


Function Type

type Like = Colour -> Boolean

Red -> {t,f}Yellow -> {t,f}Blue -> {t,f}

How many implementations?


Function Type

type Like = Colour -> Boolean

Red -> {t,f}Yellow -> {t,f}Blue -> {t,f}

There can be 2 * 2 * 2 = 23 implementations


Function Type

sealed trait Countrycase object France extends Country case object UK extends Countrycase object Germany extends Country case object Japan extends Country case object USA extends Country

5 countries


Function Type

sealed trait Brand case object Brand1 extends Brand case object Brand2 extends Brand...case object Brand20 extends Brand

2O brands


Function Type

def isProduced(brand:Brand) : Country

Brand1 -> {France, UK, Germany, Japan, USA}Brand2 -> {France, UK, Germany, Japan, USA} ...Brand20 -> {France, UK, Germany, Japan, USA}

How many implementations?


Function Type

def isProduced(brand:Brand) : Country

Brand1 -> {France, UK, Germany, Japan, USA}Brand2 -> {France, UK, Germany, Japan, USA} ...Brand20 -> {France, UK, Germany, Japan, USA}

There can be 5 * 5 * ... * 5 (20 times) = 520 implementations


ExponentialsIn Category Theory

In mathematical literature, the function object, or the internal hom-object between two objects a and b, is often called the exponential and denoted by ba.


Exponentials

In simpler terms

A Function Type val f : A => B

corresponds to the exponential


Practical example

From the book: Functional Programming for Mortals

• (A => C) => ((B => C) => C)

•

•

•

•

•

• (Either[A, B] => C) => C


More Algebras

• Tagless Final Algebra

• Free Μonads Algebra


Tagless Final vs Free Μonads

• The comparison is out of scope for this talk

• But let's try to find out what Algebra means

• A random blogpost: Free Monad vs Tagless Final


https://medium.com/@agaro1121/free-monad-vs-tagless-final-623f92313eac

Tagless Final Algebra

trait DatabaseAlgebra[F[_], T] { def create(t: T): F[Boolean] def read(id: Long): F[Either[DatabaseError, T]] def delete(id: Long): F[Either[DatabaseError, Unit]]}

... tagless final encoded algebras.


Free Monad Algebra

sealed trait DBFreeAlgebraT[T]case class Create[T](t: T) extends DBFreeAlgebraT[Boolean]case class Read[T](id: Long) extends DBFreeAlgebraT[Either[DatabaseError, T]]case class Delete[T](id: Long) extends DBFreeAlgebraT[Either[DatabaseError, Unit]]

• ... We need to create some interpreters to interpret our algebra into actions'

• ... For this section we’ll create interpreters to execute...


Free Monad and Tagless Final

• in essence the Interpreter pattern

• A grammar for a simple language should be defined

• in Free Monad and Tagless Final : the grammar is called "Algebra"

• the grammar/algebra is implemented by concrete implementations.


Category Theory

• formalizes mathematical structure and its concepts in terms of a labeled directed graph called a category, whose nodes are called objects, and whose labelled directed edges are called arrows (or morphisms)

• the mathematics of mathematics

• the science of composition and abstraction

• the mathematics behind functional programming


Algebras in Category Theory• F-algebra

• F-coalgebra

• Free Algebra

• Cofree Algebra


Algebra

• Set of A

• Some operator

• unary: A => A

• binary (A, A) => A

• n-ary (A,A,...,A ) => A

• What about Seq[A] => A ?

• or Option[A]=> A

• F[A] => A


F-Algebra

• F[A] => A

• If the F is also a functor

• this is called F-algebra

• F-algebra generalization of normal algebra


Co-

• Co-Algebra

• Co-Free


Co-

• Co-Algebra

• Co-Free

What does co- mean?


Duality in Category Theory

Duality is a correspondence between the properties of a category C and the dual properties of the opposite category Cop


F-coalgebra

• if F[A] => A is an algebra

• If we reverse the arrows

• type Coalgebra[F[_], A] = A => F[A]


Recursion Schemes

• a calculus for lazy functional programming based on recursion operators associated with data type definitions.

• in simple terms: is an advanced functional programming technique that moves the the recursion in the type level

• using F-Algebras and F- Coalgebras


Recap

• (G)ADT analogy to elementary algebra

• Sum Type => arithmetic addition

• Product Type => arithmetic multiplication

• Function Type => exponential operation

• Free Monads Algebra - Tagless Final Algebra => Grammar in Interpreter Pattern

• F-algebra

• F-coalgebra


References / Read more• https://en.wikipedia.org/wiki/Algebra

• What the F is a GADT?

• GADT support in Scala

• Function Types

• Functional Programming for Mortals

• Free Monad vs Tagless Final

• Recursion Schemes for Higher Algebras

• The Science Behind Functional Programming

• AST playground: recursion schemes and recursive data


https://en.wikipedia.org/wiki/Algebra

https://tech.ovoenergy.com/what-the-f-is-a-gadt/

https://gist.github.com/pchiusano/1369239

https://bartoszmilewski.com/2015/03/13/function-types/

https://leanpub.com/fpmortals

https://medium.com/@agaro1121/free-monad-vs-tagless-final-623f92313eac

https://bartoszmilewski.com/2018/08/20/recursion-schemes-for-higher-algebras/

https://www.47deg.com/blog/science-behind-functional-programming/

https://kubuszok.com/2019/ast-playground-recursion-schemes-and-recursive-data

Questions?https://www.harrylaou.com/slides/AlgebrasInProgramming.pdf

Harry Laoulakos : @harrylaou


algebras in programming - harrylaou · •a calculus for lazy functional programming based on...

Documents