27

我发现自己需要一个数据结构,它可能包含一个A,可能是一个B,并且绝对是其中之一。如果我要为这个东西破解一个通用数据类型,它可能看起来像:

data OneOrBoth a b = A a | B b | AB a b

maybeA :: OneOrBoth a b -> Maybe a
maybeB :: OneOrBoth a b -> Maybe b
eitherL :: OneOrBoth a b -> Either a b -- Prefers a
eitherR :: OneOrBoth a b -> Either a b -- Prefers b
hasBoth, hasExactlyOne, hasA, hasB :: OneOrBoth a b -> Bool

这个数据结构有名字吗?有没有一种规范的方法来处理 Haskell 中的一个或两个结构?

4

3 回答 3

45

Data.These

这对于表示两个值的组合很有用,如果任一输入是则定义组合。从代数上讲,该类型 These A B表示 (A + B + AB),它不容易计算和和乘积——类似这样的类型Either A (B, Maybe A)不清楚且难以使用。

于 2013-10-16T20:46:00.940 回答
7

Data.这些已被提及,可能是最好的选择,但如果我要自己动手,我会这样做:

import Control.Applicative ((<$>), (<*>))

type These a b = Either (Either a b) (a, b)

maybeA :: These a b -> Maybe a
maybeA (Left (Left a)) = Just a
maybeA (Right (a, _))  = Just a
maybeA _               = Nothing

maybeB :: These a b -> Maybe b
maybeB (Left (Right b)) = Just b
maybeB (Right (_, b))   = Just b
maybeB _                = Nothing

eitherA :: These a b -> Either a b
eitherA (Left (Left a))  = Left a
eitherA (Right (a, _))   = Left a
eitherA (Left (Right b)) = Right b

eitherB :: These a b -> Either a b
eitherB (Left (Right b)) = Right b
eitherB (Right (_, b))   = Right b
eitherB (Left (Left a))  = Left a

hasBoth, hasJustA, hasJustB, hasA, hasB :: These a b -> Bool

hasBoth (Right _) = True
hasBoth _         = False

hasJustA (Left (Left _)) = True
hasJustA _               = False

hasJustB (Left (Right _)) = True
hasJustB _                = False

hasA = (||) <$> hasBoth <*> hasJustA
hasB = (||) <$> hasBoth <*> hasJustB
于 2013-10-16T21:42:56.260 回答
5

如果您想要“零、一或两者”,您将拥有1 + A + B + A*B = (1 + A) * (1 + B)or (Maybe A, Maybe B)

您可以A + B + A*B = (1+A)*(1+B)-1通过包装(Maybe A, Maybe B)anewtype并使用智能构造函数来删除(Nothing,Nothing)

module Some (
  Some(),
  this, that, those, some,
  oror, orro, roro, roor,
  swap
) where

import Control.Applicative ((<|>))

newtype Some a b = Some (Maybe a, Maybe b) deriving (Show, Eq)

-- smart constructors
this :: a -> Some a b
this a = Some (Just a,Nothing)

that :: b -> Some a b
that b = Some (Nothing, Just b)

those :: a -> b -> Some a b
those a b = Some (Just a, Just b)

-- catamorphism/smart deconstructor
some :: (a -> r) -> (b -> r) -> (a -> b -> r) -> Some a b -> r
some f _ _ (Some (Just a, Nothing)) = f a
some _ g _ (Some (Nothing, Just b)) = g b
some _ _ h (Some (Just a, Just b))  = h a b
some _ _ _ _ = error "this case should be unreachable due to smart constructors"

swap :: Some a b -> Some b a
swap ~(Some ~(ma,mb)) = Some (mb,ma)

-- combining operators
oror, orro, roro, roor :: Some a b -> Some a b -> Some a b

-- prefer the leftmost A and the leftmost B
oror (Some (ma,mb)) (Some (ma',mb')) = Some (ma <|> ma', mb <|> mb')
-- prefer the leftmost A and the rightmost B
orro (Some (ma,mb)) (Some (ma',mb')) = Some (ma <|> ma', mb' <|> mb)
-- prefer the rightmost A and the rightmost B
roro = flip oror
-- prefer the rightmost A and the leftmost B
roor = flip orro

组合运算符很有趣:

λ this "red" `oror` that "blue" `oror` those "beige" "yellow"
Some (Just "red",Just "blue")
λ this "red" `orro` that "blue" `orro` those "beige" "yellow"
Some (Just "red",Just "yellow")
λ this "red" `roor` that "blue" `roor` those "beige" "yellow"
Some (Just "beige",Just "blue")
λ this "red" `roro` that "blue" `roro` those "beige" "yellow"
Some (Just "beige",Just "yellow")
于 2013-10-17T02:39:04.667 回答