Personal tools


From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(one colon too much)
Line 2: Line 2:
You can make use of some SyntacticSugar of Haskell, namely of [[Guards]].
You can make use of some [[syntactic sugar]] of Haskell, namely of [[guard]]s.

Revision as of 14:48, 8 November 2006

Can I have a
where the alternatives contain expressions?

You can make use of some syntactic sugar of Haskell, namely of guards.

case () of _
             | cond1     -> ex1
             | cond2     -> ex2
             | cond3     -> ex3
             | otherwise -> exDefault

Alternatively, one could simply factor out a function(/value) and use guards in the argument patterns.

Why sticking to syntactic sugar? We can do it nicely with a function implemented in Haskell:

select :: a -> [(Bool, a)] -> a
select def = maybe def snd . List.find fst
select exDefault
    [(cond1, ex1),
     (cond2, ex2),
     (cond3, ex3)]

Alternative implementations are

select' def = fromMaybe def . lookup True
{- a purely functional implementation of if-then-else -}
if' :: Bool -> a -> a -> a
if' True  x _ = x
if' False _ y = y
select'' = foldr (uncurry if')
The implementation of
makes clear that
can be considered as nested
s. The functional
is also useful in connection with
zipWith3 if'
merges two lists according to a list of conditions.

If you don't like the parentheses for the pairs, you can also define

data SelectBranch a = (:->) {
  condition  :: Bool,
  expression :: a
select :: a -> [SelectBranch a] -> a
select def = maybe def expression . List.find condition
select exDefault
    [cond1 :-> ex1,
     cond2 :-> ex2,
     cond3 :-> ex3]