# Declaration vs. expression style

### From HaskellWiki

(Difference between revisions)

(introduction) |
(Add table borders) |
||

Line 2: | Line 2: | ||

which are both supported by Haskell mainly because several language designers preferred these different styles. |
which are both supported by Haskell mainly because several language designers preferred these different styles. |
||

− | In the '''declaration style''' you formulate an algorithm in terms of several equations that shall be satisfied. |
+ | In the '''declaration style''' you formulate an algorithm in terms of several equations that shall be satisfied.<br> |

In the '''expression style''' you compose big expressions from small expressions. |
In the '''expression style''' you compose big expressions from small expressions. |
||

Line 41: | Line 41: | ||

There are characteristic elements of both styles. |
There are characteristic elements of both styles. |
||

− | {| |
+ | {| cellpadding="4" cellspacing="0" border="3" style="color:blue" |

− | | '''Declaration style''' || || '''Expression-style''' || |
+ | ! style="color:black" colspan="2"|Declaration style |

− | |- |
+ | ! style="color:black" colspan="2"|Expression-style |

− | | <hask>where</hask> clause || || <hask>let</hask> expression || |
+ | |- style="color:black" |

− | |- |
+ | | colspan="2"| <hask>where</hask> clause |

+ | | colspan="2"| <hask>let</hask> expression |
||

+ | |- style="color:black" |
||

| Function arguments on left hand side: || <hask>f x = x*x</hask> || [[Lambda abstraction]]: || <hask>f = \x -> x*x</hask> |
| Function arguments on left hand side: || <hask>f x = x*x</hask> || [[Lambda abstraction]]: || <hask>f = \x -> x*x</hask> |
||

− | |- |
+ | |- style="color:black" |

| [[Pattern matching]] in function definitions: || <hask>f [] = 0</hask> || <hask>case</hask> expression: || <hask>f xs = case xs of [] -> 0</hask> |
| [[Pattern matching]] in function definitions: || <hask>f [] = 0</hask> || <hask>case</hask> expression: || <hask>f xs = case xs of [] -> 0</hask> |
||

− | |- |
+ | |- style="color:black" |

| [[Guard]]s on function definitions: || <hask>f [x] | x>0 = 'a'</hask> || <hask>if</hask> expression: || <hask>f [x] = if x>0 then 'a' else ...</hask> |
| [[Guard]]s on function definitions: || <hask>f [x] | x>0 = 'a'</hask> || <hask>if</hask> expression: || <hask>f [x] = if x>0 then 'a' else ...</hask> |
||

|} |
|} |
||

Line 55: | Line 55: | ||

== See also == |
== See also == |
||

− | * http://research.microsoft.com/~simonpj/papers/history-of-haskell/ |
+ | * http://research.microsoft.com/~simonpj/papers/history-of-haskell/ section 4.4 |

[[Category:Style]] |
[[Category:Style]] |

## Revision as of 00:25, 23 August 2008

There are two main styles of writing functional programs, which are both supported by Haskell mainly because several language designers preferred these different styles.

In the **declaration style** you formulate an algorithm in terms of several equations that shall be satisfied.

In the **expression style** you compose big expressions from small expressions.

## Contents |

## 1 Comparison

As illustration for the two styles, Simon Peyton Jones give two implementations of the Prelude functionfilter

filter :: (a -> Bool) -> [a] -> [a]

### 1.1 Declaration style

filter p [] = [] filter p (x:xs) | p x = x : rest | otherwise = rest where rest = filter p xs

### 1.2 Expression style

filter = \p -> \ xs -> case xs of [] -> [] (x:xs) -> let rest = filter p xs in if p x then x : rest else rest

## 2 Syntactic elements

There are characteristic elements of both styles.

Declaration style | Expression-style | ||
---|---|---|---|

where |
let | ||

Function arguments on left hand side: | f x = x*x |
Lambda abstraction: | f = \x -> x*x |

Pattern matching in function definitions: | f [] = 0 |
case |
f xs = case xs of [] -> 0 |

Guards on function definitions: | f [x] | x>0 = 'a' |
if |
f [x] = if x>0 then 'a' else ... |