Getting acquainted with Lens

"Getting acquainted with Lens"
@EncodePanda
@EncodePanda, paul.szulc@gmail.com 1

This talk is about Lens1
1. What problem they are trying to solve?
2. How we can use them?
3. How they are being implemented?
1
https://hackage.haskell.org/package/lens.

There are two things fundamentally
broken in Haskell
1. Record syntax
2. Strings

Record syntax broken?
"The record system is a continual source of pain"
- Stephen Diehl

"What is your least favorite thing about Haskell?
Records are still tedious"
- 2018 State of Haskell Survey

"Shitty records."
- Someone on reddit

The Example

data Conference = Conference
{ organizer :: Organizer
, speakers :: [Speaker]
} deriving Show

} deriving Show
data Organizer = Organizer
{ name :: Name
, contact :: Contact
} deriving Show

{ name :: Name
} deriving Show

{ name :: Name
} deriving Show
data Name = Name
{ firstName :: String
, lastName :: String
} deriving Show

{ name :: Name
} deriving Show
data Contact = Contact
{ address :: Address
, email :: String
} deriving Show

data Address = Address
{ street :: String
, city :: String
, country :: String
} deriving Show

} deriving Show

} deriving Show
data Speaker = Speaker
{ slidesReady :: Bool
} deriving Show

Getting things from a
record

{ name :: Name
} deriving Show
oli :: Organizer
oli = Organizer
{ name = Name "Oli" "Makhasoeva"
, contact = classified
}

{ name :: Name
} deriving Show
λ> :t name
name :: Organizer -> Name

{ name :: Name
} deriving Show
λ> name oli
Name {firstName = "Oli", lastName = "Makhasoeva"}

import Data.Function ((&))
λ> :t (&)
(&) :: a -> (a -> b) -> b
λ> length [4, 6, 8]
3
λ> [4, 6, 8] & length
3

λ> :t (&)
(&) :: a -> (a -> b) -> b
λ> length [4, 6, 8]
3
λ> [4, 6, 8] & length
3

{ name :: Name
} deriving Show
λ> name oli

{ name :: Name
} deriving Show
λ> oli & name

{ name :: Name
} deriving Show
λ> oli & name & firstName
"Oli"

organizerCountry :: Conference -> String
organizerCountry conf =
conf & organizer
& contact
& address
& country

But

} deriving Show
{ name :: Name
} deriving Show
{ slidesReady :: Bool
} deriving Show

{ name :: String
, organizer :: Organizer
} deriving Show
{ name :: Name
} deriving Show
{ name :: Name
, slidesReady :: Bool
} deriving Show

{ name :: String
} deriving Show
{ name :: Name
} deriving Show
{ name :: Name
} deriving Show

/../src/WhyLens.hs:27:5: error:
Multiple declarations of ‘name’
Declared at: src/WhyLens.hs:12:5
src/WhyLens.hs:27:5
|
27 | { name :: Name
|

We can actually do
something about it

{-# LANGUAGE DuplicateRecordFields #-}

module WhyLens where
{ name :: String
} deriving Show
{ name :: Name
} deriving Show
{ name :: Name
} deriving Show

But

organizerName :: Conference -> Name
organizerName conference =
conference & organizer & name

Ambiguous occurrence ‘name’
It could refer to
either the field ‘name’, defined at src/WhyLens.hs:34:5
or the field ‘name’, defined at src/WhyLens.hs:19:5

{-# LANGUAGE OverloadedLabels #-}

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedLabels #-}

class IsLabel (x :: Symbol) a where
fromLabel :: a
instance IsLabel "encodepanda" Speaker where
fromLabel = Speaker
{ name = Name "Pawel" "Szulc"
, slidesReady = False
}
pawel :: Speaker
pawel = fromLabel @"encodepanda"

fromLabel :: a
fromLabel = Speaker
}
pawel :: Speaker

fromLabel :: a
fromLabel = Speaker
}
pawel :: Speaker
pawel = #encodepanda

It could refer to
either the field ‘name’, defined at src/WhyLens.hs:34:5

{ name :: String
} deriving Show
{ name :: Name
} deriving Show
{ name :: Name
} deriving Show

{ name :: Name
} deriving Show
instance IsLabel "name" (Organizer -> Name) where
fromLabel = name

{ name :: Name
} deriving Show
fromLabel = name

{ name :: Name
} deriving Show
fromLabel = name
conference & organizer & #name

Setting things to a record

λ> haskellLove
Conference
{ name = "Haskell.Love"
, organizer = Organizer {..}
, speakers = []
}

λ> haskellLove
Conference
, speakers = []
}

λ> haskellLove { speakers = [ pawel, marcin ] }
Conference
, speakers = [ Speaker { name = Name { firstName = "Pawel"
, lastName = "Szulc"}
}
, Speaker { name = Name { firstName = "Marcin"
, lastName = "Rzeznicki"}
, slidesReady = False}
]
}

λ> haskellLove { speakers = [ pawel, marcin ] }
Conference
}
]
}

But

allSpeakersNotReady :: Conference -> Conference
allSpeakersNotReady conference =
let
oldSpeakers = conference & speakers
in
conference {
speakers =
fmap (s -> s { slidesReady = False}) oldSpeakers
}

let
in
conference {
speakers =
}

changeOrganizerEmail :: (String -> String) -> Conference -> Conference
changeOrganizerEmail modifyEmail conference =
let
oldOrganizer = conference & organizer
newContact = (oldOrganizer & contact)
{ email = modifyEmail (oldOrganizer & contact & email)
}
newOrganizer = oldOrganizer { contact = newContact}
in
conference { organizer = newOrganizer }

let
}
in

What can you do about it
1. Change the programming language
2. Quit
3. Ask the Oracle

Lens1
1
https://hackage.haskell.org/package/lens.

Lens' s a

_organizer :: Lens' Conference Organizer

λ> view _organizer haskellLove
Organizer
{ name = Name { firstName = "Oli"
, lastName = "Makhasoeva"}
, contact = Contact {..}
}

λ> haskellLove ^. _organizer
Organizer
{ name = Name { firstName = "Oli"
, lastName = "Makhasoeva"}
, contact = Contact {..}
}

_contact :: Lens' Organizer Contact
_address :: Lens' Contact Address
_country :: Lens' Address String
λ> haskelllove ^. _organizer . _contact . _address . _country
"classified"

"classified"

dot?

(.) :: (b -> c) -> (a -> b) -> a -> c
How is that possible?

"classified"

_name :: Lens' Conference String
λ> set _name "Haskell Love 2020" haskellLove
Conference
{ name = "Haskell Love 2020"
, speakers = [..]
}

λ> (_name .~ "Haskell Love 2020") haskellLove
Conference
, speakers = [..]
}

λ> haskellLove & _name .~ "Haskell Love 2020"
Conference
, speakers = [..]
}

λ> haskellLove & _organizer . _contact . _address . _country .~ "Poland"
Conference
, organizer =
Organizer { name = Name {firstName = "Oli", lastName = "Makhasoeva"}
, contact = Contact { address = Address { street = "Class"
, city = "ified"
, country = "Poland"
}
, email = "oli@haskell.love"}
}
, speakers = [...]
}

Conference
, organizer =
, city = "ified"
}
}
, speakers = [...]
}

& _name .~ "Haskell Love 2021"
Conference
, organizer =
, city = "ified"
}
}
, speakers = [...]}

Conference
, organizer =
, city = "ified"
}
}
, speakers = [...]}

λ> :t lens
lens :: (s -> a) -> (s -> a -> s) -> Lens' s a

_organizer = lens getter setter
where
getter = organizer
setter c o = c { organizer = o}

But

_name = lens getter setter
where
getter = name
setter c n = c { name = n }
/../src/TheLens.hs:23:14: error:
It could refer to
either the field ‘name’,
imported from ‘Example’ at src/TheLens.hs:6:1-24
or the field ‘name’,

where
getter = name
setter c n = c { name = n }
It could refer to
either the field ‘name’,

where
getter (Conference n _ _) = n
setter (Conference _ o s) n = Conference n o s

_organizer = lens getter setter
where
getter = organizer
setter c o = c { organizer = o}
where
getter (Conference n _ _) = n
setter (Conference _ o s) n = Conference n o s
_contact = lens contact (o -> c -> o { contact = c})
_address = lens address (c -> a -> c { address = a})
_country = lens country (a -> c -> a { country = c})

Approach #1 -
TemplateHaskell

{-# LANGUAGE TemplateHaskell #-}
module TheLens where
data Ticket = Ticket
{ _event :: String
, _price :: Int
} deriving Show
makeLenses ''Ticket
λ> ticket = Ticket "Haskell Love" 0
λ> ticket ^. price
0
λ> ticket & event .~ "Haskell Love 2020"
Ticket {_event = "Haskell Love 2020", _price = 0}

{ _event :: String
, _price :: Int
} deriving Show
makeLenses ''Ticket
λ> ticket ^. price
0

But

{ _event :: String
, _price :: Int
} deriving Show
makeLenses ''Ticket
data Item = Item
{ _id :: Int
, _price :: Int
}
makeLenses ''Item
Multiple declarations of ‘price’
Declared at: src/TheLens.hs:33:1
src/TheLens.hs:39:1
|
39 | makeLenses ''Item
| ^^^^^^^^^^^^^^^^^

{ _event :: String
, _price :: Int
} deriving Show
makeLenses ''Ticket
data Item = Item
{ _id :: Int
, _price :: Int
}
makeLenses ''Item
src/TheLens.hs:39:1
|
| ^^^^^^^^^^^^^^^^^

Approach #2 -
GHC.Generics

generic-lens 2
2
https://hackage.haskell.org/package/generic-lens.

{ name :: String
} deriving Show
{ name :: Name
} deriving Show
...

{ name :: String
} deriving (Generic, Show)
{ name :: Name
...

λ> haskellLove ^. field @"organizer" . field @"contact" . field @"email"
"oli@haskell.love"

λ> haskellLove ^. #organizer . #contact . #email
"oli@haskell.love"

{ name :: String
{ name :: Name
...

λ> haskellLove ^. #name
"Haskell.Love"
λ> haskellLove ^. #organizer . #name

Lens' s a

Lens s t a b

"Shitty records."
- Someone on reddit

Lens s t a b

Lens s t a b
λ> :t lens
lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
type Lens' s a = Lens s s a a

first :: Lens' (a, b) a
first = lens getter setter
where
getter (a, _) = a
setter (_, b) a = (a, b)
λ> (10, 20) ^. first
10
λ> (10, 20) & first .~ 30
(30,20)
λ> (10, 20) & first .~ "hello"
<interactive>:25:2: error:
• Could not deduce (Num [Char]) arising from the literal ‘10’
from the context: Num b

where
getter (a, _) = a
λ> (10, 20) ^. first
10
λ> (10, 20) & first .~ 30
(30,20)
λ> (10, 20) & first .~ "hello"

first :: Lens (a, c) (b, c) a b
where
getter (a, _) = a
setter (_, b) c = (c, b)
λ> (10, 20) ^. first
10
λ> (10, 20) & first .~ 30
(30,20)
λ> (10, 20) & first .~ "hello"
("hello",20)

data Truck a = Truck
{ name :: String
, cargo :: a
} deriving (Show, Generic)
data Fruit = Apple | Orange deriving Show
data Electronic = Computer | Phone deriving Show
λ> truck = Truck "Tom" Apple
truck :: Truck Fruit
λ> otherTruck = truck & #cargo .~ Phone
otherTruck :: Truck Electronic

{ name :: String
, cargo :: a

λ> truck = Truck "tom" [Apple, Orange, Apple]
λ> truck & #cargo .~ (truck ^. #cargo <> [Orange, Apple])
Truck { name = "tom"
, cargo = [Apple,Orange,Apple,Orange,Apple]}
λ> truck & #cargo %~ (fruits -> fruits <> [Orange, Apple])
λ> truck & #cargo <>~ [Orange, Apple]

λ> truck & #cargo %~ length
& #cargo +~ 1
Truck {name = "tom", cargo = 4}
λ> truck & #cargo %~ length
& #cargo *~ 10
Truck {name = "tom", cargo = 30}

Other Optics

Traversal s t a b

λ> haskellLove ^. #speakers
[ Speaker { name = Name {firstName = "Pawel", lastName = "Szulc"}
, Speaker { name = Name {firstName = "Marcin", lastName = "Rzeznicki"}
, slidesReady = True}
]
λ> haskellLove ^.. #speakers . traversed . #name . #lastName
["Szulc","Rzeznicki"]
λ> haskellLove ^. #speakers . traversed . #name . #lastName
"SzulcRzeznicki"

]
"SzulcRzeznicki"

Anyone ready?
anyOf :: Traversal s t a b -> (a -> Bool) -> s -> Bool
λ> anyOf (#speakers . traversed . #slidesReady) id haskellLove
True

λ> haskellLove & #speakers %~ (fmap (set #slidesReady False))
Conference
]
}

λ> haskellLove & #speakers . traversed . #slidesReady .~ False
Conference
]
}

Reveal the magic

Exhibit A: Lens s t a b
1. How to encode getter and setter in one type?
2. How to compose via "dot"?

data Lenz s t a b = Lenz
{ view :: s -> a
, set :: s -> b -> t
}
over :: Lenz s t a b -> (a -> b) -> s -> t
over lenz func s =
let
old = view lenz s
new = func old
in
set lenz s new
type Lenz' s a = Lenz s s a a

{ view :: s -> a
, set :: s -> b -> t
}
over lenz func s =
let
old = view lenz s
new = func old
in
set lenz s new

But that "dot" though...

{ view :: s -> a
, set :: s -> b -> t
}

{ lenz :: s -> (a, b -> t)
}

type Lenz s t a b = s -> (a, b -> t)

type Lenz s t a b = s -> (a, b -> t)
But this will not compose with itself.

type Lens s t a b =
forall f. Functor f =>
(a -> f b) -> s -> f t