# Declaration vs. expression style

### From HaskellWiki

(Difference between revisions)

(taken table from "History of Haskell") |
(Add link to Let vs. Where and History of Haskell pages) |

(3 intermediate revisions by 2 users not shown) |

## Latest revision as of 00:41, 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 |

## [edit] 1 Comparison

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

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

### [edit] 1.1 Declaration style

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

### [edit] 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

## [edit] 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 ... |

## [edit] 3 See also

- Let vs. Where
- History of Haskell (in section 4.4)