Profunctor Optics: Modular Data Accessors

Transcription

1 Profunctor Optics: Modular Data Accessors Jeremy Gibbons (joint work with Matthew Pickering and Nicolas Wu) Spring Festival Workshop, Karuizawa, March 2017

2 Profunctor Optics 2 1. Overview lenses for access within product types dually, prisms for access with sum types collectively optics also adapters for conversion, traversals for iteration not closed under heterogeneous composition not convenient even for homogeneous composition alternative representation in terms of profunctors much better compositionality!

3 Profunctor Optics 3 2. Optics Polymorphic lenses, for access into product types: data Lens a b s t = Lens {view :: s a, update :: b s t } For example: pi 1 :: Lens a b (a c) (b c) pi 1 = Lens viewfst updatefst where viewfst (x, y) = x updatefst (x, (x, y)) = (x, y) S T view update A B

4 Profunctor Optics 4 Monomorphic lenses The representation allows the view type to change, but does not require it. For example, sign :: Lens Bool Bool Integer Integer sign = Lens view update where view x = (x 0) update (b, x) = if b then abs x else (abs x)

5 Profunctor Optics 5 Prisms Dually, for access into sum types: data Prism a b s t = Prism {match :: s t + a, build :: b t } For example, the :: Prism a b (Maybe a) (Maybe b) the = Prism down up where down (Just x) = Right x down Nothing = Left Nothing up x = Just x S T match build A B

6 Profunctor Optics 6 Adapters Lenses and prisms are divergent specialisations of a common ancestor, which converts data between two equivalent formats: data Adapter a b s t = Adapter {from :: s a, For example, to :: b t } flatten :: Adapter (a b c) (a b c ) ((a b) c) ((a b ) c ) flatten = Adapter from to where from ((x, y), z) = (x, y, z) to (x, y, z) = ((x, y), z) S T from to A B

7 Profunctor Optics 7 Traversals data Trav a b t = Trav {untrav :: f. Applicative f (a f b) f t } data Traversal a b s t = Traversal {traverse :: s Trav a b t } For example, data Tree a = Leaf Node (Tree a) a (Tree a) inorder :: Traversal a b (Tree a) (Tree b) inorder = Traversal (λt Trav (go t)) where go Leaf h = pure Leaf go (Node t x u) h = pure Node go t h h x go u h cf the Traversable type class, for container types, with method: traverse :: (Traversable t, Applicative f ) (a f b) t a f (t b) S T traverse A n B n

8 Profunctor Optics 8 Homogeneous composite data Consider access to the A in a nested pair (A B) C: pi 11 :: Lens a a ((a b) c) ((a b) c) pi 11 = Lens view update where Lens v u = pi 1 view = v v update (x, xyz) = u (xy, xyz) where xy = v xyz xy = u (x, xy) Clumsy for update, better to resort instead to first principles: update (x, ((x, y), z)) = ((x, y), z) rather than reusing pi 1. The abstraction is inconvenient.

9 Profunctor Optics 9 Heterogeneous composite data Worse, consider access to the A in a composite data structure Maybe (A B) built using both sums and products. It s not a lens, because there is no view :: Maybe (A B) A. And it s not a prism, because there is no build :: A Maybe (A B). The universe of data accessors is not closed under composition.

10 Profunctor Optics Profunctors A generalisation of functions: transformers that consume and produce. A B Captured as a two-parameter type constructor, contravariant the input: class Profunctor p where dimap :: (a a) (b b ) p a b p a b such that dimap id id = id dimap (f f ) (g g ) = dimap f g dimap f g

11 Profunctor Optics 11 Lifting functors Ordinary functions are an instance: instance Profunctor ( ) where dimap f g h = g h f So are functions returning structured results: data UpStar f a b = UpStar {unupstar :: a f b} instance Functor f Profunctor (UpStar f ) where dimap f g (UpStar h) = UpStar (fmap g h f ) (Also functions taking structured arguments; but we don t need this.)

12 Profunctor Optics 12 Cartesian profunctors Subclass class Profunctor p Cartesian p where first :: p a b p (a c) (b c) of profunctors that can act in a product context, satisfying dimap runit runit 1 = first :: P a b P (a 1) (b 1) dimap assoc assoc 1 first first = first :: P a b P (a (c d)) (b (c d)) where runit and assoc witness the monoidal structure of products. For example, the function arrow is cartesian: instance Cartesian ( ) where first h (x, y) = (h x, y)

13 Profunctor Optics 13 Cocartesian profunctors Dually, subclass class Profunctor p Cocartesian p where right :: p a b p (c + a) (c + b) of profunctors that can act in a sum context, satisfying dimap lzero lzero 1 = right :: P a b P (0 + a) (0 + b) dimap coassoc coassoc 1 right right = right :: P a b P ((c + d) + a) ((c + d) + b) where lzero and coassoc witness the monoidal structure of sums. For example, the function arrow is cocartesian: instance Cocartesian ( ) where right h (Left x) = Left x right h (Right y) = Right (h y)

14 Profunctor Optics 14 Monoidal profunctors A third subclass class Profunctor p Parallel p where par :: p a b p c d p (a c) (b d) empty :: p 1 1 of profunctors that can act in parallel. Functions are an instance: instance Parallel ( ) where par f g (x, y) = (f x, g y) empty () = () Not entirely sure what laws we want here; perhaps empty is the unit of par, and coherence with the monoidal structure of products. (Don t seem to need any additional laws for the proofs.)

15 Profunctor Optics Profunctor optics Data accessors represented as mappings between transformers: type Optic p a b s t = p a b p s t lifting a transformer P A B on elements to a transformer P S T on whole data structures. Lenses, prisms, etc arise by imposing constraints on P, starting with it being a Profunctor. Crucially, all optics are now of the same form, and moreover, are functions: so they compose nicely.

16 Profunctor Optics 16 Profunctor adapters data Adapter a b s t = Adapter {from :: s a, to :: b t } type AdapterP a b s t = p. Profunctor p Optic p a b s t with translations adapterc2p :: Adapter a b s t AdapterP a b s t adapterc2p (Adapter o i) = dimap o i adapterp2c :: AdapterP a b s t Adapter a b s t adapterp2c l = l (Adapter id id) For the latter, we need that concrete adapters form a profunctor: instance Profunctor (Adapter a b) where dimap f g (Adapter o i) = Adapter (o f ) (g i)

17 Profunctor Optics 17 Profunctor lenses data Lens a b s t = Lens {view :: s a, update :: b s t } type LensP a b s t = p. Cartesian p Optic p a b s t with translations lensc2p :: Lens a b s t LensP a b s t lensc2p (Lens v u) = dimap (v id) u first lensp2c :: LensP a b s t Lens a b s t lensp2c l = l (Lens id fst) For the latter, we need that concrete lenses form a cartesian profunctor: instance Profunctor (Lens a b) where dimap f g (Lens v u) = Lens (v f ) (g u (id f )) instance Cartesian (Lens a b) where first (Lens v u) = Lens (v fst) ((u (id fst)) (snd snd))

18 Profunctor Optics 18 Profunctor prisms data Prism a b s t = Prism {match :: s t + a, build :: b t } type PrismP a b s t = p. Cocartesian p Optic p a b s t with translations prismc2p :: Prism a b s t PrismP a b s t prismc2p (Prism m b) = dimap m (id b) right prismp2c :: PrismP a b s t Prism a b s t prismp2c l = l (Prism Right id) For the latter, we need that concrete prisms form a cocartesian profunctor: instance Profunctor (Prism a b) where dimap f g (Prism m b) = Prism ((g + id) m f ) (g b) instance Cocartesian (Prism a b) where right (Prism m b) = Prism ((Left Left) ((Right + id) m)) (Right b)

19 Profunctor Optics 19 Profunctor traversals data Traversal a b s t = Traversal {trav :: s Trav a b t } type TraversalP a b s t = p. (Cartesian p, Cocartesian p, Parallel p) with translations Optic p a b s t traversalc2p :: Traversal a b s t TraversalP a b s t traversalc2p (Traversal h) k = dimap h fuse (traverse k) where fuse :: Trav b b t t traverse :: (Choice p, Parallel p) p a b p (Trav a c t) (Trav b c t) traversalp2c :: TraversalP a b s t Traversal a b s t traversalp2c l = l (Traversal (λx Trav (λf f x))) For the latter, we need that concrete traversals form a cartesian, cocartesian, parallel profunctor...

20 Profunctor Optics Composing profunctor optics Recall pi 1 :: Lens a b (a c) (b c) Make a profunctor version: pip 1 :: LensP a b (a c) (b c) pip 1 = lensc2p pi 1 so in fact pip 1 :: Cartesian p p a b p (a c) (b c) pip 1 = dimap (fork viewfst id) updatefst first (not complicated, but also not obvious). Similarly, thep :: PrismP a b (Maybe a) (Maybe b) thep = prismc2p the

21 Profunctor Optics 21 The payoff Now they compose very sweetly: pip 1 pip 1 :: LensP a b ((a c) d) ((b c) d) thep pip 1 :: (Cartesian p, Cocartesian p) Optic p a b (Maybe (a c)) (Maybe (b c)) In the heterogeneous case, the constraints simply conjoin; the result is neither a lens nor a prism. Similarly for traversals. With inorderp :: TraversalP a b (Tree a) (Tree b) inorderp = traversalc2p inorder we have for example inorderp pip 1 :: TraversalP a b (Tree (a c)) (Tree (b c))

22 Profunctor Optics Conclusion Based on many libraries, blog posts, IRC comments, etc, by Edward Kmett, Elliott Hird, Shachaf Ben-Kiki, Russell O Connor, and others. This work is primarily Matthew Pickering s undergraduate thesis. Paper to appear at the Programming conference: 2017.programming-conference.org and available (soon!) from my webpage: