Purescript Union of Rows

Question

I've been trying to develop a component system in Purescript, using a Component typeclass which specifies an eval function. The eval function for can be recursively called by a component for each sub-component of the component, in essence fetching the input's values.

As components may wish to use run-time values, a record is also passed into eval. My goal is for the rows in the Record argument of the top-level eval to be required to include all the rows of every sub-component. This is not too difficult for components which do not use any rows themselves, but their single sub-component does, as we can simply pass along the sub-components rows to the component's. This is shown in evalIncrement.

import Prelude ((+), one)
import Data.Symbol (class IsSymbol, SProxy(..))
import Record (get)
import Prim.Row (class Cons, class Union)

class Component a b c | a -> b where
  eval :: a -> Record c -> b

data Const a = Const a

instance evalConst :: Component (Const a) a r where
  eval (Const v) r = v

data Var (a::Symbol) (b::Type) = Var

instance evalVar :: 
  ( IsSymbol a
  , Cons a b r' r) => Component (Var a b) b r  where
  eval _ r = get (SProxy :: SProxy a) r

data Inc a = Inc a

instance evalInc :: 
  ( Component a Int r
  ) => Component (Inc a) Int r where
  eval (Inc a) r = (eval a r) + one

All of the above code works correctly. However, once I try to introduce a component which takes multiple input components and merges their rows, I cannot seem to get it to work. For example, when trying to use the class Union from Prim.Row:

data Add a b = Add a b

instance evalAdd :: 
  ( Component a Int r1
  , Component b Int r2
  , Union r1 r2 r3
  ) => Component (Add a b) Int r3 where
  eval (Add a b) r = (eval a r) + (eval b r)

The following error is produced:

  No type class instance was found for

    Processor.Component a3 
                        Int 
                        r35


while applying a function eval
  of type Component t0 t1 t2 => t0 -> { | t2 } -> t1
  to argument a
while inferring the type of eval a
in value declaration evalAdd

where a3 is a rigid type variable
      r35 is a rigid type variable
      t0 is an unknown type
      t1 is an unknown type
      t2 is an unknown type

In fact, even modifying the evalInc instance to use a dummy Union with an empty row produces a similar error, like so:

instance evalInc :: (Component a Int r, Union r () r1) 
                       => Component (Increment a) Int r1 where

Am I using Union incorrectly? Or do I need further functional dependencies for my class - I do not understand them very well.

I am using purs version 0.12.0

In the definition of evalAdd.eval, you have r :: Record r3, but the call eval a r would require that r :: Record r1, and similarly, the call eval b r would require that r :: Record r2. So you would get a type mismatch if it was a plain function, but since eval is overloaded, the compiler just says that there is no overload for a + r3 or for b + r3. — Fyodor Soikin
@FyodorSoikin Do I have to construct a new record with only the rows the component requires, for each use of eval on components within evalAdd.eval? Can I not make use of open rows some how so that as long as the r1 is a subset of r3, then passing r3 will work? — Joseph Young
@JosephYoung is it really necessary to use a row to store your values? You can use a Map whose keys are Strings representing Symbols (akin to reflectSymbol) and whose values have type Value. Value could have a different constructor for each kind of type you're going to store. I understand you'll lose polymorphism but you'll save on the type-level gymnastics... Alternatively you can see if the purescript-variant package meets your needs. — Kartik Sabharwal
@KartikSabharwal I've actually solved my problem using the original approach, but haven't had time to form a proper answer. I haven't worked on the project for a while but from what I remember, instead of using a union for the components of two inputs, I simply just used the same variable for each. So in essence replacing r1 r2 r3 with r and removing the union constraint. This achieved the effect of requiring the component to need all the variables its inputs require at compile time at the type level — Joseph Young
@JosephYoung thanks for sharing your solution! It would be great if you could post it as an answer eventually since this situation is a neat exercise in the use of type classes. — Kartik Sabharwal

erisco erisco · Accepted Answer · 2019-04-05T00:31:15

r ∷ r3 but it is being used where an r1 and r2 are required, so there is a type mismatch. A record {a ∷ A, b ∷ B} cannot be given where {a ∷ A} or {b ∷ B} or {} is expected. However, one can say this:

f ∷ ∀ s r. Row.Cons "a" A s r ⇒ Record r → A
f {a} = a

In words, f is a function polymorphic on any record containing a label "a" with type A. Similarly, you could change eval to:

eval ∷ ∀ s r. Row.Union c s r ⇒ a → Record r → b

In words, eval is polymorphic on any record which contains at least the fields of c. This introduces a type ambiguity which you will have to resolve with a proxy.

eval ∷ ∀ proxy s r. Row.Union c s r ⇒ proxy c → a → Record r → b

The eval instance of Add becomes:

instance evalAdd ∷
  ( Component a Int r1
  , Component b Int r2
  , Union r1 s1 r3
  , Union r2 s2 r3
  ) => Component (Add a b) Int r3 where
  eval _ (Add a b) r = eval (RProxy ∷ RProxy r1) a r + eval (RProxy ∷ RProxy r2) b r

From here, r1 and r2 become ambiguous because they're not determined from r3 alone. With the given constraints, s1 and s2 would also have to be known. Possibly there is a functional dependency you could add. I am not sure what is appropriate because I am not sure what the objectives are of the program you are designing.

Purescript Union of Rows

2 Answers