These are some examples for haskell syntax with concise explanations. If you are a real fp ninja you might be able to learn haskell by reading this, but it is targeted to haskell learners, who read a tutorial or book like LYAH and need a reference card to remember the syntax and some patterns. You can load it into ghci and run examles and check type signatures.

 - This is a block comment.
 - One line comments start with -- 

Module Definition

A module definition has a name andd optionally lists everything you want to export in braces.

module Cheatsheet

Export types with a list of constructors or export all contructors.

  ( Recsam(Recsam)
  , Datasam(..)

You can export all values and even reexport imports withmodule here. The module definition ends with the where keyword.

  , datasam
  , module Control.Monad
  ) where


Imports load other modules into our scope. Sometimes you have to import submodules too.

import Control.Monad
import Control.Monad.Reader

You can decide to only load some functions. Instances and typeclasses are loaded anyways.

import Data.Function (on)

The qualified hides the non prefixed versions and as renames the prefix. If you want to define own versions of Prelude functions you can use hiding.

import qualified Data.Char as C (ord, chr)
import Prelude hiding (gcd)


A class resembles interfaces and abstract classes of OOP. This one "extends" Num. Classes list the types of functions to provide using a type variable. Classes may include default implementations.

class (Num a) => Classam a where
	classam :: a -> Bool
	classam = const False


The data keyword allows definition of algebraic data types. They can derive Eq, Ord, Enum, Bounded, Show, Read for some convenient instances.

Datas can have type variables and be recursive.

data Datasam = A | B | C
  deriving Show

data Datarecsam a = End a | Recur (Datarecsam a)

You construct datas using their constructor functions. They can be used like normal functions.

datasam = A

datarecsam :: [Datarecsam Int]
datarecsam = Recur (End 2) : map (Recur . Recur . End) [3..5]

You can make datas instances with a header similar to the class definition. You do not always have to define all methods. With this definition we can print the above list like [>2,>>3,>>4,>>5] The values are extracted with pattern matching.

instance Show a => Show (Datarecsam a) where
	show (End x) = show x
	show (Recur xs) = '>': show xs

Record Syntax

The use of the record syntax ist defining algebraic data types giving meaningful names to their members.

data Recsam = Recsam { name :: String
                     , hidden :: Bool
                     } deriving Show

Reocrd syntax enables easy constructing. Note the = in place of ::.

recsam = Recsam { name = "Example", hidden = True }

The fields of a record are at the same time getter functions.

recsamName = name recsam

You can pattern match againts a record. If you type assertShown recsam in ghci you get the error.

assertShown Recsam { hidden = True } = error "Not shown"
assertShown _ = ()

You can use records to build derivates. If you type assertShown recsam' there's no error.

recsam' = recsam { hidden = False }


Newtypes are similar to a type alias, they carry own instances even using deriving and can be defined using record syntax, but are limited to a single field.

newtype Ntsam = Ntsam [Int]


Type is another alias tool, but only creates a synonyme name and no constructors. It's most prominent use is String for [Char].

type Pair a = (a,a)

Note that you should avoid recursion. The following works however.

type Coords = Pair Int

Special Function Syntax

There are some advanced function building methods. The examples demonstrate referencing of an infix operator, building lambdas with \, partially applying infix operators (sections), using non symbolic functions as infix and defining own infix operators with fixity. They are of questional value here but handy when used right.

add a b = a + b
add' = (+)
add'' = \a b -> a+b
add3 a b = (+a) b
add4 a b = a `add3` b
a +# b = add a b
infixl 9 +#

Pattern matching

There are pattern matchng examples for function definitions in the sections about data and the record syntax. There's more options though. You can use patterns in let, case, lambdas, with <- and where too.

patternsam x y = 
  let (a,b) = (,) x y
  in case a of 3     -> b
               (n+1) -> n

You can pattern match tuples, lists and sums with their syntactic sugar in adition to normal constructors. You can use the @ notation to match a parameter while keeping it intact.

single3 l@[3] = Just l
single3    _  = Nothing

Let & where, if, case & guards

If you just want to check constructors use pattern matching, see above. Sometimes you want to use complex predicates though. You can choose guards. With a where block you can define private functions.

numsam x
       | x < 3     = phrase "small"
       | x < 50    = phrase "medium"
       | otherwise = phrase "huge"
         phrase s = "A "++s++" number!"

A little mothe flexible are let and case because they are expresseions and can be used everywhere as opposed to only in function definitions. A little hack is to case on the unit () only matching the ignore _ pattern thus using only the guards.

numsam' x
  = let phrase s = "A "++s++" number!"
    in case () of
            _ | x < 3     -> phrase "small"
              | x < 50    -> phrase "medium"
              | otherwise -> phrase "huge"

And of course there is if then else working a little like the ternary operator a?b:c in other languages. You can use multiple else if branches but no pattern matching.

numsam'' x = phrase $
              if      x < 3  then "small"
              else if x < 50 then "medium"
              else                "huge"
    where phrase s = "A "++s++" number!"

List comprehensions

An option for filtering and processing lists are list comprehensions. They take multiple input lists, predicates and an output expression.

listcmrsam = [(x,show y) | x <- [0..3], y <- [3..5], x*y < 4]


The above list comprehension can be written in monadic style too.

monsam = [0..3] >>= (\x -> 
  [3..5] >>= (\y -> 
    guard (x*y < 4) >> return (x,show y) ) )


When dealing with monads using the do notation can sometimes be handy albait considered harmful. Inside a do block a failed pattern match will call fail with an exception message.

The first non whitespace char determines the width of indentation.

dosam = do
  x <- [0..3]
  y <- [3..5]
  guard $ x*y < 4
  return (x, show y)


The programm listed here defines a function askNumber to read a number > 3 from user input and then outputs some numbered lines. I try to keep the IO parts as short as possible.

Also interesting for simple I/O are interact, print and System.Environment (getArgs)

main = do
  times <- askNumber
  sequence_ [putStrLn $ "line" ++ show n | n <- [0..times-1]]

askNumber :: IO Int
askNumber = do
  putStrLn "How many?"
  n <- readLn
  if n>3 then return n
    else do
      print "To few!"

Pointfree Style

Here are some patterns for using pointfree style.

For comparing stuff use the on comosition

onsam x y = x*3 + y*3
onsam' = (+) `on` (*3)

If you want to combine functions with arity one and two you can sometimes use the boobs operator.

(.:) = (.).(.)
(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d

Here's an example how to use the boobs operator with Y pipes:

ysam pe c pd= pe .: (c `on` pd) where
tapas = ysam  ('T':) (++) ('a':)  "p" "s"

If you have two different pipes for one input and a combinator you use liftM2.

liftM2sam pe c p1 p2  = pe . liftM2 c p1 p2
tapas' = liftM2sam (++"s") (++) ('T':) ('p':)  "a"

If you just want to clone an argument you can use join.

joinsam = join (+)
fiveDoubled = joinsam 5

If you have two different pipes for two different arguments and a combinator you use composition with a pre applyed function.

applysam c p1 p2 = (. p2) . c . p1
tacos = applysam (++) ("Ta"++) ('o':)  "c" "s"


Here's some useful external references:


This file was written by Bernhard Häussner, you can find and fork the source at github and here's the annotated source code view processed by docco