我一直在尝试在Purescript中开发一个组件系统,使用指定eval函数的组件类型类。的eval函数可以由组件的每个子组件递归调用,本质上是获取输入的值。
由于组件可能希望使用运行时值,因此还将记录传递到eval中。我的目标是要求顶级eval的Record参数中的行包括每个子组件的所有行。这对于本身不使用任何行的组件来说并不太困难,但它们的单个子组件确实使用了行,因为我们可以简单地将子组件行传递给组件。如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
以上所有代码都能正常工作。然而,一旦我尝试引入一个接受多个输入组件并合并它们的行的组件,我似乎就无法让它发挥作用。例如,当尝试使用Prim.Row
:中的class Union
时
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)
产生以下错误:
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
事实上,即使修改evalInc
实例以使用空行的伪并集也会产生类似的错误,如下所示:
instance evalInc :: (Component a Int r, Union r () r1)
=> Component (Increment a) Int r1 where
我是否错误地使用了Union?或者我的类需要更多的函数依赖项吗?我对它们的理解不是很好。
我使用的是purs版本0.12.0
r ∷ r3
,但它被用于需要r1
和r2
的地方,因此存在类型不匹配。不能在期望{a ∷ A}
、{b ∷ B}
或{}
的地方给出记录{a ∷ A, b ∷ B}
。然而,可以这样说:
f ∷ ∀ s r. Row.Cons "a" A s r ⇒ Record r → A
f {a} = a
换句话说,f
是包含类型为A
的标签"a"
的任何记录上的多态函数。类似地,您可以将eval更改为:
eval ∷ ∀ s r. Row.Union c s r ⇒ a → Record r → b
换句话说,eval
在任何至少包含c
字段的记录上都是多态的。这引入了一种类型歧义,您必须使用代理来解决这种歧义。
eval ∷ ∀ proxy s r. Row.Union c s r ⇒ proxy c → a → Record r → b
Add的eval实例变为:
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
从这里开始,r1
和r2
变得模糊,因为它们不是单独由r3
确定的。在给定的约束条件下,s1
和s2
也必须是已知的。可能存在可以添加的功能依赖项。我不确定什么是合适的,因为我不确定你正在设计的程序的目标是什么。
由于Row的使用,Var的实例已经是多态的(或者在技术上是开放的?(。缺点((
eval (Var :: Var "a" Int) :: forall r. { "a" :: Int | r } -> Int
然后,我们所要做的就是使用相同的记录进行左右评估,类型系统可以推断出两者的组合,而不需要并集:
instance evalAdd ::
( Component a Int r
, Component b Int r
) => Component (Add a b) Int r where
eval (Add a b) r = (eval a r) + (eval b r)
当不使用typeclasses时,这一点更为明显:
> f r = r.foo :: Int
> g r = r.bar :: Int
> :t f
forall r. { foo :: Int | r } -> Int
> :t g
forall r. { bar :: Int | r } -> Int
> fg r = (f r) + (g r)
> :t fg
forall r. { foo :: Int, bar :: Int | r } -> Int
我认为,与@erisco的方法相比,这种方法的缺点是,空行必须在Var等实例的定义中,而不是在eval的定义中?它也不是强制的,所以如果一个组件不使用开放行,那么像Add这样的组合子就不再工作了。
好处是没有对RProxies的要求,除非eriscos实现实际上不需要它们,否则我没有检查过。
更新:
我想出了一种要求关闭eval实例的方法,但这让它变得非常丑陋,额外使用了从purescript记录中选取的内容。
我真的不确定为什么这会比上面的选项更好,感觉我只是在重新实现行多态性
import Record.Extra (pick, class Keys)
...
instance evalVar ::
( IsSymbol a
, Row.Cons a b () r
) => Component (Var a b) b r where
eval _ r = R.get (SProxy :: SProxy a) r
data Add a b = Add a b
evalp :: forall c b r r_sub r_sub_rl trash
. Component c b r_sub
=> Row.Union r_sub trash r
=> RL.RowToList r_sub r_sub_rl
=> Keys r_sub_rl
=> c -> Record r -> b
evalp c r = eval c (pick r)
instance evalAdd ::
( Component a Int r_a
, Component b Int r_b
, Row.Union r_a r_b r
, Row.Nub r r_nub
, Row.Union r_a trash_a r_nub
, Row.Union r_b trash_b r_nub
, RL.RowToList r_a r_a_rl
, RL.RowToList r_b r_b_rl
, Keys r_a_rl
, Keys r_b_rl
) => Component (Add a b) Int r_nub where
eval (Add a b) r = (evalp a r) + (evalp b r)
eval (Add (Var :: Var "a" Int) (Var :: Var "b" Int) ) :: { a :: Int , b :: Int } -> Int
eval (Add (Var :: Var "a" Int) (Var :: Var "a" Int) ) :: { a :: Int } -> Int