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

(6 intermediate revisions by 3 users not shown)  
Line 1:  Line 1:  
+  == Question == 

+  
Can I have a <hask>case</hask> where the alternatives contain expressions? 
Can I have a <hask>case</hask> where the alternatives contain expressions? 

+  == Answer == 

−  You can make use of some [[syntactic sugar]] of Haskell, namely of [[guard]]s. 
+  There are several approaches to this problem. 
−  <haskell> 
+  === Using functions === 
−  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. 
+  ==== select ==== 
−  Why sticking to syntactic sugar? We can do it nicely with a function implemented in Haskell: 
+  We can do this nicely with a function implemented in Haskell: 
<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 19:  Line 22:  
(cond3, ex3)] 
(cond3, ex3)] 

</haskell> 
</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. 

+  
+  ==== nested 'if' ==== 

Alternative implementations are 
Alternative implementations are 

<haskell> 
<haskell> 

−  select' def = fromMaybe def . lookup True 

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

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

Line 33:  Line 38:  
The implementation of <hask>select''</hask> makes clear that <hask>select</hask> can be considered as nested <hask>if</hask>s. 
The implementation of <hask>select''</hask> makes clear that <hask>select</hask> can be considered as nested <hask>if</hask>s. 

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

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

<haskell> 
<haskell> 

−  data SelectBranch a = (:>) { 
+  if' cond1 ex1 $ 
−  condition :: Bool, 
+  if' cond2 ex2 $ 
−  expression :: a 
+  if' cond3 ex3 $ 
−  } 
+  exDefault 
−  
−  select :: a > [SelectBranch a] > a 

−  select def = maybe def expression . List.find condition 

−  
−  
−  select exDefault 

−  [cond1 :> ex1, 

−  cond2 :> ex2, 

−  cond3 :> ex3] 

</haskell> 
</haskell> 

−  It is also possible to define a ternary operator '?' like in C. 
+  ==== infix operator ==== 
−  Because of partial application it will work nicely together with 

−  '$' for the else clause. 

+  If you use <hask>if'</hask> in infix form, 

+  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> 
<haskell> 

infixl 1 ? 
infixl 1 ? 

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

−  True ? v = const v 
+  (?) = if' 
−  False ? _ = id 

cond1 ? ex1 $ 
cond1 ? ex1 $ 

cond2 ? ex2 $ 
cond2 ? ex2 $ 

−  cond3 ? ex3 $ exDefault 
+  cond3 ? ex3 $ 
+  exDefault 

+  </haskell> 

+  
+  === Using syntactic sugar === 

+  
+  ==== Guards ==== 

+  
+  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> 
</haskell> 

+  [[Category:FAQ]] 

[[Category:Idioms]] 
[[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 ]