Adam Smyczek wrote:

data SampleType = A | B Int | C String | D -- .... etc.

sampleTypes = [A, B 5, C "test"] :: [SampleType]

How do I find for example element A in the sampleTypes list?

Here's one way to do it: filter (\x -> case x of A -> True; otherwise -> False) sampleTypes ==> [A] filter (\x -> case x of B _ -> True; otherwise -> False) sampleTypes ==> [B 5] filter (\x -> case x of C _ -> True; otherwise -> False) sampleTypes ==> [C "test"] Your idea works just as well:

isA :: SampleType -> Bool isA A = True isA _ = False

filter isA sampleTypes ==> [A] There is a third possibility: Have you learned about the maybe function or the either function yet? maybe :: b -> (a -> b) -> Maybe a -> b either :: (a -> c) -> (b -> c) -> Either a b -> c I would call these "mediating morphisms", where "morphism" is techno- babble for "function". You could write your own version of one of these for SampleType. Assuming you have: data SampleType = A | B Int | C String You could write: sampletype :: t -> (Int -> t) -> (String -> t) -> SampleType -> t sampletype a bf cf s = case s of A -> a B n -> bf n C s -> cf s isA = sampletype True (const False) (const False) isB = sampletype False (const True) (const False) isC = sampletype False (const False) (const True) filter isA sampleTypes ==> [A] This (the mediating morphism) is probably overkill for what you want to do, though.

Adam Smyczek wrote:

data SampleType = A | B Int | C String | D -- .... etc. deriving (Eq)

sampleTypes = [A, B 5, C "test"] :: [SampleType]

If you derive from Eq, you can do isA = (==) A filter isA sampleTypes or ad-hoc: filter ((==) A) sampleTypes things like filter (\x -> case x of { A -> True ; B b | b > 2 -> True ; C c | c == "foo" -> True ; _ -> False}) sampleTypes work, too. Admittedly, I'm lambda-spoilt. -- (c) this sig last receiving data processing entity. Inspect headers for past copyright information. All rights reserved. Unauthorised copying, hiring, renting, public performance and/or broadcasting of this signature prohibited.

There's always one more way to do things in Haskell! :) Here's yet another way to get at the payloads in a list. You don't have to know how this works to use it: data SampleType = A | B Int | C String unA :: SampleType -> [()] unA A = return () unA _ = fail "Not an A" unB :: SampleType -> [Int] unB (B b) = return b unB _ = fail "Not a B" unC :: SampleType -> [String] unC (C c) = return c unC _ = fail "Not a C" -- I can check for more than one constructor... -- Note that a single type must be returned, -- so for C I return e.g. the length of the string unBorC :: SampleType -> [Int] unBorC (B b) = return b unBorC (C c) = return (length c) unBorC _ = fail "Not a B or C" For lists, the >>= operator knows to ignore failure and collect anything else into a new list. The technobabble for this is that [] is a Monad. *Main> let sampleTypes = [A, B 5, C "test", A, A, B 7, C "go"] *Main> sampleTypes >>= unA [(),(),()] *Main> sampleTypes >>= unB [5,7] *Main> sampleTypes >>= unC ["test","go"] *Main> sampleTypes >>= unBorC [5,4,7,2] Adam Smyczek wrote:

Example:

data SampleType = A | B Int | C String | D -- .... etc.

sampleTypes = [A, B 5, C "test"] :: [SampleType]

How do I find for example element A in the sampleTypes list? Do I have to create e.g.:

isA :: SampleType -> Bool isA A = True isA _ = False

for every constructor and use find? It feels like this is not the quicker method.

Thanks, Adam

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

adam.smyczek:

Example:

data SampleType = A | B Int | C String | D -- .... etc.

sampleTypes = [A, B 5, C "test"] :: [SampleType]

How do I find for example element A in the sampleTypes list? Do I have to create e.g.:

isA :: SampleType -> Bool isA A = True isA _ = False

for every constructor and use find? It feels like this is not the quicker method.

This is where the implicit filtering in a list comprehension comes in really handy, data T = A | B Int | C String | D deriving Show xs = [A, B 5, C "test", D] main = do print [ A | A <- xs ] -- filter A's print [ x | x@(C _) <- xs ] -- filter C's {- *Main> main [A] [C "test"] -}