Generic Programming with Adjunctions

Transcription

1 Generic Programming with Adjunctions 0.0 Generic Programming with Adjunctions Ralf Hinze Computing Laboratory, University of Oxford Wolfson Building, Parks Road, Oxford, OX1 3QD, England March 2010 University of Oxford Ralf Hinze 1-172

2 Generic Programming with Adjunctions 1.0 Part 1 Prologue University of Oxford Ralf Hinze 2-172

3 Generic Programming with Adjunctions Outline 1. What? 2. Why? 3. Where? 4. Overview University of Oxford Ralf Hinze 3-172

4 Generic Programming with Adjunctions What? What? Haskell programmers have embraced functors, natural transformations, initial algebras, final coalgebras, monads,... It is time to turn our attention to adjunctions. University of Oxford Ralf Hinze 4-172

5 Generic Programming with Adjunctions Why? Catamorphism f = b f in = b F f University of Oxford Ralf Hinze 5-172

6 Generic Programming with Adjunctions Why? Banana-split law h k = h F outl k F outr University of Oxford Ralf Hinze 6-172

7 Generic Programming with Adjunctions Why? Proof of banana-split law ( h k ) in = { split-fusion } h in k in = { fold-computation } h F h k F k = { split-computation } h F (outl ( h k )) k F (outr ( h k )) = { F functor } h F outl F ( h k ) k F outr F ( h k ) = { split-fusion } (h F outl k F outr) F ( h k ) University of Oxford Ralf Hinze 7-172

8 Generic Programming with Adjunctions Why? Example: total data Stack = Empty Push (Nat, Stack) total : Stack Nat total (Empty) = 0 total (Push (n, s)) = n + total s University of Oxford Ralf Hinze 8-172

9 Generic Programming with Adjunctions Why? Two-level types Abstracting away from the recursive call. data Stack stack = Empty Push (Nat, stack) instance Functor Stack where fmap f (Empty) = Empty fmap f (Push (n, s)) = Push (n, f s) Tying the recursive knot. newtype µf = In {in : f (µf )} type Stack = µstack University of Oxford Ralf Hinze 9-172

10 Generic Programming with Adjunctions Why? Two-level functions Structure. total : Stack Nat Nat total (Empty) = 0 total (Push (n, s)) = n + s Tying the recursive knot. total : µstack Nat total (In s) = total (fmap total s) University of Oxford Ralf Hinze

11 Generic Programming with Adjunctions Why? Counterexample: stack stack : (Stack, Stack) Stack stack (Empty, bs) = bs stack (Push (a, as), bs) = Push (a, stack (as, bs)) University of Oxford Ralf Hinze

12 Generic Programming with Adjunctions Why? Counterexamples: fac and fib data Nat = Z S Nat fac : Nat Nat fac (Z) = 1 fac (S n) = S n fac n fib : Nat Nat fib (Z) = Z fib (S Z) = S Z fib (S (S n)) = fib n + fib (S n) University of Oxford Ralf Hinze

13 Generic Programming with Adjunctions Why? Counterexample: sum data List a = Nil Cons (a, List a) sum : List Nat Nat sum (Nil) = 0 sum (Cons (a, as)) = a + sum as University of Oxford Ralf Hinze

14 Generic Programming with Adjunctions Why? Counterexample: append append : a. (List a, List a) List a append (Nil, bs) = bs append (Cons (a, as), bs) = Cons (a, append (as, bs)) University of Oxford Ralf Hinze

15 Generic Programming with Adjunctions Why? Counterexample: concat concat : a. List (List a) List a concat (Nil) = Nil concat (Cons (l, ls)) = append (l, concat ls) University of Oxford Ralf Hinze

16 Generic Programming with Adjunctions Where? References The lectures are based on: Part 1: R. Hinze: A category theory primer, SSGIP Part 2 & 3: R. Hinze: Adjoint Folds and Unfolds, MPC 10. Part 4: R. Hinze: Type Fusion. Further reading: S. Mac Lane: Categories for the Working Mathematician. M. Fokkinga, L. Meertens: Adjunctions. R. Bird, R. Paterson: Generalised folds for nested datatypes. University of Oxford Ralf Hinze

17 Generic Programming with Adjunctions Overview Overview Part 0: Prologue Part 1: Category theory Part 2: Adjoint folds and unfolds Part 3: Adjunctions Part 4: Application: Type fusion Part 5: Epilogue University of Oxford Ralf Hinze

18 Generic Programming with Adjunctions 2.0 Part 2 Category theory University of Oxford Ralf Hinze

19 Generic Programming with Adjunctions Outline 5. Categories, functors and natural transformations 6. Constructions on categories 7. Initial and final objects 8. Products 9. Adjunctions 10. Yoneda lemma University of Oxford Ralf Hinze

20 Generic Programming with Adjunctions Categories, functors and natural transformations Category objects: A C, arrows: f C(A, B), identity: id A C(A, A), composition: if f C(A, B) and g C(B, C), then g f C(A, C), is associative with id as its neutral element. University of Oxford Ralf Hinze

21 Generic Programming with Adjunctions Categories, functors and natural transformations Example: a preorder P objects: a P, arrows: a b, identity: a a (reflexivity), composition: if a b and b c, then a c (transitivity). NB There is at most one arrow between two objects. University of Oxford Ralf Hinze

22 Generic Programming with Adjunctions Categories, functors and natural transformations Example: Set objects: sets, arrows: total functions, identity: id x = x, composition: function composition (g f ) x = g (f x). University of Oxford Ralf Hinze

23 Generic Programming with Adjunctions Categories, functors and natural transformations Example: Mon objects: monoids A, ɛ, +, arrows: monoid homomorphisms h : A, 0, + B, 1, : h 0 = 1 h (x + y) = h x h y, identity: id x = x, composition: function composition (g f ) x = g (f x). University of Oxford Ralf Hinze

24 Generic Programming with Adjunctions Categories, functors and natural transformations Functor F : C D, action on objects, action on arrows, if f C(A, B), then F f D(F A, F B) F id A = id F A, F (g f ) = F g F f. University of Oxford Ralf Hinze

25 Generic Programming with Adjunctions Categories, functors and natural transformations Example: the forgetful functor U : Mon Set, action on objects: U A, ɛ, + = A, action on arrows: U f = f. University of Oxford Ralf Hinze

26 Generic Programming with Adjunctions Categories, functors and natural transformations Natural transformation let F, G : C D be two parallel functors, a transformation α : F G is a collection of arrows: for each object A C there is an arrow α A D(F A, G A), a natural transformation α : F G additionally satisfies G h α A = α B F h for all arrows h C(A, B). F A F h F B α A G A G h G B α B University of Oxford Ralf Hinze

27 Generic Programming with Adjunctions Constructions on categories Cat objects: small categories, arrows: functors, identity: identity functor: Id C A = A and Id C f = f, composition: (G F) A = G (F A) and (G F) f = G (F f ). University of Oxford Ralf Hinze

28 Generic Programming with Adjunctions Constructions on categories Functor category D C let C and D be two categories, objects: functors C D, arrows: natural transformations F G, identity: id F A = id F A, composition: (β α) A = β A α A. University of Oxford Ralf Hinze

29 Generic Programming with Adjunctions Constructions on categories Opposite category C op let C be a category, objects: A C op if A C arrows: f C op (A, B) if f C(B, A) identity: id A C(A, A), composition: g f C op (A, C) if f g C(C, A). University of Oxford Ralf Hinze

30 Generic Programming with Adjunctions Constructions on categories Product category C 1 C 2 let C 1 and C 2 be two categories, objects: A 1, A 2 C 1 C 2 if A 1 C 1 and A 2 C 2, arrows: f 1, f 2 (C 1 C 2 )( A 1, A 2, B 1, B 2 ) if f 1 C 1 (A 1, B 1 ) and f 2 C 2 (A 2, B 2 ), identity: id = id, id, composition: g 1, g 2 f 1, f 2 = g 1 f 1, g 2 f 2. University of Oxford Ralf Hinze

31 Generic Programming with Adjunctions Constructions on categories Outl, Outr and projection functors: Outl : C D C; Outl A, B = A; Outl f, g = f ; Outr : C D D; Outr A, B = B; Outr f, g = g. diagonal functor: : C C C; A = A, A ; f = f, f. University of Oxford Ralf Hinze

32 Generic Programming with Adjunctions Constructions on categories The hom-functor C(, =) : C op C Set, action on objects: C(, =) A, B = C(A, B), action on arrows: C(, =) f, g = λ h. g h f, shorthand: C(f, g) h = g h f. University of Oxford Ralf Hinze

33 Generic Programming with Adjunctions Initial and final objects Initial object The object 0 is initial if for each object B C there is exactly one arrow from 0 to B, denoted B (pronounce gnab ). 0 B B University of Oxford Ralf Hinze

34 Generic Programming with Adjunctions Initial and final objects Final object Dually, 1 is a final object if for each object A C there is a unique arrow from A to 1, denoted! A (pronounce bang ). A! A 1 University of Oxford Ralf Hinze

35 Generic Programming with Adjunctions Products Product The product of two objects B 1 and B 2 consists of an object written B 1 B 2, a pair of arrows outl : B 1 B 2 B 1 and outr : B 1 B 2 B 2, and satisfies the following universal property: for each object A, for each pair of arrows f 1 : A B 1 and f 2 : A B 2, there exists an arrow f 1 f 2 : A B 1 B 2 such that f 1 = outl g f 2 = outr g f 1 f 2 = g, for all g : A B 1 B 2. University of Oxford Ralf Hinze

36 Generic Programming with Adjunctions Products Product A f 1 B 1 outl. f 1 f 2. B 1 B 2 f 2 outr B 2 University of Oxford Ralf Hinze

37 Generic Programming with Adjunctions Products Laws computation laws: f 1 = outl (f 1 f 2 ); f 2 = outr (f 1 f 2 ), reflection law: outl outr = id A B. University of Oxford Ralf Hinze

38 Generic Programming with Adjunctions Products Laws fusion law: (f 1 f 2 ) h = f 1 h f 2 h, action of on arrows: f 1 f 2 = f 1 outl f 2 outr, functor fusion law: (k 1 k 2 ) (f 1 f 2 ) = k 1 f 1 k 2 f 2, outl and outr are natural transformations: k 1 outl = outl (k 1 k 2 ); k 2 outr = outr (k 1 k 2 ). University of Oxford Ralf Hinze

39 Generic Programming with Adjunctions Products Proof of functor fusion (k 1 k 2 ) (f 1 f 2 ) = { definition of } (k 1 outl k 2 outr) (f 1 f 2 ) = { fusion } k 1 outl (f 1 f 2 ) k 2 outr (f 1 f 2 ) = { computation } k 1 f 1 k 2 f 2 University of Oxford Ralf Hinze

40 Generic Programming with Adjunctions Products Naturality fusion and functor fusion: ( ) : A B. (C C)( A, B) C(A, B), naturality of outl and outr: outl : B. C( B, Outl B); outr : B. C( B, Outr B), or more succinctly outl, outr : B. (C C)( ( B), B). University of Oxford Ralf Hinze

41 Generic Programming with Adjunctions Adjunctions Adjunction C L R D φ : A B. C(L A, B) D(A, R B) University of Oxford Ralf Hinze

42 Generic Programming with Adjunctions Adjunctions Adjoints, adjuncts and units left and right adjoints: L g = φ (η g), R f = φ (f ɛ), left and right adjuncts: φ g = ɛ L g, φ f = R f η, counit and unit: ɛ = φ id, η = φ id. University of Oxford Ralf Hinze

43 Generic Programming with Adjunctions Adjunctions Adjoints of the diagonal functor f = outl, outr g f = g C + C C C f = g f inl, inr = g University of Oxford Ralf Hinze

44 Generic Programming with Adjunctions Adjunctions Left adjoint of the forgetful functor Mon List U Set University of Oxford Ralf Hinze

45 Generic Programming with Adjunctions Adjunctions 2.5 φ introduction / elimination φ elimination / introduction Universal property f = φ g φ f = g ɛ : C(L (R B), B) η : D(A, R (L A)) ɛ = φ id φ id = η / computation law computation law / η-rule / β-rule β-rule / η-rule f = φ (φ f ) φ (φ g) = g reflection law / / reflection law simple η-rule / simple β-rule simple β-rule / simple η-rule id = φ η φ ɛ = id University of Oxford Ralf Hinze

46 Generic Programming with Adjunctions Adjunctions 2.5 φ introduction / elimination φ elimination / introduction Universal property f = φ g φ f = g functor fusion law / / fusion law φ is natural in A φ is natural in A φ g L h = φ (g h) φ f h = φ (f L h) fusion law / / functor fusion law φ is natural in B φ is natural in B k φ g = φ (R k g) R k φ f = φ (k f ) ɛ is natural in B η is natural in A k ɛ = ɛ L (R k) R (L h) η = η h University of Oxford Ralf Hinze

47 Generic Programming with Adjunctions Yoneda lemma Yoneda lemma Let H : C Set be a functor, and let B C be an object. H B C(B, ) H The functions witnessing the isomorphism are φ s = λ κ. H κ s, φ α = α B id B. NB Continuation-passing style is a special case: H = C(A, ). University of Oxford Ralf Hinze

48 Generic Programming with Adjunctions 3.0 Part 3 Adjoint folds and unfolds University of Oxford Ralf Hinze

49 Generic Programming with Adjunctions Outline 11. Semantics of datatypes 12. Mendler-style folds and unfolds 13. Adjoint folds and unfolds University of Oxford Ralf Hinze

50 Generic Programming with Adjunctions Semantics of datatypes Example: total data Stack = Empty Push (Nat, Stack) total : Stack Nat total (Empty) = 0 total (Push (n, s)) = n + total s University of Oxford Ralf Hinze

51 Generic Programming with Adjunctions Semantics of datatypes Fixed-point equations both Stack and total are given by recursion equations, meaning of x = Ψ x? a solves the equation iff a is a fixed point of Ψ, Ψ is called the base function. University of Oxford Ralf Hinze

52 Generic Programming with Adjunctions Semantics of datatypes Two-level types Abstracting away from the recursive call. data Stack stack = Empty Push (Nat, stack) instance Functor Stack where fmap f (Empty) = Empty fmap f (Push (n, s)) = Push (n, f s) Tying the recursive knot. newtype µf = In {in : f (µf )} type Stack = µstack University of Oxford Ralf Hinze

53 Generic Programming with Adjunctions Semantics of datatypes Speaking categorically functor: Stack A = 1 + Nat A, a Stack-algebra: total : Stack Nat Nat total (Empty) = 0 total (Push (n, s)) = n + s total = zero plus, Stack-algebra: Nat, total. University of Oxford Ralf Hinze

54 Generic Programming with Adjunctions Semantics of datatypes The category of F-algebras Alg(F) let F : C C be an endofunctor, objects: A, a with A C and a C(F A, A), arrows: F-homomorphisms, h : A, a B, b if h C(A, B) such that h a = b F h, F A F A F h F B F B a A a A h b B b B identity: id A : A, a A, a, composition: in C. University of Oxford Ralf Hinze

55 Generic Programming with Adjunctions Semantics of datatypes The category of F-coalgebras Coalg(F) let F : C C be an endofunctor, objects: A, a with A C and a C(A, F A), arrows: F-homomorphisms, h : A, a B, b if h C(A, B) such that F h a = b h, A A h B B a F A a F A b F h F B b F B identity: id A : A, a A, a, composition: in C. University of Oxford Ralf Hinze

56 Generic Programming with Adjunctions Semantics of datatypes Fixed points of functors initial object in Alg(F): initial F-algebra µf, in, µf is the least fixed point of F, in : F (µf) µf, final object in Coalg(F): final F-coalgebra νf, out, νf is the greatest fixed point of F, out : νf F (νf). University of Oxford Ralf Hinze

57 Generic Programming with Adjunctions Semantics of datatypes Coq: inductive and coinductive types Inductive Nat : Type := Zero : Nat Succ : Nat Nat. Inductive Stack : Type := Empty : Stack Push : Nat Stack Stack. CoInductive Stream : Type := Cons : Nat Stream Stream. University of Oxford Ralf Hinze

58 Generic Programming with Adjunctions Mendler-style folds and unfolds Semantics of recursive functions total : µstack Nat total (In (Empty)) = 0 total (In (Push (n, s))) = n + total s University of Oxford Ralf Hinze

59 Generic Programming with Adjunctions Mendler-style folds and unfolds Abstracting away from the recursive call total : (µstack Nat) (µstack Nat) total total (In (Empty)) = 0 total total (In (Push (n, s))) = n + total s A function of this type has many fixed points. University of Oxford Ralf Hinze

60 Generic Programming with Adjunctions Mendler-style folds and unfolds removing in Abstracting away from the recursive call and removing in. total : x. (x Nat) (Stack x Nat) total total (Empty) = 0 total total (Push (n, s)) = n + total s A function of this type has a unique fixed point. Tying the recursive knot. total : µstack Nat total (In l) = total total l University of Oxford Ralf Hinze

61 Generic Programming with Adjunctions Mendler-style folds and unfolds Example: from data Sequ = Next (Nat, Sequ) from : Nat Sequ from n = Next (n, from (n + 1)) University of Oxford Ralf Hinze

62 Generic Programming with Adjunctions Mendler-style folds and unfolds Two-level types and functions data Sequ sequ = Next (Nat, sequ) from : x. (Nat x) (Nat Sequ x) from from n = Next (n, from (n + 1)) from : Nat νsequ from n = Out (from from n). University of Oxford Ralf Hinze

63 Generic Programming with Adjunctions Mendler-style folds and unfolds Initial fixed-point equations An initial fixed-point equation in the unknown x C(µF, A) has the syntactic form x in = Ψ x, where the base function Ψ has type Ψ : X. C(X, A) C(F X, A). The naturality of Ψ ensures termination. University of Oxford Ralf Hinze

64 Generic Programming with Adjunctions Mendler-style folds and unfolds Guarded by destructors x = Ψ x in x C(µF, A) Ψ : X. C(X, A) C(F X, A) µf in F (µf) Ψ x A University of Oxford Ralf Hinze

65 Generic Programming with Adjunctions Mendler-style folds and unfolds Mendler-style folds x = Ψ Id x in = Ψ x University of Oxford Ralf Hinze

66 Generic Programming with Adjunctions Mendler-style folds and unfolds Proof of uniqueness φ : C(F A, A) ( X. C(X, A) C(F X, A)) x in = Ψ x { isomorphism } x in = φ (φ Ψ) x { definition of φ : φ Ψ = Ψ id } x in = φ (Ψ id) x { definition of φ: φ f = λ κ. f F κ } x in = Ψ id F x { initial algebras } x = Ψ id University of Oxford Ralf Hinze

67 Generic Programming with Adjunctions Mendler-style folds and unfolds Final fixed-point equations A final fixed-point equation in the unknown x C(A, νf) has the syntactic form out x = Ψ x, where the base function Ψ has type Ψ : X. C(A, X ) C(A, F X ). The naturality of Ψ ensures productivity. University of Oxford Ralf Hinze

68 Generic Programming with Adjunctions Mendler-style folds and unfolds Guarded by constructors x = out Ψ x x C (A, νf) Ψ : X. C(A, X ) C(A, F X ) A Ψ x F (νf) out νf University of Oxford Ralf Hinze

69 Generic Programming with Adjunctions Mendler-style folds and unfolds Mendler-style unfolds x = [(Ψ)] Id out x = Ψ x University of Oxford Ralf Hinze

70 Generic Programming with Adjunctions Mendler-style folds and unfolds Mutual type recursion data Tree = Node Nat Trees data Trees = Nil Cons (Tree, Trees) flattena : Tree Stack flattena (Node n ts) = Push (n, flattens ts) flattens : Trees Stack flattens (Nil) = Empty flattens (Cons (t, ts)) = stack (flattena t, flattens ts) University of Oxford Ralf Hinze

71 Generic Programming with Adjunctions Mendler-style folds and unfolds Speaking categorically Idea: view Tree and Trees as a fixed point in a product category. T A, B = Nat B, 1 + A B flatten (C C)(µT, Stack, Stack ) University of Oxford Ralf Hinze

72 Generic Programming with Adjunctions Mendler-style folds and unfolds Specialising fixed-point equations An equation in C D corresponds to two equations, one in C and one in D. x in = Ψ x x 1 in 1 = Ψ 1 x 1, x 2 and x 2 in 2 = Ψ 2 x 1, x 2 Here, x 1 = Outl x, x 2 = Outr x, in 1 = Outl in, in 2 = Outr in, Ψ 1 = Outl Ψ and Ψ 2 = Outr Ψ. University of Oxford Ralf Hinze

73 Generic Programming with Adjunctions Mendler-style folds and unfolds Parametric datatypes data Perfect a = Zero a Succ (Perfect (a, a)) size : a. Perfect a Nat size (Zero a) = 1 size (Succ p) = 2 size p University of Oxford Ralf Hinze

74 Generic Programming with Adjunctions Mendler-style folds and unfolds Speaking categorically Idea: view Perfect as a fixed point in a functor category. P F = Λ A. A + F (A A) The second-order functor F sends a functor to a functor. size : µp K Nat NB K : D D C is the constant functor K A = Λ B. A. University of Oxford Ralf Hinze

75 Generic Programming with Adjunctions Mendler-style folds and unfolds Specialising fixed-point equations x in = Ψ x x A in A = Ψ x A NB Type application and abstraction are invisible in Haskell. University of Oxford Ralf Hinze

76 Generic Programming with Adjunctions Mendler-style folds and unfolds 3.2 initial fixed-point equation x in = Ψ x final fixed-point equation out x = Ψ x Set inductive type coinductive type standard fold standard unfold Cpo continuous coalgebra continuous unfold Cpo strict continuous fold strict continuous unfold continuous algebra continuous coalgebra (µf νf) C D mutually rec. ind. types mutually rec. coind. types mutually rec. folds mutually rec. unfolds D C inductive type functor coinductive type functor higher-order fold higher-order unfold University of Oxford Ralf Hinze

77 Generic Programming with Adjunctions Adjoint folds and unfolds Counterexample: stack stack : (µstack, Stack) Stack stack (In (Empty), bs) = bs stack (In (Push (a, as)), bs) = In (Push (a, stack (as, bs))) University of Oxford Ralf Hinze

78 Generic Programming with Adjunctions Adjoint folds and unfolds Counterexample: nats and squares nats : Nat νsequ nats n = Out (Next (n, squares n)) squares : Nat νsequ squares n = Out (Next (n n, nats (n + 1))) University of Oxford Ralf Hinze

79 Generic Programming with Adjunctions Adjoint folds and unfolds Adjoint fixed-point equations Idea: model the context by a functor. x L in = Ψ x R out x = Ψ x Requirement: the functors have to be adjoint: L R. University of Oxford Ralf Hinze

80 Generic Programming with Adjunctions Adjoint folds and unfolds Adjoint initial fixed-point equations An adjoint initial fixed-point equation in the unknown x C(L (µf), A) has the syntactic form x L in = Ψ x, where the base function Ψ has type Ψ : X : D. C(L X, A) C(L (F X ), A). The unique solution is called an adjoint fold. Furthermore, φ x is called the transposed fold. University of Oxford Ralf Hinze

81 Generic Programming with Adjunctions Adjoint folds and unfolds Proof of uniqueness x L in = Ψ x { adjunction } φ (x L in) = φ (Ψ x) { naturality of φ: φ f h = φ (f L h) } φ x in = φ (Ψ x) { adjunction } φ x in = (φ Ψ φ ) (φ x) { universal property of Mendler-style folds } φ x = φ Ψ φ Id { adjunction } x = φ φ Ψ φ Id University of Oxford Ralf Hinze

82 Generic Programming with Adjunctions Adjoint folds and unfolds Adjoint folds x = Ψ L x L in = Ψ x University of Oxford Ralf Hinze

83 Generic Programming with Adjunctions Adjoint folds and unfolds Banana-split law Φ L Ψ L = λ x. Φ (outl x) Ψ (outr x) L University of Oxford Ralf Hinze

84 Generic Programming with Adjunctions Adjoint folds and unfolds Proof of banana-split law ( Φ L Ψ L ) L in = { split-fusion } Φ L L in Ψ L L in = { fold-computation } Φ Φ L Ψ Ψ L = { split-computation } Φ (outl ( Φ L Ψ L )) Ψ (outl ( Φ L Ψ L )) University of Oxford Ralf Hinze

85 Generic Programming with Adjunctions Adjoint folds and unfolds Adjoint final fixed-point equations An adjoint final fixed-point equation in the unknown x D(A, R (νf)) has the syntactic form R out x = Ψ x, where the base function Ψ has type Ψ : X : C. D(A, R X ) D(A, R (F X )). The unique solution is called an adjoint unfold. University of Oxford Ralf Hinze

86 Generic Programming with Adjunctions Adjoint folds and unfolds Adjoint unfolds x = [(Ψ)] R R out x = Ψ x University of Oxford Ralf Hinze

87 Generic Programming with Adjunctions 4.0 Part 4 Adjunctions University of Oxford Ralf Hinze

88 Generic Programming with Adjunctions Outline 14. Identity 15. Currying 16. Mutual Value Recursion 17. Type Application 18. Type Composition University of Oxford Ralf Hinze

89 Generic Programming with Adjunctions Identity Recall: Adjoint fixed-point equations x L in = Ψ x R out x = Ψ x Requirement: the functors have to be adjoint: L R. University of Oxford Ralf Hinze

90 Generic Programming with Adjunctions Identity Identity C Id Id C φ : A B. C(Id A, B) C(A, Id B) Adjoint fixed-point equations subsume Mendler-style ones. University of Oxford Ralf Hinze

91 Generic Programming with Adjunctions Currying Recall: stack stack : (µstack, Stack) Stack stack (In (Empty), bs) = bs stack (In (Push (a, as)), bs) = In (Push (a, stack (as, bs))) The type µstack is embedded in a context L: L A = A Stack L f = f id Stack. University of Oxford Ralf Hinze

92 Generic Programming with Adjunctions Currying Currying C X ( ) X C φ : A B. C(A X, B) C(A, B X ) University of Oxford Ralf Hinze

93 Generic Programming with Adjunctions Currying Specialising adjoint equations x L in = Ψ x { definition of L } x (in id) = Ψ x { pointwise } x (in a, c) = Ψ x (a, c) R out x = Ψ x { definition of R } (out ) x = Ψ x { pointwise } out (x a c) = Ψ x a c University of Oxford Ralf Hinze

94 Generic Programming with Adjunctions Currying stack as an adjoint fold stack : x. (L x Stack) (L (Stack x) Stack) stack stack (Empty, bs) = bs stack stack (Push (a, as), bs) = In (Push (a, stack (as, bs))) stack : L (µstack) Stack stack (In as, bs) = stack stack (as, bs) University of Oxford Ralf Hinze

95 Generic Programming with Adjunctions Currying The transpose of stack R A = A Stack R f = f id Stack The transposed fold is the curried variant of stack. stack : µstack R Stack stack (In Empty) = λbs bs stack (In (Push (a, as))) = λbs In (Push (a, stack as bs)) University of Oxford Ralf Hinze

96 Generic Programming with Adjunctions Currying Recall: append append : a. (List a, List a) List a append (Nil, bs) = bs append (Cons (a, as), bs) = Cons (a, append (as, bs)) University of Oxford Ralf Hinze

97 Generic Programming with Adjunctions Currying Two-level types data LIST list a = Nil Cons (a, list a) instance (Functor list) Functor (LIST list) where fmap f (Nil) = Nil fmap f (Cons (a, as)) = Cons (f a, fmap f as) append : a. (µlist a, List a) List a append (In (Nil), bs) = bs append (In (Cons (a, as)), bs) = In (Cons (a, append (as, bs))) University of Oxford Ralf Hinze

98 Generic Programming with Adjunctions Currying append as a natural transformation Definining (F G) A = F A G A, we can view append as a natural transformation: append : List List List. We have to find the right adjoint of the lifted product H. University of Oxford Ralf Hinze

99 Generic Programming with Adjunctions Currying Deriving the right adjoint G H A { Yoneda lemma } C(A, ) G H { requirement: H H } C(A, ) H G { natural transformation } X : C. C(A, X ) H X G X { X X } X : C. C(A, X ) (G X ) H X. NB We assume that the functor category is Set C so G H : C Set. University of Oxford Ralf Hinze

100 Generic Programming with Adjunctions Currying The transpose of append append : List List List In Haskell: append : a. List a x. (a x) (List x List x) append as = λf λbs append (fmap f as, bs). NB append combines append with fmap. University of Oxford Ralf Hinze

101 Generic Programming with Adjunctions Mutual Value Recursion Recall: nats and squares nats : Nat νsequ nats n = Out (Next (n, squares n)) squares : Nat νsequ squares n = Out (Next (n n, nats (n + 1))) University of Oxford Ralf Hinze

102 Generic Programming with Adjunctions Mutual Value Recursion Speaking categorically numbers : Nat, Nat (νsequ) University of Oxford Ralf Hinze

103 Generic Programming with Adjunctions Mutual Value Recursion Adjoints of the diagonal functor φ : A B. C((+) A, B) (C C)(A, B) C + C C C φ : A B. (C C)( A, B) C(A, ( ) B) University of Oxford Ralf Hinze

104 Generic Programming with Adjunctions Mutual Value Recursion Specialising adjoint equations out x = Ψ x out x 1 = Ψ 1 x 1, x 2 and out x 2 = Ψ 2 x 1, x 2 Here, x 1 = Outl x, x 2 = Outr x, Ψ 1 = Outl Ψ and Ψ 2 = Outr Ψ. University of Oxford Ralf Hinze

105 Generic Programming with Adjunctions Mutual Value Recursion The transpose of nats and squares numbers : Either Nat Nat νsequ numbers (Left n) = Out (Next (n, numbers (Right n))) numbers (Right n) = Out (Next (n n, numbers (Left (n + 1)))) University of Oxford Ralf Hinze

106 Generic Programming with Adjunctions Mutual Value Recursion A special case: paramorphisms fac : µnat Nat fac (In (Z)) = 1 fac (In (S n)) = In (S (id n)) fac n id : µnat Nat id (In (Z)) = In Z id (In (S n)) = In (S (id n)) University of Oxford Ralf Hinze

107 Generic Programming with Adjunctions Mutual Value Recursion A special case: histomorphisms fib : µnat Nat fib (In (Z)) = 0 fib (In (S n)) = fib n fib : µnat Nat fib (In (Z)) = 1 fib (In (S n)) = fib n + fib n University of Oxford Ralf Hinze

108 Generic Programming with Adjunctions Type Application Recall: sum data List a = Nil Cons (a, List a) sum : List Nat Nat sum (Nil) = 0 sum (Cons (a, as)) = a + sum as University of Oxford Ralf Hinze

109 Generic Programming with Adjunctions Type Application Likewise for perfect trees sump : Perfect Nat Nat sump (Zero n) = n sump (Succ p) = sump (fmap plus p) plus (a, b) = a + b NB The recursive call is not applied to a subterm of Succ p. University of Oxford Ralf Hinze

110 Generic Programming with Adjunctions Type Application Speaking categorically where sum : App Nat List K Nat App X : C D C App X F = F X App X α = α X. University of Oxford Ralf Hinze

111 Generic Programming with Adjunctions Type Application 4.4 φ : A B. C D (Lsh X A, B) C(A, App X B) C D Lsh X App X C App X Rsh X CD φ : A B. C(App X A, B) C D (A, Rsh X B) University of Oxford Ralf Hinze

112 Generic Programming with Adjunctions Type Application Deriving the left adjoint C(A, App X B) { definition of App X } C(A, B X ) { Yoneda } Y : D. D(X, Y ) C(A, B Y ) { definition of a copower: Ix C(X, Y ) C( Ix. X, Y ) } Y : D. C( D(X, Y ). A, B Y ) { define Lsh X A = Λ Y : D. D(X, Y ). A } Y : D. C(Lsh X A Y, B Y ) { natural transformation } Lsh X A B University of Oxford Ralf Hinze

113 Generic Programming with Adjunctions Type Application Left shifts in Haskell newtype Lsh x a y = Lsh (x y, a) instance Functor (Lsh x a) where fmap f (Lsh (κ, a)) = Lsh (f κ, a) φ Lsh : ( y. Lsh x a y b y) (a b x) φ Lsh α = λs α (Lsh (id, s)) φ Lsh : (Functor b) (a b x) ( y. Lsh x a y b y) φ Lsh g = λ(lsh (κ, s)) fmap κ (g s) University of Oxford Ralf Hinze

114 Generic Programming with Adjunctions Type Application Right shifts in Haskell newtype Rsh x b y = Rsh {rsh : (y x) b} instance Functor (Rsh x b) where fmap f (Rsh g) = Rsh (λκ g (κ f )) φ Rsh : (Functor a) (a x b) ( y. a y Rsh x b y) φ Rsh f = λs Rsh (λκ f (fmap κ s)) φ Rsh : ( y. a y Rsh x b y) (a x b) φ Rsh β = λs rsh (β s) id University of Oxford Ralf Hinze

115 Generic Programming with Adjunctions Type Application Specialising adjoint equations x App X in = Ψ x { definition of App X } x in X = Ψ x University of Oxford Ralf Hinze

116 Generic Programming with Adjunctions Type Application The transpose of sump sump : x. Perfect x (x Nat) Nat sump (Zero n) = λκ κ n sump (Succ p) = λκ sump p (plus (κ κ)) University of Oxford Ralf Hinze

117 Generic Programming with Adjunctions Type Application Relation to Generic Haskell sump : x. (x Nat) (Perfect x Nat) sump sumx (Zero n) = sumx n sump sumx (Succ p) = sump (plus (sumx sumx)) p University of Oxford Ralf Hinze

118 Generic Programming with Adjunctions Type Composition Recall: concat concat : a. List (List a) List a concat (Nil) = Nil concat (Cons (l, ls)) = append (l, concat ls) University of Oxford Ralf Hinze

119 Generic Programming with Adjunctions Type Composition Speaking categorically where concat : Pre List (µlist) List Pre J : E D E C Pre J F = F J Pre J α = α J. University of Oxford Ralf Hinze

120 Generic Programming with Adjunctions Type Composition 4.5 φ : F G. E D (Lan J F, G) E C (F, G J) C C E G LanJ F F J D E D Lan J ( J) ( J) EC Ran J ED J D G F Ran J G E φ : F G. E C (F J, G) E D (F, Ran J G) University of Oxford Ralf Hinze

121 Generic Programming with Adjunctions Type Composition 4.5 F J G { natural transformation as an end } A : C. E(F (J A), G A) { Yoneda } A : C. X : D. D(X, J A) E(F X, G A) { definition of power: Ix C(A, B) C(A, Ix. B) } A : C. X : D. E(F X, D(X, J A). G A) { interchange of quantifiers } X : D. A : C. E(F X, D(X, J A). G A) { the functor E(F X, ) preserves ends } X : D. E(F X, A : C. D(X, J A). G A) { define Ran J G = Λ X : D. A : C. D(X, J A). G A } X : D. E(F X, Ran J G X ) { natural transformation as an end } F Ran J G University of Oxford Ralf Hinze

122 Generic Programming with Adjunctions Type Composition Right Kan extensions in Haskell newtype Ran i g x = Ran {ran : a. (x i a) g a} instance Functor (Ran i g) where fmap f (Ran h) = Ran (λκ h (κ f )) φ Ran : (Functor f ) ( x. f (i x) g x) ( x. f x Ran i g x) φ Ran α = λs Ran (λκ α (fmap κ s)) φ Ran : ( x. f x Ran i g x) ( x. f (i x) g x) φ Ran β = λs ran (β s) id University of Oxford Ralf Hinze

123 Generic Programming with Adjunctions Type Composition Left Kan extensions in Haskell data Lan i f x = a. Lan (i a x, f a) instance Functor (Lan i f ) where fmap f (Lan (κ, s)) = Lan (f κ, s) φ Lan : ( x. Lan i f x g x) ( x. f x g (i x)) φ Lan α = λs α (Lan (id, s)) φ Lan : (Functor g) ( x. f x g (i x)) ( x. Lan i f x g x) φ Lan β = λ(lan (κ, s)) fmap κ (β s) University of Oxford Ralf Hinze

124 Generic Programming with Adjunctions Type Composition The transpose of concat concat : a b. µlist a (a List b) List b concat as = λκ concat (fmap κ as) The transpose of concat is the bind of the list monad (written >= in Haskell)! University of Oxford Ralf Hinze

125 Generic Programming with Adjunctions Type Composition 4.5 adjunction initial fixed-point equation final fixed-point equation x L in = Ψ x R out x = Ψ x L R φ x in = (φ Ψ φ ) (φ x) out φ x = (φ Ψ φ) (φ x) Id Id ( X ) ( X ) (+) ( ) standard fold standard fold parametrised fold fold to an exponential recursion from a coproduct of mutually recursive types mutual value recursion on mutually recursive types mutual value recursion single recursion to a product domain Lsh X ( X ) monomorphic fold ( X ) Rsh X fold to a right shift Lan J ( J) polymorphic fold ( J) Ran J fold to a right Kan extension standard unfold standard unfold curried unfold unfold from a pair mutual value recursion single recursion from a coproduct domain recursion to a product of mutually recursive types mutual value recursion on mutually recursive types monomorphic unfold unfold from a left shift polymorphic unfold unfold from a left Kan extension University of Oxford Ralf Hinze

126 Generic Programming with Adjunctions 5.0 Part 5 Application: Type fusion University of Oxford Ralf Hinze

127 Generic Programming with Adjunctions Outline 19. Memoisation 20. Fusion 21. Type fusion 22. Application: firstification 23. Application: type specialisation 24. Application: tabulation University of Oxford Ralf Hinze

128 Generic Programming with Adjunctions Memoisation Memoisation Say, you want to memoise the function f : Nat V so that it caches previously computed values. University of Oxford Ralf Hinze

129 Generic Programming with Adjunctions Memoisation 5.1 Given the interface data Table v lookup : v. Table v (Nat v) tabulate : v. (Nat v) Table v, we can memoize f as follows memo-f : Nat V memo-f = lookup (tabulate f ). University of Oxford Ralf Hinze

130 Generic Programming with Adjunctions Memoisation Implementing Table data Nat = Zero Succ Nat data Table v = Node {zero : v, succ : Table v } lookup (Node {zero = t }) Zero = t lookup (Node {succ = t }) (Succ n) = lookup t n tabulate f = Node {zero = f Zero, succ = tabulate (λn f (Succ n))} University of Oxford Ralf Hinze

131 Generic Programming with Adjunctions Fusion Fusion for adjoint folds Let α : X D. C(L X, B) C (L X, B ), then α Ψ L = Ψ L = α Ψ = Ψ α. NB This subsumes the fusion law for folds. University of Oxford Ralf Hinze

132 Generic Programming with Adjunctions Fusion Proof of fusion α Ψ L L in = { naturality of α: α x L h = α (x L h) } α ( Ψ L L in) = { computation } α (Ψ Ψ L ) = { assumption α Ψ = Ψ α } Ψ (α Ψ L ) University of Oxford Ralf Hinze

133 Generic Programming with Adjunctions Type fusion Type fusion C G G C L R D F F D L (µf) µg = L F G L νf R (νg) = F R R G University of Oxford Ralf Hinze

134 Generic Programming with Adjunctions Type fusion 5.3 τ : L (µf) µg = swap : L F G L University of Oxford Ralf Hinze

135 Generic Programming with Adjunctions Type fusion Definition of τ and τ L (F (µf)) swap swap G (L (µf)) G τ G τ G (µg) L in L in L (µf) τ τ in in µg τ L in = in G τ swap and τ in = L in swap G τ University of Oxford Ralf Hinze

136 Generic Programming with Adjunctions Type fusion Proof of τ τ = id µg (τ τ ) in = { definition of τ } τ L in swap G τ = { definition of τ } in G τ swap swap G τ = { inverses } in G τ G τ = { G functor } in G (τ τ ) The equation x in = in G x has a unique solution. Since id is also a solution, the result follows. University of Oxford Ralf Hinze

137 Generic Programming with Adjunctions Type fusion Proof of τ τ = id L (µf) (τ τ) L in = { definition of τ } τ in G τ swap = { definition of τ } L in swap G τ G τ swap = { G functor } L in swap G (τ τ) swap Again, x L in = L in swap G x swap has a unique solution. And again, id is also solution, which implies the result. University of Oxford Ralf Hinze

138 Generic Programming with Adjunctions Application: firstification Application: firstification data Stack = Empty Push (Nat, Stack) data List a = Nil Cons (a, List a) List Nat Stack University of Oxford Ralf Hinze

139 Generic Programming with Adjunctions Application: firstification Speaking categorically = App Nat (µlist) µstack App Nat LIST Stack App Nat University of Oxford Ralf Hinze

140 Generic Programming with Adjunctions Application: firstification Proof of App Nat LIST Stack App Nat App Nat LIST { composition of functors and definition of App } Λ X. LIST X Nat { definition of LIST } Λ X. 1 + Nat X Nat { definition of Stack } Λ X. Stack (X Nat) { composition of functors and definition of App } Stack App Nat University of Oxford Ralf Hinze

141 Generic Programming with Adjunctions Application: firstification In Haskell swap : x. LIST x Nat Stack (x Nat) swap Nil = Empty swap (Cons (n, x)) = Push (n, x) swap : x. Stack (x Nat) LIST x Nat swap Empty = Nil swap (Push (n, x)) = Cons (n, x) Λ-lift : µstack µlist Nat Λ-lift (In x) = In (swap (fmap Λ-lift x)) Λ-drop : µlist Nat µstack Λ-drop (In x) = In (fmap Λ-drop (swap x)) University of Oxford Ralf Hinze

142 Generic Programming with Adjunctions Application: type specialisation Application: type specialisation Lists of optional values, List Maybe with data Maybe a = Nothing Just a, can be represented more compactly using the tailor-made data Sequ a = Done Skip (Sequ a) Yield (a, Sequ a). University of Oxford Ralf Hinze

143 Generic Programming with Adjunctions Application: type specialisation Speaking categorically List Maybe Sequ, = Pre Maybe (µlist) µsequ Pre Maybe LIST SEQU Pre Maybe University of Oxford Ralf Hinze

144 Generic Programming with Adjunctions Application: type specialisation Proof of Pre Maybe LIST SEQU Pre Maybe LIST X Maybe { composition of functors } Λ A. LIST X (Maybe A) { definition of LIST } Λ A. 1 + Maybe A X (Maybe A) { definition of Maybe } Λ A. 1 + (1 + A) X (Maybe A) { distributes over + and 1 B B } Λ A. 1 + X (Maybe A) + A X (Maybe A) { composition of functors } Λ A. 1 + (X Maybe) A + A (X Maybe) A { definition of SEQU } SEQU (X Maybe) University of Oxford Ralf Hinze

145 Generic Programming with Adjunctions Application: type specialisation In Haskell swap : x. a. LIST x (Maybe a) SEQU (x Maybe) a swap (Nil) = Done swap (Cons (Nothing, x)) = Skip x swap (Cons (Just a, x)) = Yield (a, x) University of Oxford Ralf Hinze

146 Generic Programming with Adjunctions Application: tabulation Recall Nat and Table data Nat = Zero Succ Nat data Table val = Node {zero : val, succ : Table val } V Nat Table V University of Oxford Ralf Hinze

147 Generic Programming with Adjunctions Application: tabulation 5.6 ( ) Nat Table University of Oxford Ralf Hinze

148 Generic Programming with Adjunctions Application: tabulation Truth tables ( ) : Bool Bool Bool False False False True University of Oxford Ralf Hinze

149 Generic Programming with Adjunctions Application: tabulation 5.6 ( ) Bool Bool (Id Id) (Id Id) University of Oxford Ralf Hinze

150 Generic Programming with Adjunctions Application: tabulation Laws of exponentials V 0 1 V 1 V V A+B V A V B V A B (V B ) A University of Oxford Ralf Hinze

151 Generic Programming with Adjunctions Application: tabulation Curried exponentiation Exp : C (C C ) op Exp K = Λ V. V K Exp f = Λ V. (id V ) f University of Oxford Ralf Hinze

152 Generic Programming with Adjunctions Application: tabulation Laws of exponentials Exp 0 K 1 Exp 1 Id Exp (A + B) Exp A Exp B Exp (A B) Exp A Exp B University of Oxford Ralf Hinze

153 Generic Programming with Adjunctions Application: tabulation Exp is a left adjoint (C C ) op G Exp G (CC op ) Sel C F F C University of Oxford Ralf Hinze

154 Generic Programming with Adjunctions Application: tabulation Deriving the right adjoint (C C ) op (Exp A, B) { definition of op } C C (B, Exp A) { natural transformation as an end } X C. C(B X, Exp A X ) { definition of Exp } X C. C(B X, X A ) { Y ( ) Y and Y Z Z Y } X C. C(A, X B X ) { the functor C(A, ) preserves ends } C(A, X C. X B X ) { define Sel B = X C. X B X } C(A, Sel B) University of Oxford Ralf Hinze

155 Generic Programming with Adjunctions Application: tabulation 5.6 (C C ) op G Exp G (CC op ) Sel C F F C Since Exp is a contra-variant functor, τ and swap live in an opposite category. Type fusion in terms of arrows in C C : τ : νg Exp (µf) = swap : G Exp Exp F. University of Oxford Ralf Hinze

156 Generic Programming with Adjunctions Application: tabulation Look-up and tabulate The isomorphism τ : νg Exp (µf) is a curried look-up function that maps a memo table to an exponential. lookup (Out t) (in i) = swap (G lookup t) i The inverse τ : Exp (µf) νg is a transformation that tabulates a given exponential. tabulate f = Out (G tabulate (swap (f in))) University of Oxford Ralf Hinze

157 Generic Programming with Adjunctions Application: tabulation In Haskell The transformation swap implements V V X V 1+X. swap : x. val. TABLE (Exp x) val (Nat x val) swap (Node (v, t)) (Zero) = v swap (Node (v, t)) (Succ n) = t n The inverse of swap implements V 1+X V V X. swap : x. val. (Nat x val) TABLE (Exp x) val swap f = Node (f Zero, f Succ) University of Oxford Ralf Hinze

158 Generic Programming with Adjunctions Application: tabulation In Haskell lookup : val. νtable val (µnat val) lookup (Out (Node (v, t))) (In Zero) = v lookup (Out (Node (v, t))) (In (Succ n)) = lookup t n tabulate : val. (µnat val) νtable val tabulate f = Out (Node (f (In Zero), tabulate (f In Succ))) University of Oxford Ralf Hinze

159 Generic Programming with Adjunctions 6.0 Part 6 Epilogue University of Oxford Ralf Hinze

160 Generic Programming with Adjunctions Summary Adjoint (un-) folds capture many recursion schemes. Adjunctions play a central role. Tabulation is an intriguing example. University of Oxford Ralf Hinze

161 Generic Programming with Adjunctions Limitations Simultaneous recursion doesn t fit under the umbrella. zip : (List a, List b) List (a, b) zip (Nil, bs) = Nil zip (as, Nil) = Nil zip (Cons (a, as), Cons (b, bs)) = Cons ((a, b), zip (as, bs)) However, one can establish x = Ψ x ( ) in = Ψ x using a different technique (colimits). See, R. Bird, R. Paterson: Generalised folds for nested datatypes. University of Oxford Ralf Hinze

162 Generic Programming with Adjunctions 7.0 Part 7 Tagless interpreters University of Oxford Ralf Hinze

163 Generic Programming with Adjunctions Initial algebras: view from the left data Expr 0 = Lit Nat Add (Expr 0, Expr 0 ) e 0 : Expr 0 e 0 = Add (Lit 4700, Lit 11) University of Oxford Ralf Hinze

164 Generic Programming with Adjunctions 7.0 data Expr expr = Lit Nat Add (expr, expr) The evaluation algebra. eval 0 : Expr Nat Nat eval 0 (Lit n) = n eval 0 (Add (n 1, n 2 )) = n 1 + n 2 The fold for expressions. fold 0 : val. (Expr val val) (Expr 0 val) fold 0 alg (Lit n) = alg (Lit n) fold 0 alg (Add (e 1, e 2 )) = alg (Add (fold 0 alg e 1, fold 0 alg e 2 )) University of Oxford Ralf Hinze

165 Generic Programming with Adjunctions 7.0 C(Expr Val, Val) { definition of Expr } C(Nat + (Val Val), Val) { (+) } (C C)( Nat, Val Val, Val) { product categories } C(Nat, Val) C(Val Val, Val) data Alg val = Alg {lit : Nat val, add : (val, val) val } University of Oxford Ralf Hinze

166 Generic Programming with Adjunctions 7.0 data Alg val = Alg {lit : Nat val, add : (val, val) val } The evaluation algebra. eval 0 : Alg Nat eval 0 = Alg {lit = id, add = λ(n 1, n 2 ) n 1 + n 2 } The fold for expressions. fold 0 : val. Alg val (Expr 0 val) fold 0 alg (Lit n) = lit alg n fold 0 alg (Add (e 1, e 2 )) = add alg (fold 0 alg e 1, fold 0 alg e 2 ) University of Oxford Ralf Hinze

167 Generic Programming with Adjunctions Initial algebras: view from the right val. Alg val (Expr 0 val) { A (B C) B (A C) } val. Expr 0 (Alg val val) { a. A T a A a. T a } Expr 0 ( val. Alg val val) University of Oxford Ralf Hinze

168 Generic Programming with Adjunctions using records newtype Expr 1 = Expr {fold 1 : val. Alg val val } e 1 : Expr 1 e 1 = Expr {fold 1 = λalg add alg (lit alg 4700, lit alg 11)} Converting between the left and right view. toright : Expr 0 Expr 1 toright e = Expr {fold 1 = λi fold 0 i e} toleft : Expr 1 Expr 0 toleft e = fold 1 e (Alg {lit = Lit, add = Add }) University of Oxford Ralf Hinze

169 Generic Programming with Adjunctions using classes class Alg val where {lit : Nat val; add : (val, val) val } e 1 : (Alg val) val e 1 = add (lit 4700, lit 11) Converting between the left and right view. toright : (Alg val) Expr 0 val toright e = fold 0 (Alg {lit = lit, add = add }) e instance Alg Expr 0 where {lit = Lit; add = Add } toleft : Expr 0 Expr 0 toleft e = e University of Oxford Ralf Hinze

170 Generic Programming with Adjunctions Parametricity A. (F A A) A (φ, φ) A. (F A A) A { polymorphic type } h. (φ A 1, φ A 2 ) (F h h) h { function type } h. f 1 f 2. (f 1, f 2 ) F h h = (φ A 1 f 1, φ A 2 f 2 ) h { base } h. f 1 f 2. (f 1, f 2 ) F h h = h (φ A 1 f 1 ) = φ A 2 f 2 { function type } h. f 1 f 2. h f 1 = f 2 F h = h (φ A 1 f 1 ) = φ A 2 f 2 University of Oxford Ralf Hinze

171 Generic Programming with Adjunctions An isomorphism toright i = λ a. a i toleft f = f in toleft (toright i) = { definition of toright } toleft (λ a. a i) = { definition of toleft } in i = { reflection } i University of Oxford Ralf Hinze

172 Generic Programming with Adjunctions 7.0 toright i = λ a. a i toleft f = f in toright (toleft f ) = { definition of toleft } toright (f in) = { definition of toright } λ a. a (f in) = { parametricity with a in = a F a } λ a. f a = { extensionality } f University of Oxford Ralf Hinze