Passende mehrere Daten Typkonstruktoren sofort

Question

Lets sagen, dass wir diese Art Erklärung haben:

data D a = A a | B a | C a | D a | E a | F a 

und möchte eine Funktion über sie definieren, welche die Daten Konstrukteuren in 2 Sets unterteilt. Es wäre schön, etwas in der Art zu schreiben:

g x | x `is` [A,B,C] = 1 
    | x `is` [D,E,F] = 2 

anstatt auf jeden Konstruktor separat zu vergleichen.

Gibt es eine Möglichkeit, dies zu erreichen? Ich schaute auf uniplate, konnte aber keinen Weg finden, es zu tun.

Answer 1

Edit: Wenn alle Konstrukteure die gleiche Art von Feldern haben, könnten Sie Functor missbrauchen:

{-# LANGUAGE DeriveFunctor #-} 

data D a = A a | B a | C a | D a | E a | F a 
    deriving (Eq, Functor) 

isCons :: (Eq (f Int), Functor f) => f a -> (Int -> f Int) -> Bool 
isCons k s = fmap (const 42) k == s 42 

is :: (Eq (f Int), Functor f) => f a -> [Int -> f Int] -> Bool 
is k l = any (isCons k) l 

g :: D a -> Int 
g x | x `is` [A,B,C] = 1 
    | x `is` [D,E,F] = 2 

---

Sie könnten versuchen,

{-# LANGUAGE DeriveDataTypeable #-} 

import Data.Data 

data D a = A a | B a | C a | D a | E a | F a 
     deriving (Typeable, Data) 

g :: Data a => D a -> Int 
g x | y `elem` ["A","B","C"] = 1 
    | y `elem` ["D","E","F"] = 2 
    where y = showConstr (toConstr x) 

Answer 2

Es ist ein bisschen wie ein Hack, aber wie etwa mit Data.Data und einem "Platzhalter" -Typ?

{-# LANGUAGE DeriveDataTypeable #-} 

import Data.Data 

data X = X deriving (Show, Data, Typeable) 
data D a = A a | B a | C a | D a a | E a a | F a a 
    deriving (Show, Data, Typeable) 


matchCons :: (Data a) => D a -> [D X] -> Bool 
matchCons x ys = any ((== xc) . toConstr) ys 
    where xc = toConstr x 

g :: (Data a) => D a -> Int 
g x | matchCons x [A X, B X, C X] = 1 
    | matchCons x [D X X, E X X, F X X] = 2 

Beachten Sie, dass dies das Problem der Typ-Signatur/anderer Konstruktor Arity vermeidet. Es gibt wahrscheinlich einen saubereren Weg, etwas Ähnliches zu tun.

Answer 3

Ich habe versucht, mit Antwort von @KennyTM zu verallgemeinern:

data D a = A a | B a | C a a | D 
    deriving (Show, Eq, Functor) 

class AutoBind a where 
    bindSome :: forall b . (a -> b) -> b 

instance AutoBind Bool where bindSome f = f False 
instance Num a => AutoBind a where bindSome f = f 0 

class AutoConst a b | a -> b where {- bind until target type -} 
    bindAll :: a -> b 

instance AutoBind a => AutoConst (a -> b) b where bindAll = bindSome 
instance (AutoBind a, AutoConst b c) => AutoConst (a -> b) c where bindAll = bindAll . bindSome 

isCons :: (Eq (f a), AutoBind a, AutoConst b (f a), Functor f) => f a -> b -> Bool 
isCons x y = fmap (bindSome const) x == bindAll y 

Aber aus irgendeinem Grund funktioniert es nicht für Konstruktor C

Answer 4

Wenn Sie oft passen müssen für den gleichen Satz von Konstruktoren könnte eine Hilfsfunktion die einfachste Lösung sein. Zum Beispiel:

g x = g_ (getAbc x) 
    where 
    g_ (Just v) = 1 
    g_ Nothing = 2 

Oder mit der maybe Funktion:

getAbc :: D a -> Maybe a 
getAbc (A v) = Just v 
getAbc (B v) = Just v 
getAbc (C v) = Just v 
getAbc _  = Nothing 

Mit einer solchen Hilfsfunktion, die Definition von g kann so vereinfacht werden

g = maybe 2 (\v -> 1) . getAbc 

Answer 5

Ich wünsche, dass Haskell-Muster hätten eine Möglichkeit, das "ODER" zweier Muster zu spezifizieren, ähnlich | in OCaml:

(* ocaml code *) 
let g x = match x with 
      A v | B v | C v -> 1 
      | C v | D v | E v -> 2 

Answer 6

Ich hatte die gleiche Frage. Meine Lösung wäre, eine Ansicht zu verwenden, obwohl ich persönlich etwas kanonisch semantisch Äquivalentes bevorzugen würde (in einigen der Codes, die ich schreibe, ist die Faulheitserhaltung entscheidend, so dass zusätzliche unnötige Musterübereinstimmungen die Technik unbrauchbar machen könnten).

{-# LANGUAGE ViewPatterns #-} 

data D a = A a | B a | C a | D a | E a | F a 
isABC (A v) = Just v 
isABC (B v) = Just v 
isABC (C v) = Just v 
isABC _ = Nothing 

f :: D Int -> Int 
f (isABC -> Just v) = v 
f (isABC -> Nothing) = 0