Question

假设我的类型定义为：

data Node = forall a b. Node (SimpleWire a b)

SimpleWire是monad，其中a代表输入，b代表输出。我可以对那个monad做功能组合。因此，假设我wireA类型为SimpleWire A B，wireB类型为SimpleWire B C，则wireA . wireB会向我提供类型SimpleWire A C。

现在我想折叠该monad的列表（对于这种情况，类型为[Node]）。类似的东西：

buildGraph :: [Node] -> (SimpleWire a b)
buildGraph (Node h):t = h . (buildGraph t)

如何在Haskell的类型系统中使用此代码？

Answer 1

我们无法使用建议的类型撰写[Node]。这是因为否则我们会得到

sw1 :: SimpleWire A B
sw2 :: SimpleWire C D
buildGraph :: [Node] -> (SimpleWire a b)
buildGraph [ sw1, sw2 ] :: SimpleWire E F

这太强大了。我们能够组成任意的，不兼容的类型（错误的），然后在最后一个随机写入（错误）。

问题是我们丢失了[Node]类型中的所有类型信息。我们需要记住一些，即：

第一种和最后一种线类型是已知的（中间线型不是）
在列表中，每个相邻节点都是可组合的

所以，我们得到一个自定义的GADT列表类型

data NodeList a b where
   Nil  :: NodeList a a
   Cons :: Node a b -> NodeList b c -> NodeList a c

然后

buildGraph :: NodeList a b -> SimpleWire a b
buildGraph Nil = id  
buildGraph (Cons (Node h) t) = h . buildGraph t

Answer 2

我将承担以下故事：

你可能使用过类型

data Node = forall a b. Node (SimpleWire a b)

而不仅仅是SimpleWire a b因为您需要SimpleWire的列表，其中a和b不同。特别是，你真正希望作为buildGraph的参数是（在伪Haskell中）

buildGraph :: [SimpleWire a b, SimpleWire b c, ..., SimpleWire x y] -> SimpleWire a y

你无法用Haskell的标准同构[]表达第一个列表，并尝试使用普遍量化的类型来帮助你摆脱那个泡菜。

如果我说的是真的，你可能正在寻找type-threaded lists or "thrists"。特别是，您可以完全取消Node。 Thrist (->) a b是一系列功能a -> a1，a1 -> a2，...，an -> b。更一般地，Thrist f a b是f s f a a1，f a1 a2，...，f an b的列表。

{-# LANGUAGE GADTs #-}
import qualified Data.Thrist as DT

-- Note that I'll be using (>>>) as a flipped form of (.), i.e. 
-- (>>>) = flip (.)
-- (>>>) is in fact an Arrow operation which is significantly more general
-- than function composition. Indeed your `SimpleWire` type is almost
-- definitely an arrow.
import Control.Arrow ((>>>))

-- A simple take on SimpleWire
type SimpleWire = (->)

-- Ugh a partial function that blows up if the thrist is empty
unsafeBuildGraph :: DT.Thrist SimpleWire a b -> SimpleWire a b
unsafeBuildGraph = DT.foldl1Thrist (>>>)

-- Making it total
buildGraph :: DT.Thrist SimpleWire a b -> Maybe (SimpleWire a b)
buildGraph DT.Nil = Nothing
buildGraph (wire `DT.Cons` rest) = Just $ DT.foldlThrist (>>>) wire rest

-- For syntactic sugar
(*::*) = DT.Cons
infixr 6 *::*

trivialExample :: DT.Thrist SimpleWire a a
trivialExample = id *::* id *::* DT.Nil

lessTrivialExample :: (Num a, Show a) => DT.Thrist SimpleWire a String
lessTrivialExample = (+ 1) *::* (* 2) *::* show *::* DT.Nil

-- result0 is "12"
result0 = (unsafeBuildGraph lessTrivialExample) 5

-- result1 is Just "12"
result1 = fmap ($ 5) (buildGraph lessTrivialExample)

旁注：

虽然SimpleWire很可能是一个单子，但这可能不会直接帮助你。特别是当函数是monad时，你似乎关心的是概括函数组合的概念，这是arrows的含义（并且它只与monad有间接关系）。我使用>>>并且Thrist有一个Arrow实例，这有一些提示。正如我在代码的评论中提到的，SimpleWire可能是Arrow。

减少Haskell中的Monads

2 个答案: