Fixing Records in Haskell Neil Mitchell et al, ndmitchell.com an - - PowerPoint PPT Presentation

▶
fixing records in haskell
SMART_READER_LITE
LIVE PREVIEW

Fixing Records in Haskell Neil Mitchell et al, ndmitchell.com an - - PowerPoint PPT Presentation

Jun 29, 2023 399 likes •811 views

Fixing Records in Haskell Neil Mitchell et al, ndmitchell.com an in-your-face, glaring weakness telling you there is something wrong with Haskell - Greg Weber What is your least favorite thing about Haskell? Records are still tedious - 2018

slide-1
SLIDE 1

Fixing Records in Haskell

Neil Mitchell et al, ndmitchell.com

slide-2
SLIDE 2

an in-your-face, glaring weakness telling you there is something wrong with Haskell

  • Greg Weber

Haskell’s record system is a cruel joke - Scrive Records' syntax sucks

  • Bitcheese

What is your least favorite thing about Haskell? Records are still tedious - 2018 State of Haskell Survey The record system is a continual source of pain

  • Stephen Diehl
slide-3
SLIDE 3

myPerson.name

Which language is this?

slide-4
SLIDE 4

It can be Haskell!

  • Using record-dot-preprocessor

– github.com/ndmitchell/record-dot-preprocessor – Available as a textual preprocessor and plugin

  • Using DAML – a Haskell derivative

– daml.com

  • If the latest GHC proposal gets accepted and

implemented

– tinyurl.com/ghc-records

slide-5
SLIDE 5

Forbidden Questions (until later)

L**s

slide-6
SLIDE 6

What I want to do

data Company = Company { name :: String,

  • wner :: Person}

data Person = Person { name :: String, age :: Int} ERROR: Multiple declarations of ‘name’

slide-7
SLIDE 7

Automatic selectors

  • Haskell helpfully generates

name :: Company -> String

  • wner :: Company -> Person

name :: Person -> String age :: Person -> Int ERROR: Multiple declarations of ‘name’

slide-8
SLIDE 8

What I actually do #1

data Company = Company { companyName :: String, companyOwner :: Person} data Person = Person { personName :: String, personAge :: Int} personName (companyOwner x)

slide-9
SLIDE 9

What I actually do #2

import qualified Company(Company(..)) as C import qualified Person(Person(..)) as P P.name (C.owner x)

slide-10
SLIDE 10

What I actually do #3

Especially when explaining this to Haskell beginners… Especially experienced programmers…

slide-11
SLIDE 11

With RecordDotSyntax

data Company = Company { name :: String,

  • wner :: Person}

data Person = Person { name :: String, age :: Int} x.owner.name

slide-12
SLIDE 12

This change is a BIG deal

  • DAML is a Haskell inspired DSL for smart

contracts on a Distributed Ledger

– Written by Digital Asset, a company that is hiring, that I used to work for: digitalasset.com

  • Wanted to move from Haskell inspired to GHC

based implementation

  • Records stopped us, until we implemented

this extension (in use ~18 months)

slide-13
SLIDE 13

How does it work?

  • Step 1: Don’t generate the selectors

– Already part of the NoFieldSelectors proposal – But now how do I get at the fields? – Record puns to the rescue

case x of Company{owner} -> case owner of Person{name} -> name

slide-14
SLIDE 14

Sugar that up #1

a.B.c => case a of B{c} -> c x.Company.owner.Person.name

  • Ugly! Company should be inferred from the

type of ‘a’.

slide-15
SLIDE 15

Sugar that up #2

x.owner.name a.b => getField a b getField :: r -> String -> F r String "b" :: String -- a value of type String @"b" :: Label -- a type of kind Label

Type vs Value

slide-16
SLIDE 16

Implement that sugar

class HasField x r a | x r -> a where getField :: r -> a instance HasField "name" Person String where getField Person{name} = name x.owner.name getField @"name" (getField @"owner" x)

slide-17
SLIDE 17

Appreciate the Magic

  • NoFieldSelectors
  • HasField type class
  • Automatic instances
  • Minor syntax sugar

= records solved

slide-18
SLIDE 18

Pairs of labels

instance (HasField l1 a b, HasField l2 b c) => HasField (l1, l2) a c where getField = getField @l2 . getField @l1

  • Since type is either a Label (lifted String) or

pair (lifted pair) getField @("owner", "name") x

slide-19
SLIDE 19

Standalone selectors

  • Old world

map name people

  • New world

map (getField @"name") people map (.name) people

slide-20
SLIDE 20

Record Updates

slide-21
SLIDE 21

Step 1: Make them work

a{b=c} => setField @"b" a c class HasField x r a | x r -> a where setField :: r -> a -> r

slide-22
SLIDE 22

Step 2: Multiple field updates

  • a{b=c, d=e}

setField @"d" (setField @"b" a c) e

Real updates are more powerful. Where did I cheat?

slide-23
SLIDE 23

Type changing updates!

data Foo a = Foo {foo :: [a], bar :: Int} (x :: Foo Int){foo = [True]} :: Foo Bool setField :: Label -> r -> v -> F Label r v

slide-24
SLIDE 24

Type inference issues

x{foo = [], bar = 2} setField @"bar" (setField @"foo" x []) 2

:: Foo ???

There are complex solutions, but…

slide-25
SLIDE 25

Powerful idea Complex and rarely used feature

slide-26
SLIDE 26

Easily emulated

let Foo{..} = x in Foo{foo=[], bar=2, …}

slide-27
SLIDE 27

Deep updates still suck

  • Set the age of the owner to 42

x{owner = x.owner{age=42}} Repeated owner twice. Gets much worse as we nest further.

slide-28
SLIDE 28

Deep updates fixed

  • Set the age of the owner to 42

x{owner.age = 42} setField @("owner","age") x 42

slide-29
SLIDE 29

Field modification still sucks

  • Increment the age of the owner

x{owner.age = x.owner.age + 1} Not terrible, but not beautiful.

slide-30
SLIDE 30

Field modification fixed

  • Increment the age of the owner

x{owner.age + 1} modifyField @("owner","age") x (+ (1))

slide-31
SLIDE 31

Field modification with lambda

  • Do something weird

x{owner.age & \i -> floor $ sqrt (i * 57) + 21} modifyField @("owner","age") x (& (\i -> …)) Data.Function.(&) = flip ($)

slide-32
SLIDE 32

Is modifyField expensive?

  • - Traversing the structure twice is bad (maybe?)

modifyField @l x f = setField @l x $ f $ getField @l x instance HasField x r a | x r -> a where hasField :: r -> (a, a -> r) modifyField @l x f = u $ f v where (v, u) = hasField @l x

L**s

slide-33
SLIDE 33

HasField FAQ

  • Can I define my own HasField instance, e.g. to

pretend my structure has a virtual field

– Yes, you can. Let’s not do one for Map though, please…

  • Can I access non-exported fields now?

– No. HasField is magic. GHC manufactures it locally

  • nly if the field/constructor are in scope.
slide-34
SLIDE 34

Hmm, DuplicateRecordFields?

  • An extension in GHC that let’s you write:

name (owner c :: Person)

  • name’s arg must be a locally known type:

– f c = name (owner (c :: Company)) -- bad – f c = name (owner c :: Person) -- good – f (p :: Person) = name p -- bad

  • We use real constraints for better power
slide-35
SLIDE 35

Did you just reinvent lenses?

  • There’s definitely overlap!
  • Lenses are record fields as first-class values,

which is awesome. Powerful. Scary. These records are concrete.

  • It does conflict with the lens

c^.companyOwner.personName style.

Lens

slide-36
SLIDE 36

Remember the original motivation

For the domain

  • f DAML, lens is

not a feasible solution.

DAML
slide-37
SLIDE 37

Syntactic extensions

Expression Equivalent e.lbl getField @"lbl" e e{lbl = val} setField @"lbl" e val (.lbl) (\x -> x.lbl)| e{lbl1.lbl2 = val} e{lbl1 = (e.lbl1){lbl2 = val}} e{lbl * val} e{lbl = e.lbl * val} e{lbl1.lbl2} e{lbl1.lbl2 = lbl2}

slide-38
SLIDE 38

Combinations

Expression Equivalent e.lbl1.lbl2 (e.lbl1).lbl2 (.lbl1.lbl2) (\x -> x.lbl1.lbl2) e.lbl1{lbl2 = val} (e.lbl1){lbl2 = val} e{lbl1 = val}.lbl2 (e{lbl1 = val}).lbl2 e{lbl1.lbl2 * val} e{lbl1.lbl2 = e.lbl1.lbl2 * val} e{lbl1 = val1, lbl2 = val2} (e{lbl1 = val1}){lbl2 = val2} e{lbl1.lbl2, ..} e{lbl2=lbl1.lbl2, ..}

slide-39
SLIDE 39

myPerson.name

Coming to a GHC near you! (Maybe)

Acknowledgements: DAML Team, incl Shayne Fletcher. Adam Gundry. Mathieu Boespflug. Simon Hafner.