DOCSLIB.ORG

Lambda Jam 2018-05-22 Amy Wong

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Lambda Jam 2018-05-22 Amy Wong Introduction to Recursion schemes Lambda Jam 2018-05-22 Amy Wong BRICKX [email protected] Agenda • My background • Problem in recursion • Fix point concept • Recursion patterns, aka morphisms • Using morphisms to solve different recursion problems • References of further reading • Q & A My background • Scala developer • Basic Haskell knowledge • Not familiar with Category Theory • Interested in Functional Programming Recursion is ubiquitous, however, recusive calls are also repeatedly made Example 1 - expression data Expr = Const Int | Add Expr Expr | Mul Expr Expr eval :: Expr -> Int eval (Const x) = x eval (Add e1 e2) = eval e1 + eval e2 eval (Mul e1 e2) = eval e1 * eval e2 Evaluate expression > e = Mul ( Mul (Add (Const 3) (Const 0)) (Add (Const 3) (Const 2)) ) (Const 3) > eval e > 45 Example 2 - factorial factorial :: Int -> Int factorial n | n < 1 = 1 | otherwise = n * factorial (n - 1) > factorial 6 > 720 Example 3 - merge sort mergeSort :: Ord a => [a] -> [a] mergeSort = uncurry merge . splitList where splitList xs | length xs < 2 = (xs, []) | otherwise = join (***) mergeSort . splitAt (length xs `div` 2) $ xs > mergeSort [1,2,3,3,2,1,-10] > [-10,1,1,2,2,3,3] Problem • Recursive call repeatedly made and mix with the application-specific logic • Factoring out the recursive call makes the solution simpler Factor out recursion • Recursion is iteration of nested structures • If we identify abstraction of nested structure • Iteration on abstraction is factored out as pattern • We only need to define non-recursive function for application requirement • Problem solved in simple way How? Fix point Higher-kinded type Fix, (* -> *) -> * newtype Fix f = Fix { unFix :: f (Fix f) } Fix f is nested data structure We expect f is not just a type constructor but also a functor Iterate Fix f newtype Fix f = Fix { unFix :: f (Fix f) } fmap iterate f (Fix f) f a unFix alg iterate Fix f a Replace iterate by cata alg Decouples alg from recursion pattern fmap (cata alg) f (Fix f) f a unFix alg cata alg Fix f a cata function cata :: (Functor f) => (f a -> a) -> Fix f -> a cata alg = alg . fmap (cata alg) . unfix cata is called catamorphism - fundamental recursion pattern Highlights on catamorphism cata :: (Functor f) => (f a -> a) -> Fix f -> a alg :: f a -> a is called algebra, non-recursive function for application-specific logic a is called carrier of the algebra If we solve a recursion problem using cata, we only need to define functor f and f a -> a according to application requirement Catamorphism example - expression Original ADT data Expr = Const Int | Add Expr Expr | Mul Expr Expr Re-design the ADT as functor (notice the bolded carrier type) data ExprF a = Const Int | Add a a | Mul a a deriving Functor Algebra to evaluate expression -- cata :: (Functor f) => (f a -> a) -> Fix f -> a In evaluating an expression, carrier type is Int eval :: ExprF Int -> Int eval (Const c) = c eval (Add x y) = x + y eval (Mul x y) = x * y -- cata :: (Functor f) => (f a -> a) -> Fix f -> a > e = Fix $ Mul (Fix $ Mul (Fix $ Add (Fix $ Const 3) (Fix $ Const 0)) (Fix $ Add (Fix $ Const 3) (Fix $ Const 2)) ) (Fix $ Const 3) > cata eval e > 45 Algebra to format expression -- cata :: (Functor f) => (f a -> a) -> Fix f -> a In formatting an expression, carrier type is String format :: ExprF String -> String format (Const c) = show c format (Add s1 s2) = "(" <> s1 <> " + " <> s2 <> ")" format (Mul s1 s2) = s1 <> " * " <> s2 > cata format e > "(3 + 0) * (3 + 2) * 3" But catamorphism can’t solve all problems Anamorphism – opposite of Catamorphism • Catamorphism is building up a value from a nested structure, like a piece of paper folded up to an object • Anamorphism is the opposite, like an object unfolded to a piece of paper Anamorphism signature Catamorphism cata :: (Functor f) => (f a -> a) -> Fix f -> a cata alg = alg . fmap (cata alg) . unFix Anamorphism ana :: (Functor f) => (a -> f a) -> a -> Fix f ana coalg = Fix . fmap (ana coalg) . coalg coalg :: (a -> f a) is called coalgebra Hylomorphism The composition of anamorphism followed by catamorphism hylo :: (Functor f) =>(f b -> b) -> (a -> f a) -> a -> b hylo alg coalg = cata alg . ana coalg Alternatively, eliminating intermediate nested data structure hylo alg coalg = alg . fmap (hylo alg coalg) . coalg Hylomorphism example – merge sort Original code for merge sort mergeSort :: Ord a => [a] -> [a] mergeSort = uncurry merge . splitList where splitList xs | length xs < 2 = (xs, []) | otherwise = join (***) mergeSort . splitAt (length xs `div` 2) $ xs ADT for merge sort -- (notice that bolded carrier type) data TreeF a r = Empty | Leaf a | Branch r r deriving Functor Coalgebra for anamorphism -- ana :: (Functor f) => (a -> f a) -> a -> Fix f -- TreeF a is functor, [a] is carrier type split :: Ord a => [a] -> TreeF a [a] split [] = Empty split [x] = Leaf x split xs = uncurry Branch . splitAt (length xs `div` 2) $ xs Algebra for catamorphism -- cata :: (Functor f) => (f a -> a) -> Fix f -> a merge_ :: Ord a => TreeF a [a] -> [a] merge_ Empty = [] merge_ (Leaf x) = [x] merge_ (Branch l r) = merge l r -- hylo :: (Functor f) =>(f b -> b) -> (a -> f a) -> a -> b > hylo merge split [1,2,3,3,2,1,-10] > [-10,1,1,2,2,3,3] Paramorphism cata :: (Functor f) => (f a -> a) -> Fix f -> a In catamorphism, (f a -> a) only provides the value a, to be transformed. It doesn’t provide the original structure, Fix f from which the value is built. Paramorphism address this problem para :: (Functor f) =>(f (a, Fix f) -> a)-> Fix f -> a para alg = alg . fmap (para alg &&& id) . unFix Paramorphism example Original code for factorial factorial n | n < 1 = 1 | otherwise = n * factorial (n - 1) ADT for the natural number that copes with following conditions • Number < 1 • Number >= 1 data NatF a = Zero | Succ a deriving Functor Use Catamorphism for natural number -- cata :: (Functor f) => (f a -> a) -> Fix f -> a natAlg :: NatF Int -> Int natAlg Zero = 0 natAlg (Succ n) = n + 1 Use Paramorphism for factorial number --para :: (Functor f) => (f (a, Fix f) -> a) -> Fix f -> a factAlg :: NatF (Int, Fix NatF) -> Int factAlg Zero = 1 factAlg (Succ (n, x)) = n * cata natAlg (Fix $ Succ x) > nat = Fix $ Succ $ Fix $ Succ $ Fix $ Succ $ Fix Zero > para factAlg nat > 6 Recap Catamorphism cata :: (Functor f) => (f a -> a) -> Fix f -> a Anamorphism ana :: (Functor f) => (a -> f a) -> a -> Fix f Hylomorphism hylo :: (Functor f) =>(f b -> b) -> (a -> f a) -> a -> b Paramorphism para :: (Functor f) => (f (a, Fix f) -> a) -> Fix f -> a Recursion schemes • Catamorphism, paramorphism, anamorphism and hylomorphism are fundamental morphisms • They are available from Haskell recursion schemes library • When using morphisms to solve recursion problems, we only need to consider application-specific requirement by designing ADT for functor and non-recursive function More interesting morphisms • More interesting morphisms are available from recursion schemes library • More morphisms to be invented by us • Try to use morphisms to solve recursion problems to make simple solution References • https://www.schoolofhaskell.com/user/bartosz/understanding-algebras • http://blog.sumtypeofway.com/an-introduction-to-recursion-schemes/ • https://github.com/willtim/recursion-schemes/raw/master/slides-final.pdf - • http://hackage.haskell.org/package/recursion-schemes • http://maartenfokkinga.github.io/utwente/mmf91m.pdf - Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire • https://github.com/slamdata/matryoshka - recursion schemes in Scala Q & A.
Load more

Recommended publications
  • NICOLAS WU Department of Computer Science, University of Bristol (E-Mail: [email protected], [email protected])
    Hinze, R., & Wu, N. (2016). Unifying Structured Recursion Schemes. Journal of Functional Programming, 26, [e1]. https://doi.org/10.1017/S0956796815000258 Peer reviewed version Link to published version (if available): 10.1017/S0956796815000258 Link to publication record in Explore Bristol Research PDF-document University of Bristol - Explore Bristol Research General rights This document is made available in accordance with publisher policies. Please cite only the published version using the reference above. Full terms of use are available: http://www.bristol.ac.uk/red/research-policy/pure/user-guides/ebr-terms/ ZU064-05-FPR URS 15 September 2015 9:20 Under consideration for publication in J. Functional Programming 1 Unifying Structured Recursion Schemes An Extended Study RALF HINZE Department of Computer Science, University of Oxford NICOLAS WU Department of Computer Science, University of Bristol (e-mail: [email protected], [email protected]) Abstract Folds and unfolds have been understood as fundamental building blocks for total programming, and have been extended to form an entire zoo of specialised structured recursion schemes. A great number of these schemes were unified by the introduction of adjoint folds, but more exotic beasts such as recursion schemes from comonads proved to be elusive. In this paper, we show how the two canonical derivations of adjunctions from (co)monads yield recursion schemes of significant computational importance: monadic catamorphisms come from the Kleisli construction, and more astonishingly, the elusive recursion schemes from comonads come from the Eilenberg-Moore construction. Thus we demonstrate that adjoint folds are more unifying than previously believed. 1 Introduction Functional programmers have long realised that the full expressive power of recursion is untamable, and so intensive research has been carried out into the identification of an entire zoo of structured recursion schemes that are well-behaved and more amenable to program comprehension and analysis (Meijer et al., 1991).
    [Show full text]
  • A Category Theory Explanation for the Systematicity of Recursive Cognitive
    Categorial compositionality continued (further): A category theory explanation for the systematicity of recursive cognitive capacities Steven Phillips ([email protected]) Mathematical Neuroinformatics Group, National Institute of Advanced Industrial Science and Technology (AIST), Tsukuba, Ibaraki 305-8568 JAPAN William H. Wilson ([email protected]) School of Computer Science and Engineering, The University of New South Wales, Sydney, New South Wales, 2052 AUSTRALIA Abstract together afford cognition) whereby cognitive capacity is or- ganized around groups of related abilities. A standard exam- Human cognitive capacity includes recursively definable con- cepts, which are prevalent in domains involving lists, numbers, ple since the original formulation of the problem (Fodor & and languages. Cognitive science currently lacks a satisfactory Pylyshyn, 1988) has been that you don’t find people with the explanation for the systematic nature of recursive cognitive ca- capacity to infer John as the lover from the statement John pacities. The category-theoretic constructs of initial F-algebra, catamorphism, and their duals, final coalgebra and anamor- loves Mary without having the capacity to infer Mary as the phism provide a formal, systematic treatment of recursion in lover from the related statement Mary loves John. An in- computer science. Here, we use this formalism to explain the stance of systematicity is when a cognizer has cognitive ca- systematicity of recursive cognitive capacities without ad hoc assumptions (i.e., why the capacity for some recursive cogni- pacity c1 if and only if the cognizer has cognitive capacity tive abilities implies the capacity for certain others, to the same c2 (see McLaughlin, 2009). So, e.g., systematicity is evident explanatory standard used in our account of systematicity for where one has the capacity to remove the jokers if and only if non-recursive capacities).
    [Show full text]
  • Abstract Nonsense and Programming: Uses of Category Theory in Computer Science
    Bachelor thesis Computing Science Radboud University Abstract Nonsense and Programming: Uses of Category Theory in Computer Science Author: Supervisor: Koen Wösten dr. Sjaak Smetsers [email protected] [email protected] s4787838 Second assessor: prof. dr. Herman Geuvers [email protected] June 29, 2020 Abstract In this paper, we try to explore the various applications category theory has in computer science and see how from this application of category theory numerous concepts in computer science are analogous to basic categorical definitions. We will be looking at three uses in particular: Free theorems, re- cursion schemes and monads to model computational effects. We conclude that the applications of category theory in computer science are versatile and many, and applying category theory to programming is an endeavour worthy of pursuit. Contents Preface 2 Introduction 4 I Basics 6 1 Categories 8 2 Types 15 3 Universal Constructions 22 4 Algebraic Data types 36 5 Function Types 43 6 Functors 52 7 Natural Transformations 60 II Uses 67 8 Free Theorems 69 9 Recursion Schemes 82 10 Monads and Effects 102 11 Conclusions 119 1 Preface The original motivation for embarking on the journey of writing this was to get a better grip on categorical ideas encountered as a student assistant for the course NWI-IBC040 Functional Programming at Radboud University. When another student asks ”What is a monad?” and the only thing I can ex- plain are its properties and some examples, but not its origin and the frame- work from which it comes. Then the eventual answer I give becomes very one-dimensional and unsatisfactory.
    [Show full text]
  • Recursion Patterns As Hylomorphisms
    Recursion Patterns as Hylomorphisms Manuel Alcino Cunha [email protected] Techn. Report DI-PURe-03.11.01 2003, November PURe Program Understanding and Re-engineering: Calculi and Applications (Project POSI/ICHS/44304/2002) Departamento de Inform´atica da Universidade do Minho Campus de Gualtar — Braga — Portugal DI-PURe-03.11.01 Recursion Patterns as Hylomorphisms by Manuel Alcino Cunha Abstract In this paper we show how some of the recursion patterns typically used in algebraic programming can be defined using hylomorphisms. Most of these def- initions were previously known. However, unlike previous approaches that use fixpoint induction, we show how to derive the standard laws of each recursion pattern by using just the basic laws of hylomorphisms. We also define the accu- mulation recursion pattern introduced by Pardo using a hylomorphism, and use this definition to derive the strictness conditions that characterize this operator in the presence of partiality. All definitions are implemented and exemplified in Haskell. 1 Introduction The exponential growth in the use of computers in the past decades raised important questions about the correctness of software, specially in safety critical systems. Compared to other areas of engineering, software engineers are still very unfamiliar with the mathematical foundations of computation, and tend to approach programming more as (black) art and less as a science [5]. Ideally, final implementations should be calculated from their specifications, using simple laws that relate programs, in the same way we calculate with mathematical expressions in algebra. The calculational approach is particular appealing in the area of functional programming, since referential transparency ensures that expressions in func- tional programs behave as ordinary expressions in mathematics.
    [Show full text]
  • A Category Theory Primer
    A category theory primer Ralf Hinze Computing Laboratory, University of Oxford Wolfson Building, Parks Road, Oxford, OX1 3QD, England [email protected] http://www.comlab.ox.ac.uk/ralf.hinze/ 1 Categories, functors and natural transformations Category theory is a game with objects and arrows between objects. We let C, D etc range over categories. A category is often identified with its class of objects. For instance, we say that Set is the category of sets. In the same spirit, we write A 2 C to express that A is an object of C. We let A, B etc range over objects. However, equally, if not more important are the arrows of a category. So, Set is really the category of sets and total functions. (There is also Rel, the category of sets and relations.) If the objects have additional structure (monoids, groups etc.) then the arrows are typically structure-preserving maps. For every pair of objects A; B 2 C there is a class of arrows from A to B, denoted C(A; B). If C is obvious from the context, we abbreviate f 2 C(A; B) by f : A ! B. We will also loosely speak of A ! B as the type of f . We let f , g etc range over arrows. For every object A 2 C there is an arrow id A 2 C(A; A), called the identity. Two arrows can be composed if their types match: if f 2 C(A; B) and g 2 C(B; C ), then g · f 2 C(A; C ).
    [Show full text]
  • Constructively Characterizing Fold and Unfold*
    Constructively Characterizing Fold and Unfold? Tjark Weber1 and James Caldwell2 1 Institut fur¨ Informatik, Technische Universit¨at Munchen¨ Boltzmannstr. 3, D-85748 Garching b. Munchen,¨ Germany [email protected] 2 Department of Computer Science, University of Wyoming Laramie, Wyoming 82071-3315 [email protected] Abstract. In this paper we formally state and prove theorems charac- terizing when a function can be constructively reformulated using the recursion operators fold and unfold, i.e. given a function h, when can a function g be constructed such that h = fold g or h = unfold g? These results are refinements of the classical characterization of fold and unfold given by Gibbons, Hutton and Altenkirch in [6]. The proofs presented here have been formalized in Nuprl's constructive type theory [5] and thereby yield program transformations which map a function h (accom- panied by the evidence that h satisfies the required conditions), to a function g such that h = fold g or, as the case may be, h = unfold g. 1 Introduction Under the proofs-as-programs interpretation, constructive proofs of theorems re- lating programs yield \correct-by-construction" program transformations. In this paper we formally prove constructive theorems characterizing when a function can be formulated using the recursion operators fold and unfold, i.e. given a func- tion h, when does there exist (constructively) a function g such that h = fold g or h = unfold g? The proofs have been formalized in Nuprl's constructive type theory [1, 5] and thereby yield program transformations which map a function h { accompanied by the evidence that h satisfies the required conditions { to a function g such that h = fold g or, as the case may be, h = unfold g.
    [Show full text]
  • Problem Set 3
    Problem Set 3 IAP 2020 18.S097: Programming with Categories Due Friday January 31 Good academic practice is expected. In particular, cooperation is encouraged, but assignments must be written up alone, and collaborators and resources consulted must be acknowledged. We suggest that you attempt all problems, but we do not expect all problems to be solved. We expect some to be easier if you have more experience with mathematics, and others if you have more experience with programming. The problems in this problem set are in general a step more difficult than those in previous problem sets. Nonetheless, the guideline remains that five problems is a good number to attempt, write up, and submit as homework. Question 1. Pullbacks and limits. Products and terminal objects are examples of limits. Another example is the f g pullback. Let C be a category, and let X −! A − Y be a pair of morphisms in C. The f g pullback of X −! A − Y is an object X ×A Y and a pair of morphisms π1 : X ×A Y ! X and π2 : X ×A Y ! Y such that for all commuting squares C h X k f Y g A there is a unique map u: C ! X ×A Y such that C h u π1 X ×A Y X k π2 f Y g A commutes. We'll think about pullbacks in the category Set of sets and functions. ! ! (a) What is the pullback of the diagram N −! 1 − B? (b) What is the pullback of the diagram X −!! 1 −! Y ? 1 isEven yes (c) What is the pullback of the diagram N −−−−! B −− 1? Here N is the set of natural numbers B = fyes; nog, and isEven: N ! B answers the question \Is n even?".
    [Show full text]
  • Cognitive Architecture and Second-Order
    Cognitive architecture and second-order systematicity: categorical compositionality and a (co)recursion model of systematic learning Steven Phillips ([email protected]) Mathematical Neuroinformatics Group, National Institute of Advanced Industrial Science and Technology (AIST), Tsukuba, Ibaraki 305-8568 JAPAN William H. Wilson ([email protected]) School of Computer Science and Engineering, The University of New South Wales, Sydney, New South Wales, 2052 AUSTRALIA Abstract each other. An example that is pertinent to the classical ex- planation is the learning (or memorization) of arbitrary asso- Systematicity commonly means that having certain cognitive capacities entails having certain other cognitive capacities. ciations. For instance, if one has the capacity to learn (mem- Learning is a cognitive capacity central to cognitive science, orize) that the first day of the Japanese financial year is April but systematic learning of cognitive capacities—second-order 1st, then one also has the capacity to learn (memorize) that systematicity—has received little investigation. We proposed associative learning as an instance of second-order systematic- the atomic number of carbon is 6. This example is a legiti- ity that poses a paradox for classical theory, because this form mate instance of systematicity (at the second level) given that of systematicity involves the kinds of associative constructions systematicity has been characterized as equivalence classes that were explicitly rejected by the classical explanation. In fact, both first and second-order forms of systematicity can of cognitive capacities (McLaughlin, 2009). be derived from the formal, category-theoretic concept of uni- Elsewhere (Phillips & Wilson, submitted), we argue that versal morphisms to address this problem.
    [Show full text]
  • Recursion Parameterised by Monads: Characterisation and Examples
    Recursion Parameterised by Monads: Characterisation and Examples Johan Glimming [email protected] Stockholm University (KTH) Sweden 9 December 2003 ¢ £ ¡ ¡ ¡ 1 • • Explain the required lifting from F-algebras to FM -algebras [Beck 1969, Fokkinga 1994, Pardo 2001]. • Conclude by (briefly) describing on-going research on the semantics of objects with method update [Glimming, Ghani 2003]. Aims • Describe the extension of folds to monadic folds, and present state monads via example. ¢ £ ¡ ¡ ¡ J. GLIMMING 2 • • Conclude by (briefly) describing on-going research on the semantics of objects with method update [Glimming, Ghani 2003]. Aims • Describe the extension of folds to monadic folds, and present state monads via example. • Explain the required lifting from F-algebras to FM -algebras [Beck 1969, Fokkinga 1994, Pardo 2001]. ¢ £ ¡ ¡ ¡ J. GLIMMING 2 • Aims • Describe the extension of folds to monadic folds, and present state monads via example. • Explain the required lifting from F-algebras to FM -algebras [Beck 1969, Fokkinga 1994, Pardo 2001]. • Conclude by (briefly) describing on-going research on the semantics of objects with method update [Glimming, Ghani 2003]. ¢ £ ¡ ¡ ¡ J. GLIMMING 2 • Folds, Monads, and Monadic Folds ¢ £ ¡ ¡ ¡ J. GLIMMING 3 • Recursion = fold • Structural recursion is captured by a combinator called fold, i.e. foldList , foldNat , foldTree, ... sum [] = 0 sum x:xs = x + sum xs • Let List denote lists of natural numbers, e.g. [881,883,887]. ¢ £ ¡ ¡ ¡ J. GLIMMING 4 • • (Nat; [0; +]) forms an algebra of the same pattern functor as (List; [[]; :]). • × × ! × ! foldList has type τ (τ τ τ) List τ. • Write ([f ])F for fold/catamorphism. f can be [0; +]; [[x]; :]; ::: Recursion = fold • The important part of this schema is 0 : τ and + : τ × τ ! τ where τ is Nat for sum.
    [Show full text]
  • Chapter 3 Recursion in the Pointfree Style
    Chapter 3 Recursion in the Pointfree Style How useful from a programmer’s point of view are the abstract concepts presented in the previous chapter? Recall that a table was presented — table 2.1 — which records an analogy between abstract type notation and the corresponding data- structures available in common, imperative languages. This analogy will help in showing how to extend the abstract notation studied thus far towards a most important field of programming: recursion. This, however, will be preceeded by a simpler introduction to the subject rooted on very basic and intuitive notions of mathematics. 3.1 Motivation Where do algorithms come from? From human imagination only? Surely not — they actually emerge from mathematics. In a sense, in the same way one may say that hardware follows the laws of physics (eg. semiconductor electronics) one might say that software is governed by the laws of mathematics. This section provides a naive introduction to algorithm analysis and synthesis by showing how a quite elementary class of algorithms — equivalent to for-loops in C or any other imperative language — arise from elementary properties of the underlying maths domain. We start by showing how the arithmetic operation of multiplying two natural numbers (in N0) is a for-loop which emerges solely from the algebraic properties 63 64 CHAPTER 3. RECURSION IN THE POINTFREE STYLE of multiplication: a 0 = 0 × a 1 = a (3.1) a × (b + c) = a b + a c × × × These properties are known as the absorption, unit and distributive properties of multiplication, respectively. Start by making c := 1 in the third (distributive) property, obtaining a (b + × 1) = a b + a 1, and then simplify.
    [Show full text]
  • New Approaches in Functional Programming Using Algebras and Coalgebras
    New approaches in functional programming using algebras and coalgebras Viliam Slodičák, Pavol Macko Department of Computers and Informatics Faculty of Electrical Engineering and Informatics Technical University of Koˇsice ETAPS - Workshop on generative technologies Saarbrücken, 27.03.2011 Viliam Slodičák, Pavol MackoNew approaches in functional programming using algebras and coalgebras 1/27 Basic Concepts: Category theory Program is defined as data structures and algorithms. In developing large scale programs we always have to apply several mathematical theories. The goal of programming is then to formulate a solution over these theories. Mathematical machines (i.e. computers) are able to make logical reasoning over representations of types. Categories are useful in computer science, where we often use more complex structures not expressible by sets. The relations between objects are expressed by morphisms. Viliam Slodičák, Pavol MackoNew approaches in functional programming using algebras and coalgebras 2/27 Basic Concepts: Category theory Category Ob(C ), objects of category C , e.g. A, B, . .; Morph(C ), morphisms of category C , e.g. f : A → B; identity morphism for each object of C , idA : A → A; composition of morphisms: for f : A → B and g : B → C there is f ◦ g : A → C. Functor is a morphism between categories, F : C → D; maps objects of C to objects of D ; maps morphism C1 → C2 in C to morphism FC1 → FC2 in D. Viliam Slodičák, Pavol MackoNew approaches in functional programming using algebras and coalgebras 3/27 Recursion versus corecursion Recursion in computer programming is exemplified when a function is defined in terms of simpler, often smaller versions of itself.
    [Show full text]
  • Category Theory for Programmers
    Category Theory for Programmers Bartosz Milewski Category Theory for Programmers Bartosz Milewski Version 0.1, September 2017 This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License (cc by-sa 4.0). Converted to LaTeX from a series of blog posts by Bartosz Milewski. PDF compiled by Igal Tabachnik. Contents Preface xiii I Part One 1 1 Category: The Essence of Composition 2 1.1 Arrows as Functions ................... 2 1.2 Properties of Composition ................ 5 1.3 Composition is the Essence of Programming ...... 8 1.4 Challenges ......................... 10 2 Types and Functions 11 2.1 Who Needs Types? .................... 11 2.2 Types Are About Composability ............. 13 2.3 What Are Types? ..................... 14 2.4 Why Do We Need a Mathematical Model? ....... 17 2.5 Pure and Dirty Functions ................. 20 2.6 Examples of Types ..................... 21 2.7 Challenges ......................... 25 iii 3 Categories Great and Small 27 3.1 No Objects ......................... 27 3.2 Simple Graphs ....................... 28 3.3 Orders ........................... 28 3.4 Monoid as Set ....................... 29 3.5 Monoid as Category .................... 34 3.6 Challenges ......................... 37 4 Kleisli Categories 39 4.1 The Writer Category ................... 44 4.2 Writer in Haskell ..................... 48 4.3 Kleisli Categories ..................... 50 4.4 Challenge ......................... 51 5 Products and Coproducts 53 5.1 Initial Object ........................ 54 5.2 Terminal Object ...................... 56 5.3 Duality ........................... 57 5.4 Isomorphisms ....................... 58 5.5 Products .......................... 60 5.6 Coproduct ......................... 66 5.7 Asymmetry ........................ 70 5.8 Challenges ......................... 73 5.9 Bibliography ........................ 74 6 Simple Algebraic Data Types 75 6.1 Product Types ....................... 76 6.2 Records ..........................
    [Show full text]