Difference between revisions of "Reference card"
From HaskellWiki
DonStewart (talk  contribs) m (Add some more ways of running haskell from the command line) 
m (s/x/a/ in (y, a)) 

(4 intermediate revisions by 3 users not shown)  
Line 135:  Line 135:  
−  === fst3 :: ( 
+  === fst3 :: (a, b, c) > a === 
−  snd3 :: ( 
+  snd3 :: (a, b, c) > b 
−  thd3 :: ( 
+  thd3 :: (a, b, c) > c 
fst3 (x,_,_) = x 
fst3 (x,_,_) = x 

Line 145:  Line 145:  
−  === ordPair :: Ord 
+  === ordPair :: Ord a => a > a > (a, a) === 
−  ordPair 
+  ordPair x y = if x < y then (x, y) else (y, x) 
−  === lenXX# :: [ 
+  === lenXX# :: [a] > Bool === 
−  lenEq0 
+  lenEq0 = null 
−  lenNe0 
+  lenNe0 = not . null 
lenEq1 [x] = True 
lenEq1 [x] = True 

Line 189:  Line 189:  
GT > b: mergeUnique (a:as) bs 
GT > b: mergeUnique (a:as) bs 

−  fix :: Eq 
+  fix :: Eq a => (a > a) > a > a 
fix f x = if x == x' then x else fix f x' 
fix f x = if x == x' then x else fix f x' 

Line 221:  Line 221:  
You can also just make single Haskell main modules executable, using a 
You can also just make single Haskell main modules executable, using a 

−  combination of runhaskell 
+  combination of runhaskell and #! notation: 
#!/usr/bin/env runhaskell 
#!/usr/bin/env runhaskell 

−  +  main = putStrLn "hello" 

−  Save this to a . 
+  Save this to a .hs file and then make this file executable: 
−  chmod +x Test. 
+  chmod +x Test.hs 
You can now execute this as a normal `script' file: 
You can now execute this as a normal `script' file: 

−  $ ./Test. 
+  $ ./Test.hs 
hello 
hello 

+  
+  [[Category:Language]] 
Latest revision as of 07:04, 18 April 2008
Contents
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