Case
From HaskellWiki
(Difference between revisions)
(moved from Hawiki) 
(→Using functions: reshuffle some code lines, c/e) 

(11 intermediate revisions by 4 users not shown)  
Line 1:  Line 1:  
−  Can I have a {{{case}}} where the alternatives contain expressions? 
+  == Question == 
+  Can I have a <hask>case</hask> where the alternatives contain expressions? 

−  You can make use of some SyntacticSugar of Haskell, namely of ["Guards"]. 
+  == Answer == 
−  {{{#!syntax haskell 
+  There are several approaches to this problem. 
−  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. 
+  === Using functions === 
−  Why sticking to syntactic sugar? We can do it nicely with a function implemented in Haskell: 
+  ==== select ==== 
−  {{{#!syntax haskell 
+  
+  We can do this nicely with a function implemented in Haskell: 

+  <haskell> 

select :: a > [(Bool, a)] > a 
select :: a > [(Bool, a)] > a 

select def = maybe def snd . List.find fst 
select def = maybe def snd . List.find fst 

−  +   = fromMaybe def . lookup True 

+   = maybe def id . lookup True 

select exDefault 
select exDefault 

Line 18:  Line 19:  
(cond2, ex2), 
(cond2, ex2), 

(cond3, ex3)] 
(cond3, ex3)] 

−  }}} 
+  </haskell> 
+  Unfortunately this function is not in the [[Prelude]]. 

+  It is however in the [http://hackage.haskell.org/packages/archive/utilityht/0.0.1/doc/html/DataBoolHT.html#v%3Aselect utilityht] package. 

−  Alternative implementations are 
+  ==== nested 'if' ==== 
−  {{{#!syntax haskell 

−  select' def = fromMaybe def . lookup True 

+  Alternative implementations are 

+  <haskell> 

{ a purely functional implementation of ifthenelse } 
{ a purely functional implementation of ifthenelse } 

if' :: Bool > a > a > a 
if' :: Bool > a > a > a 

Line 28:  Line 31:  
select'' = foldr (uncurry if') 
select'' = foldr (uncurry if') 

−  }}} 
+  </haskell> 
−  The implementation of {{{select''}}} makes clear that {{{select}}} can be considered as nested {{{if}}}s. 
+  The implementation of <hask>select''</hask> makes clear that <hask>select</hask> can be considered as nested <hask>if</hask>s. 
−  The functional {{{if'}}} is also useful in connection with {{{zipWith3}}} since {{{zipWith3 if'}}} merges two lists according to a list of conditions. 
+  The functional <hask>if'</hask> is also useful in connection with <hask>zipWith3</hask> since <hask>zipWith3 if'</hask> merges two lists according to a list of conditions. 
+  See [[ifthenelse]]. 

+  Alternatively you can unroll <hask>foldr</hask> and write 

+  <haskell> 

+  if' cond1 ex1 $ 

+  if' cond2 ex2 $ 

+  if' cond3 ex3 $ 

+  exDefault 

+  </haskell> 

−  If you don't like the parentheses for the pairs, you can also define 
+  ==== infix operator ==== 
−  {{{#!syntax haskell 

−  data SelectBranch a = (:>) { 

−  condition :: Bool, 

−  expression :: a 

−  } 

−  select :: a > [SelectBranch a] > a 
+  If you use <hask>if'</hask> in infix form, 
−  select def = maybe def expression . List.find condition 
+  you may call it <hask>?</hask> like in C, 
+  then because of partial application it will work nicely together with '$' for the else clause. 

+  <haskell> 

+  infixl 1 ? 

+  (?) :: Bool > a > a > a 

+  (?) = if' 

+  cond1 ? ex1 $ 

+  cond2 ? ex2 $ 

+  cond3 ? ex3 $ 

+  exDefault 

+  </haskell> 

−  select exDefault 
+  === Using syntactic sugar === 
−  [cond1 :> ex1, 
+  
−  cond2 :> ex2, 
+  ==== Guards ==== 
−  cond3 :> ex3] 
+  
−  }}} 
+  You can make use of some [[syntactic sugar]] of Haskell, namely of [[guard]]s. 
+  
+  <haskell> 

+  case () of _ 

+   cond1 > ex1 

+   cond2 > ex2 

+   cond3 > ex3 

+   otherwise > exDefault 

+  </haskell> 

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

+  
+  ==== List comprehensions ==== 

+  
+  An alternative sugarful approach is to use [[list comprehension]]s. 

+  
+  <haskell> 

+  head $ 

+  [ ex1  cond1 ] ++ 

+  [ ex2  cond2 ] ++ 

+  [ ex3  cond3 ] ++ 

+  [ exDefault ] 

+  </haskell> 

+  
+  [[Category:FAQ]] 

+  [[Category:Idioms]] 
Latest revision as of 18:31, 15 March 2012
Contents 
[edit] 1 Question
Can I have acase
[edit] 2 Answer
There are several approaches to this problem.
[edit] 2.1 Using functions
[edit] 2.1.1 select
We can do this nicely with a function implemented in Haskell:
select :: a > [(Bool, a)] > a select def = maybe def snd . List.find fst  = fromMaybe def . lookup True  = maybe def id . lookup True select exDefault [(cond1, ex1), (cond2, ex2), (cond3, ex3)]
Unfortunately this function is not in the Prelude. It is however in the utilityht package.
[edit] 2.1.2 nested 'if'
Alternative implementations are
{ a purely functional implementation of ifthenelse } if' :: Bool > a > a > a if' True x _ = x if' False _ y = y select'' = foldr (uncurry if')
select''
select
if
if'
zipWith3
zipWith3 if'
See ifthenelse.
Alternatively you can unrollfoldr
if' cond1 ex1 $ if' cond2 ex2 $ if' cond3 ex3 $ exDefault
[edit] 2.1.3 infix operator
If you useif'
?
then because of partial application it will work nicely together with '$' for the else clause.
infixl 1 ? (?) :: Bool > a > a > a (?) = if' cond1 ? ex1 $ cond2 ? ex2 $ cond3 ? ex3 $ exDefault
[edit] 2.2 Using syntactic sugar
[edit] 2.2.1 Guards
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.
[edit] 2.2.2 List comprehensions
An alternative sugarful approach is to use list comprehensions.
head $ [ ex1  cond1 ] ++ [ ex2  cond2 ] ++ [ ex3  cond3 ] ++ [ exDefault ]