Mitchell, Neil neil.mitchell.2 at credit-suisse.com
Wed Nov 12 08:53:12 EST 2008

```> 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.

Nope, it will stop on the first one - Haskell is lazy like that :-)

Thanks, Neil

________________________________

Sent: 12 November 2008 1:45 pm
To: Tom Nielsen
and find

Thanks Tom,

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.

Cheers,
Paul

-----Original Message-----
From: Tom Nielsen [mailto:tanielsen at gmail.com]
Sent: Wed 12/11/2008 12:39
To: Paul Keir
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]

or

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).

Tom

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
>  deriving(Eq)
>
> 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.
>
> Regards,
> Paul
>
> _______________________________________________
>
>

==============================================================================