2

我有以下数据：

data LinkedList a = Node a (LinkedList a) | Empty deriving (Show)

而且我想知道如何在没有模式匹配的情况下从中获取单个值。
所以在基于C的语言中：list.value

4

6 回答 6

6

Jared Loomis，听起来您想要访问 LinkedList 的不同部分，而不必编写自己的辅助函数。因此，有一种替代技术可以编写数据构造函数，为您编写这些辅助函数。

data LinkedList a = Node { nodeHead :: a, rest :: LinkedList a} | Empty
  deriving (Show)

示例用法：

*Main> let example = Node 1 (Node 2 (Node 3 Empty))
*Main> example
Node {nodeHead = 1, rest = Node {nodeHead = 2, rest = Node {nodeHead = 3, rest = Empty}}}
*Main> nodeHead example
1
*Main> nodeHead . rest $ example
2
*Main> nodeHead . rest . rest $ example
3

小心尽管 nodeHead 和 rest 被认为是部分函数，​​并且在 Empty 上使用时会引发异常：

*Main> nodeHead Empty
*** Exception: No match in record selector nodeHead
*Main> rest Empty
*** Exception: No match in record selector rest

如果你想要一些带有后修复语法的东西，我会推荐 lens包。

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens

data LinkedList' a = Node' { _nodeHead' :: a, _rest' :: LinkedList' a} | Empty'
  deriving (Show)
makeLenses ''LinkedList'

*Main> example ^? rest' 
Just (Node' {_nodeHead' = 2, _rest' = Node' {_nodeHead' = 3, _rest' = Empty'}})
*Main> example ^? rest' . nodeHead'
Just 2
于 2013-08-14T03:29:10.347 回答
3

让我们使用 monad 来做你想做的事。Monad 很棒，因为在定义它们时，您可以重新定义对您的意义;和=意义。（这是 Haskell，我们使用换行符和缩进来指示去向并;与<-永久定义区分开来=。）

我将不得不使用模式匹配来制作实例，因为我还没有其他事情要做：

instance Monad LinkedList where
   Empty >>= f = Empty
   (Node a as) >>= f = f a `andthen` (as >>= f)
   return a = Node a Empty

绑定运算符>>=是运算符后面的可配置管道<-。在这里，我们选择;了下一个元素，addthen在作品中使用了一个辅助函数：

andthen :: LinkedList a -> LinkedList a -> LinkedList a
Empty `andthen` list = list
(Node a list) `andthen` therest = Node a (list `andthen` therest)

现在我们可以使用 monad 表示法一次获取一个值。例如，让我们对链表中的元素应用一个函数：

applyToElements :: (a -> b) -> LinkedList a -> LinkedList b
applyToElements f list = do
   val <- list
   return (f val)

ghci> applyToElements ( ++ ", yeah" )  (Node "Hello" (Node "there" Empty))
Node "Hello, yeah" (Node "there, yeah" Empty)

更简单的方法

我根本不会那样定义的。我会直接使用模式匹配：

applyToElements :: (a -> b) -> LinkedList a -> LinkedList b
applyToElements f Empty = Empty
applyToElements f (Node a list) = Node (f a) (applyToElements f list)

然后声明

instance Functor LinkedList where
   fmap = applyToElements

因为按元素应用另一个函数的函数的通常名称是fmap.

更复杂

不过，Monad 对其他事情也有好处，有时它是表达某事的最佳方式：

combinationsWith :: (a -> b -> c) -> LinkedList a -> LinkedList b -> LinkedList c
combinationsWith f list otherlist = do  -- do automatically traverses the structure 
    val <- list                    -- works like   val = list.value 
    otherval <- otherlist          --              otherval = otherlist.value
    return (f val otherval)        -- once for each value/othervalue

andthen因为我们在为 LinkedList定义时选择使用<-，如果我们使用两个列表，它将使用第一个列表，然后以嵌套子循环的方式使用第二个，所以otherval值的变化比第一个更频繁val，所以我们得到：

ghci> combinationsWith (+) (Node 3 (Node 4 Empty)) (Node 10 (Node 100 Empty))
Node 13 (Node 103 (Node 14 (Node 104 Empty)))
于 2013-08-13T22:40:23.680 回答
2

我不会为您的问题提供 Haskell 解决方案，而是与 C 进行更现实的比较，并建议您并不真正想要您似乎要求的东西：

struct list {
    int value;
    struct list *next;
};

int main(void) {
    struct list *list = NULL;
    int val;

    /* Goodbye, cruel world! */
    val = list->value;

    /* If I had "pattern-matched"... */
    if (list == NULL) {
        val = 0;
    } else {
        val = list->value;
    }
    return 0;
}

当您不检查 C 中的 NULL 情况（对应于 Haskell 中的模式匹配）时，您会在程序执行的某个时刻因 SEGFAULT 而崩溃，而不是出现编译错误。

换句话说，如果不使用 C 语言进行案例分析，您也无法从“可能为空”的递归数据类型中获取值！如果您重视程序的稳定性，至少不会。Haskell 不仅坚持你做正确的事，而且提供了方便的语法来帮助你这样做！

正如其他答案中提到的，记录定义语法自动为您提供方便的投影（即访问器函数），与访问 C 中的结构成员相比，它有一些权衡：投影是一流的，因此可以用作参数和返回值；但它们与所有其他函数位于相同的命名空间中，这可能会导致不幸的名称冲突。

因此，在直接数据类型（即非递归）的情况下，访问成员的语法大致处于相同的便利级别：whole.part对于类 C 语言与part whole对于 Haskell。

对于一个或多个成员引用相同类型的可能为空的实例的递归类型（如您的示例中的那个），在提取值之前，需要在任一语言中进行案例分析。在这里，您将需要使用类 C 语言使用案例分析或可能的异常处理程序来包装字段访问。在 Haskell 中，您可以使用各种形式的语法糖来进行模式匹配，这些语法糖往往更加简洁。

此外，请参阅有关 Monads 的答案，以了解在 Haskell 中使用“可能为空”类型提供更多便利的方法，隐藏库函数内多步计算的大部分中间模式匹配。

总结一下：我的观点是，当你花时间学习 Haskell 的模式和习语时，你可能会发现自己越来越少地错过使用类 C 语言做事的方式。

于 2013-08-14T05:55:08.227 回答
1

通常，您不需要提取所有值。如果你真的想提取，使用Comonad extract函数：

class Functor w => Comonad w where
    extract :: w a -> a
    ...

通常Foldable, Traversable, Monoids,Monad更有Zippers用

于 2013-08-14T20:31:45.620 回答
1

为了完整起见，让我提到一些我听说过“dot hack”这个名字的东西：

Prelude> data LinkedList a = Node { nodeHead :: a, nodeRest :: LinkedList a} | Empty deriving (Show)
Prelude> let example = Node 1 (Node 2 (Node 3 Empty)) :: LinkedList Int
Prelude> let (.) = flip ($)
Prelude> example.nodeRest.nodeHead
2

它只是意识到 C 风格的访问.与将访问器函数应用于之前提到的对象相同，这在 Haskell 中意味着翻转应用程序 operator 的参数($)。

当然，可能不会在实际代码中使用它，因为它会引起其他人的混淆以及组合运算符的丢失。

于 2013-08-26T09:12:53.337 回答
0

我只是模式匹配。

llHead :: LinkedList a -> a
llHead Empty      = error "kaboom"
llHead (Node x _) = x

如果您希望元素位于特定索引处，请尝试以下操作（也使用模式匹配）：

llIdx :: LinkedList a -> Int -> a
llIdx l i = go l i
  where go Empty       _ = error "out of bounds"
        go (Node x _)  0 = x
        go (Node _ xs) j = go xs (j - 1)

一些保证这有效：

import Test.QuickCheck

fromList []     = Empty
fromList (x:xs) = Node x (fromList xs)

allIsGood xs i  = llIdx (fromList xs) i == xs !! i

llIdxWorksLikeItShould (NonEmpty xs) =
  let reasonableIndices = choose (0, length xs - 1) :: Gen Int
  in  forAll reasonableIndices (allIsGood xs)

-- > quickCheck llIdxWorksLikeItShould
-- +++ OK, passed 100 tests.
于 2013-08-14T02:07:03.553 回答