Writing a solution to "Data Types a la Carte"'s problem usine Purescript Run

JordanMartinez · 2018-09-22T19:19:49.485Z

I’m re-explaining the “Data Types a la Carte” paper in my learning repo. I’m also trying to teach (and learn by doing so) how to use VariantF and ultimately purescript-run to solve its problem.

Having read xgrommx’s code, which removes ValueF as a data type and reduces it to a smart constructor via pure…

github.com

xgrommx/purescript-from-adt-to-eadt/blob/master/src/ADT8.purs

module ADT8 where

import Prelude

import Control.Monad.Free (Free, resume, wrap)
import Data.Either (Either(..))
import Effect (Effect)
import Effect.Class.Console (log)
import Effect.Console (logShow)

-- TODO: https://github.com/natefaubion/purescript-run

-- Here we don't need `LitF` because we have `pure`

data ExprF a = AddF a a

derive instance functorExprF :: Functor ExprF

type Expr = Free ExprF

This file has been truncated. show original

…I’ve written this code:

gist.github.com

https://gist.github.com/JordanMartinez/a7e3fb0116301ee56bad2eab72176ff1

01-Value.purs

module Free.RunBased.Value (main, value, example_value) where

import Prelude
import Effect (Effect)
import Effect.Console (log)
import Run (Run, extract)

value :: forall r. Int -> Run r Int
value i = pure i

This file has been truncated. show original

02-Add.purs

module Free.RunBased.Add
  (
  -- main
  -- ,
  AddF
  , ADD --, add
  -- , example_add
  , addAlgebra
  ) where

This file has been truncated. show original

Unfortunately, I’m not sure how to evaluate (add (value 1) (value 2)) to 3.

natefaubion · 2018-09-22T23:09:17.941Z

The run combinator let you evaluate your set of functors in terms of some Monad m. There’s no combinator currently equivalent to iter from your linked example. However it can easily be written in terms of Run.resume Left Right and you’d get the same thing. If you wanted to use run you would have to use Identity as your m.

JordanMartinez · 2018-09-23T01:33:59.003Z

Thanks for your help! I’m looking into this now.

JordanMartinez · 2018-09-23T03:43:47.261Z

I’ve been banging my head at this for the past hour, but still haven’t gotten it to work. Sigh…

I realized that Run.resume Left Right is the definition of Run.peel. With this code:

iter :: forall r a. (VariantF r a -> a) -> Run r a -> a
iter k = go
  where
  go m = case peel m of
    Left f -> k (go <$> f)
    Right a -> a

eval :: forall r a b
      . ((VariantF () a -> b) -> VariantF r Int -> Int)
     -> Run r a
     -> Int
eval algebra = iter (case_ # algebra)

-- Examples
main :: Effect Unit
main = do
  _ <- eval addAlgebra example_add
  pure unit

I get a compiler error because eval expects the a type in its Run r a argument to be Int, not a. However, the a type in the add function is another Run (ADD + r) Int. I’m not sure how I’d fix that since the code should work if I wrapped another add in there (e.g. add example_add (value 5)

natefaubion · 2018-09-23T04:47:11.805Z

If you have m (m a) and you want m a, then that’s exactly what Monad gives you through join.

add :: forall r
     . Run (ADD + r) Int
    -> Run (ADD + r) Int
    -> Run (ADD + r) Int
add x y = join $ lift _add (AddF x y)

JordanMartinez · 2018-09-23T04:51:59.569Z

Duh!

I started thinking I would need to define an Eval type class that uses instance chains like Coproduct does to inject a data type into it.

Thank you again!

JordanMartinez · 2018-09-23T05:00:52.807Z

It finally works! Thank you!