is the function which maps a number to its square. While we commonly write parenthesis around function arguments in mathematics and most programming languages, a simple space is enough in Haskell. We're going to apply functions to arguments all around, so why clutter the notation with unnecessary ballast?

square ::Int->Int
square x = x*x

Squaring again, this time with a type signature which says that squaring maps integers to integers. In mathematics, we'd write . Every expression in Haskell has a type and the compiler will automatically infer (= figure out) one for you if you're too lazy to write down a type signature yourself. Of course, parenthesis are allowed for grouping, like in

square (4+2)

which is 36 compared to

square 4+2

which is 16+2=18.

square ::Num a => a -> a
square x = x*x

Squaring yet again, this time with a more general type signature. After all, we can square anything (

a

) that looks like a number (

Num a

). By the way, this general type is the one that the compiler will infer for

square

if you omit an explicit signature.

average x y =(x+y)/2

The average of two numbers. Multiple arguments are separated by spaces.

average ::Double->Double->Double
average x y =(x+y)/2

Average again, this time with a type signature. Looks a bit strange, but that's the spicey currying. In fact,

average

is a function that takes only one argument (

Double

) but returns a function with one argument (

Double->Double

).

power a n =if n ==0then1else a * power a (n-1)

an, defined with recursion. Assumes that the exponent

n

is not negative, that is

n >=0

.

Recursion is the basic building block for iteration in Haskell, there are no for or while-loops. Well, there are functions like

map

or

foldr

that provide something similar. There is no need for special built-in control structures, you can define them yourself as ordinary functions (later).

power a 0=1
power a n = a * power a (n-1)

Exponentiation again, this time with pattern matching. The first equation that matches will be chosen.

length[]=0length(x:xs)=1+length xs

Calculate the length of a list. What's a list? Well, a list may either be empty (

To find the least element of a list, first sort and then take the first element. You think that takes too much time ( instead of O(n))? Well, thanks to lazy evaluation, it doesn't! In Haskell, expressions are evaluated only as much as needed. Therefore, the sorting won't proceed further than producing the first element of the sorted list. Ok, the sorting function has to play along and produce that one quickly, but many like quicksort (in the average case) or mergesort do so.

sum=foldr(+)0product=foldr(*)1concat=foldr(++)[]

Tired of implementing a recursive function every time you're traversing a list? No need for that,

fold

captures the recursion, you just tell it how to combine the list elements. It's defined as