Scala categorytheory
6 likes1,390 views
Category theory concepts such as objects, arrows, and composition directly map to concepts in Scala. Objects represent types, arrows represent functions between types, and composition represents function composition. Scala examples demonstrate how category theory diagrams commute, with projection functions mapping to tuple accessors. Thinking in terms of interfaces and duality enriches both category theory and programming language concepts. Learning category theory provides a uniform way to reason about programming language structures and properties of data types.
![Diagram of CT
C
f g
! [f,g]
A AXB B
π1 π2](https://image.slidesharecdn.com/scalacategorytheory-120911011101-phpapp01/85/Scala-categorytheory-14-320.jpg)
Scala categorytheory
- 1. Category Theory In Scala Meetu Maltiar Principal Consultant Knoldus
- 2. Agenda Category Theory the basics Category Theory in Scala Code Examples
- 3. Category Pierce defines Category as comprising of: ● A collection of objects ● A collection of arrows (often called morphisms) ● Operations assigning to each arrow f an object dom f, its domain, and an object cod f, its codomain (f:A → B, where dom f = A and cod f = B)
- 4. Category continued.. A composition operator assigning to each pair of arrows f and g with cod f = dom g, a composite arrow g o f: dom f → cod g, satisfying the following associative law: for any arrows f:A → B, g:B → C and h:C → D h o (g o f) = (h o g) o f For each object A, an identity arrow idA: A → A satisfying the following identity law: for any arrow f:A → B, idB o f = f and f o idA = f
- 5. Category Apples Fruit Banana Vegetable Brinjal f: A → B
- 6. Category Composition Apples Fruit Living Banana Vegetable Non Living Brinjal g o f: A → C
- 7. Translating to Scala We can define any function from a type A to type B as: A => B here we have an example or morphism For any function val foo: A => B = //Anything We have type A as domain of function foo and type B as co-domain of function foo
- 8. Scala Category Example We can define composition of arrows or functions in Scala with following REPL example scala> val f: Int => String = _.toString f: Int => String = <function1> scala> val g: String => Int = _.length g: String => Int = <function1> scala> f compose g res3: String => String = <function1>
- 9. Scala category identity continued Identity law is a special version of a composition. Let's define function and play them in REPL: scala> val foo: Int => String = _.toString foo: Int => String = <function1> scala> val idInt: Int => Int = identity(_: Int) idInt: Int => Int = <function1> scala> val idString: String => String = identity(_: String) idString: String => String = <function1> scala> idString compose foo res4: Int => String = <function1> scala> foo compose idInt res5: Int => String = <function1>
- 10. Category theory and PL Do understanding Category Theory makes us understand PL's better? If we just do Enterprise software development and do not want to go beyond our comfort zone then answer is no. Category Theory provides uniform model of set theory, algebra, logic and computation. Many concepts of Category theory maps nicely to structures of PL. Categorical reasoning helps us to reason about programs. Some basic structures in PL like product and sum types have their correspondences in Category Theory. There is a strong correspondence between typed lambda calculus and cartesian closed categories
- 11. Properties of data type in CT Consider the category of Products of elements. Take for example of cartesian products from the category of sets. A cartesian product of two sets A and B is defined by A X B = {(a, b) | a belongs to A and b belongs to B} For example if A = {1, 2} and B = {A, B} A X B = {(1, A), (1, B), (2, A), (2, B)} So here we have tuples or Pairs as objects in a Category
- 12. Properties of data type in CT .. But what will be morphisms? In case of products, the applicable arrows (or morphisms) are the projection functions: π1: A X B → A π1: A X B → B
- 13. Properties of data type in CT .. Now if we draw a Category diagram with C as a product type we have two functions as projection functions: 1. f: C → A 2. g: C → B and the product function is represented by: C → A X B It is defined by: <F, G>(x) = (f(x), g(x))
- 14. Diagram of CT C f g ! [f,g] A AXB B π1 π2
- 15. Diagram of CT For every pair of vertices X and Y, all paths in the diagram from X to Y are equal in the sense that each path forms an arrow and these arrows are equal in category For example the path from C to A is: <f,g> and π1 therefore composition gives us: π1 o <f,g> = f Also path from C to B gives us: <f,g> and π2 π2 o <f,g> = g
- 16. Scala CT example Lets now see how the laws of commutativity maps to Scala. As a programmer we use the projection functions (_1 and _2) in Scala Tuple2 on a regular basis In the CT diagram we will see that we get additional insights in abstraction and help understand mathematical properties of how cartesian product of sets map translates to composition of functions
- 17. Scala CT example... scala> val ip = (10, "meetu") ip: (Int, java.lang.String) = (10,meetu) scala> val pi1: ((Int, String)) => Int = (p => p._1) pi1: ((Int, String)) => Int = <function1> scala> val pi2: ((Int, String)) => String = (p => p._2) pi2: ((Int, String)) => String = <function1> scala> val f: Int => Int = (_ * 2) f: Int => Int = <function1> scala> val g: Int => String = _.toString g: Int => String = <function1> scala> val `<f, g>`: Int => (Int, String) = (x => (f(x), g(x))) <f, g>: Int => (Int, String) = <function1> scala> pi1 compose `<f, g>` res0: Int => Int = <function1> scala> pi2 compose `<f, g>` res1: Int => String = <function1>
- 18. Scala CT example So we can claim from the commutativity of the diagram that: pi1 compose `<f, g>` is type wise equal to f pi2 compose `<f, g>` is type wise equal to g Category theory says that morphism between C and A X B is unique and that A X B is defined upto isomorphism. Uniqueness is denoted by ! In diagram. This makes sense as well because a pair can be unique
- 19. Interface driven modeling Category Theory maps very closely to PL in the sense that it focuses on arrows rather than objects corresponding to Interfaces Pierce: CT typically “abstracts away from elements, treating objects as black boxes with unimagined internal structure and focusing attention on the properties of arrows between objects” Learning CT enriches both CT and PL. For example if we know what a Functor is in CT then we can easily make it generic enough so that it can interact with other Functors
- 20. Thinking Generically CT talks about objects and morphisms and how arrows compose. A special kind of morphism is identity function in programming. It is 0 in addition and 1 in multiplication CT generalizes this concept by using same vocabulary (morphism) to denote both stuff that does some operations and those that don't For every object X, there exists a morphism idX: X → X called identity morphism on X, such that for every morphism f: A → B we have: IdB o f = f = f o idA (used in monoids)
- 21. Duality We have seen example of SumTypes for Product. If we look at the CT diagram of Sum compared to Product we see that arrows are reversed. This is called a dual in CT. In Scala we model it by a Union Type like Either where value of SumType comes either from left or right
- 22. What's Next Functors Monads Scalaz Resources: 1. Debasish Ghosh blog “Does Category Theory Makes you A Better Programmer” 2. Heiko's blog on Category Theory 3. Runar video on Scalaz