View source for Reference card

== General Syntax ==

=== Comments ===

   {- A multiline comment
      which can continue for many lines
   -}

   -- a single line comment

=== Conditionals ===

==== if ====

  if conditional then truePart else falsePart
  if a == 12 then 14 else 22

==== case ====

  case exp of
      Pattern1  -> action1
      Pattern2  -> action2
      _         -> else_action

  case x of
      []  -> 0
      [x] -> 1
      _   -> -1

==== Function pattern matching ====

  f [ ] = 0
  f [x] = 1
  f _   = -1

==== Function conditionals (guards) ====

  f x | x == []        = 1
      | length x == 12 = 15
      | otherwise      = -1

=== Saving work ===

==== where ====

  f x = i * i
      where i = g x

==== let in ====

  f x = let i = g x
        in i * i

=== Declaring types ===

==== data ====

  data List = Cons Int List
            | Nil
            deriving (Eq, Show, Ord)

==== type (type synonymns) ====

  type String = [Char]
  type Name = TypeValue

==== class ====

  class Check a where
      test :: a -> Bool
      force :: a -> a

==== instance ====

  instance Show List where
      show x = "No show"

=== Calling functions ===

==== Named functions ====

  myFunc :: Int -> Int -> Int
  result = myFunc 1 2
  result = 1 `myFunc` 2
  result = (myFunc 1) 2
  result = (`myFunc` 2) 1

==== Operators (and sections) ====

  (+) :: Int -> Int -> Int
  result = 1 + 2
  result = (+) 1 2
  result = (1 +) 2
  result = (+ 2) 1

==== Useful functions ====

  myFunc 1 2 == (flip myFunc) 2 1
  (f . g) x == f (g x)
  f (a+b) == f $ a+b

==== Lambda Expressions ====

  myFunc = (\ a b -> a + b)
  result = map (\x -> head x) xs

=== List Expressions ===

==== .. ====

  [1..] = [1,2,3,4,5,6...
  [1..5] = [1,2,3,4,5]
  [1,3..5] = [1,3,5]

==== List Comprehensions ====

  [ x*x | x <- [1..3] ] ==> [1,4,9]
  [ (x, y) | x <- [1..3], y <- "ab"] ==> 
     [(1,'a'),(1,'b'),(2,'a'),(2,'b'),(3,'a'),(3,'b')]
  [ (x,y) | x <- [1..4], even x, y <- "ab" ] ==>
     [(2,'a'),(2,'b'),(4,'a'),(4,'b')]
  map f xs ==> [ f x | x <- xs ]
  filter p xs ==> [ x | x <- xs, p x ]

----

== Hello World ==

main = putStrLn "Hello World"

----

== Snippets ==



=== fst3 :: (a, b, c) -> a ===

  snd3 :: (a, b, c) -> b
  thd3 :: (a, b, c) -> c

  fst3 (x,_,_) = x
  snd3 (_,x,_) = x
  thd3 (_,_,x) = x


=== ordPair :: Ord a => a -> a -> (a, a) ===

  ordPair x y = if x < y then (x, y) else (y, x)

=== lenXX# :: [a] -> Bool ===

  lenEq0 = null
  lenNe0 = not . null

  lenEq1 [x] = True
  lenEq1  _  = False

  lenGt1 [x] = False
  lenGt1 [ ] = False
  lenGt1  _  = True

=== sortUnique :: Ord a => [a] -> [a] ===

  sortUnique []  = []
  sortUnique [x] = [x]
  sortUnique xs = mergeUnique (sortUnique a) (sortUnique b)
      where (a,b) = split xs

=== split :: [a] -> ([a], [a]) ===

  split []  = ([], [])
  split [a] = ([a], [])
  split (a:b:xs) = (a:as, b:bs)
      where (as,bs) = split xs


=== mergeUnique :: Ord a => [a] -> [a] -> [a] ===

Precondition:
  isUnique(#1) && isUnique(#2)

  mergeUnique a  [] = a
  mergeUnique [] b  = b
  mergeUnique (a:as) (b:bs) =
      case compare a b of
          EQ -> a: mergeUnique as bs
          LT -> a: mergeUnique as (b:bs)
          GT -> b: mergeUnique (a:as) bs

  fix :: Eq a => (a -> a) -> a -> a

  fix f x = if x == x' then x else fix f x'
      where x' = f x

----

== Command lines ==

=== For hmake ===

  hmake Test
  hmake -realclean Test

Where Test is the name of the executable you want to build, i.e. where Test.hs contains the main function.

=== For ghc --make ===

  ghc --make MainModule.hs -o ModuleExec
  ghc --make Module.hs

Where ModuleExec is the name of the output binary you want to make (if main is exported). Module.o will be output for Module.hs, if main is not exported.

=== Others ===

  runhaskell Test.hs

  echo main | ghci -v0 Test.hs

=== #! notation ===   

You can also just make single Haskell main modules executable, using a
combination of runhaskell and #! notation:

  #!/usr/bin/env runhaskell
  main = putStrLn "hello"

Save this to a .hs file and then make this file executable:

   chmod +x Test.hs

You can now execute this as a normal `script' file:

  $ ./Test.hs 
  hello

[[Category:Language]]