All Haskell values have a type:

char='a'::Charint=123::Intfun=isDigit::Char->Bool

You have to pass the right type of values to functions, or the compiler will reject the program:

isDigit1

You can decode bytes into text:

bytes=Crypto.Hash.SHA1.hash"hello"::ByteStringtext=decodeUtf8bytes::Text

But you cannot decode Text, which is already a vector of Unicode points:

doubleDecode=decodeUtf8(decodeUtf8bytes)

The following function takes an integer and returns an integer. By the type it cannot do any side-effects whatsoever, it cannot mutate any of its arguments.

square::Int->Intsquarex=x*x

The following string concatenation is okay:

"Hello: "++"World!"

The following string concatenation is a type error:

"Name: "++getLine

Because getLine has type IO String and not String, like "Name: " is. So by the type system you cannot mix and match purity with impurity.

This example has a type signature for every binding:

main::IO()main=doline::String<-getLineprint(parseDigitline)whereparseDigit::String->MaybeIntparseDigit((c::Char):_)=ifisDigitcthenJust(ordc-ord'0')elseNothing

But you can just write:

main=doline<-getLineprint(parseDigitline)whereparseDigit(c:_)=ifisDigitcthenJust(ordc-ord'0')elseNothing

You can also use inference to avoid wasting time explaining what you want:

doss<-decode"[\"Hello!\",\"World!\"]"is<-decode"[1,2,3]"return(zipWith(\si->s++" "++show(i+5))ssis)=>Just["Hello! 6","World! 7"]

Types give a parser specification for free, the following input is not accepted:

doss<-decode"[1,2,3]"is<-decode"[null,null,null]"return(zipWith(\si->s++" "++show(i+5))ssis)=>Nothing

Easily launch threads and communicate with the standard library:

main=dodone<-newEmptyMVarforkIO(doputStrLn"I'm one thread!"putMVardone"Done!")second<-forkIO(dothreadDelay100000putStrLn"I'm another thread!")killThreadsecondmsg<-takeMVardoneputStrLnmsg

Use an asynchronous API for threads:

doa1<-async(getURLurl1)a2<-async(getURLurl2)page1<-waita1page2<-waita2...

Atomic threading with software transactional memory:

transfer::Account->Account->Int->IO()transferfromtoamount=atomically(dodeposittoamountwithdrawfromamount)

Atomic transactions must be repeatable, so arbitrary IO is disabled in the type system:

main=atomically(putStrLn"Hello!")

Define control structures easily:

whenpm=ifpthenmelsereturn()main=doargs<-getArgswhen(nullargs)(putStrLn"No args specified!")

If you notice a repeated expression pattern, like

ifcthentelseFalse

you can give this a name, like

andct=ifcthentelseFalse

and then use it with the same effect as the original expression.

Get code re-use by composing lazy functions. It's quite natural to express the any function by reusing the map and or functions:

any::(a->Bool)->[a]->Boolanyp=or.mapp

Reuse the recursion patterns in map, filter, foldr, etc.

There are 6,954 packages freely available. Here is a sample of the most common ones: