[Haskell-cafe] Searching for ADT patterns with elem and find
pkeir at dcs.gla.ac.uk
Wed Nov 12 08:44:42 EST 2008
That is indeed a very elegant solution; I too often forget about the wonders of list comprehension.
I guess one drawback compared to Neil's suggested use of "any" (and staying with a separate "isTypeB") is that your solution will iterate over the entire list, regardless of an early hit.
But I don't think your second (as-pattern) solution for findBs is ugly; I quite like it actually.
From: Tom Nielsen [mailto:tanielsen at gmail.com]
Sent: Wed 12/11/2008 12:39
To: Paul Keir
Cc: haskell-cafe at haskell.org
Subject: Re: [Haskell-cafe] Searching for ADT patterns with elem and find
somebody pointed out a few months back that list comprehensions do this nicely:
containsTypeB ts = not $ null [x | (B x) <- ts]
no need for defining isTypeB.
not quite sure how you would write findBs :: [T]->[T] succinctly; maybe
findBs ts = [b | b@(B _) <- ts]
findBs ts = [B x | (B x) <- ts]
both of them compile but the first is ugly and the second is
inefficient (Tags a new T for every hit).
2008/11/12 Paul Keir <pkeir at dcs.gla.ac.uk>:
> Hi All,
> If I have an ADT, say
> data T
> = A String Integer
> | B Double
> | C
> and I want to find if a list (ts) of type T contains an element of subtype
> "B Double", must my "containsTypeX" function use a second "isTypeX" function
> as follows:
> isTypeB :: T -> Bool
> isTypeB (B _) = True
> isTypeB _ = False
> containsTypeB :: [T] -> Bool
> containsTypeB ts = maybe False (\x -> True) (find isTypeB ts)
> I understand that while something like "find C ts" will work, "find (isTypeB
> _) ts" will not, but is there no such thing as a pattern combinator(?), or
> lambda that could help with this situation. I find I have many individual
> "isTypeB" functions now.
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the Haskell-Cafe