A Haskell tutorial

[NB. Notes incomplete, to be written up. Some surprising things jotted below, but needing substantial reorganisation. Better to post than moulder.]
Notes on infix. All functions have infix precedence; those that are in fact infix are characters only.

read show fromIntegral



Type defaulting: The type variable a appears in no other constraints; All the classes Ci are standard. At least one of the classes Ci is numeric.


error, trace

http://www.haskell.org/haskellwiki/Hoogle Install

learn precedence: (eg : has low prec, so () in fn defs, but no 

with, let

whitespace, {}

removeNonUppercase :: [Char] -> [Char]  only as a block on its own

ghci> [ x | x <- [10..20], x /= 13, x /= 15, x /= 19]  

String = [Char]


Useful operators. on, $ for precedence and to map values over functions, 

reverse' = foldl (flip (:)) [] 
append xs ys = foldr (:) ys xs
myMap f xs = foldr step [] xs
    where step x ys = f x : ys
myFoldl f z xs = foldr step id xs z
    where step x g a = g (f a x)

.:
fn = ceiling . negate . tan . cos . max 50  

ghci> map ($ 3) [(4+), (10*), (^2), sqrt]  

scan and fold

evaluation operator, real TCO w/ foldl', thunks as the implementation
MaybeS a = NothingS | JustS !a mean that JustS *thunk* is not allowed
strictness of functions and evaluation calls
http://en.wikibooks.org/wiki/Haskell/Laziness
strictness of functions in dealing with their arguments, ie f strict iff f bottom = bottom
Prelude> let f ~(x,y) = 1
Prelude> f undefined
f $! x = x `seq` f x


(application) 10
infixr 9  .
infixr 8  ^, ^^, **
infixl 7  *, /, `quot`, `rem`, `div`, `mod`
infixl 6  +, -
infixr 5  :
infix  4  ==, /=, <, <=, >=, >
infixr 3  &&
infixr 2  ||
infixl 1  >>, >>=
infixr 1  =<<
infixr 0  $, $!, `seq`

infixl 9  !!
infixr 5  ++
infix  4  `elem`, `notElem`



import Data.List; ghci> :m + Data.List Data.Map Data.Set  

data Shape = Circle Float Float Float | Rectangle Float Float Float Float deriving (Show)  

data Person = Person { firstName :: String  
                     , lastName :: String  
                     , age :: Int  
                     , height :: Float  
                     , phoneNumber :: String  
                     , flavor :: String  
                     } deriving (Show)   automatically creates functions firstName
ghci> Car {company="Ford", model="Mustang", year=1967}  
polymorphic adt: data Maybe a = Nothing | Just a deriving(Ord) in order declared, Show, Read, Eq
type String = [Char] 
Either

typeclasses. Functor. kinds

putStrLn, print, return, do, <-, IO, mapM_?, getLine/getContents/hGetContents, getArgs/getProgName


import System.Environment   
import System.Directory  
import System.IO  
import Data.List  
  
dispatch :: [(String, [String] -> IO ())]  
dispatch =  [ ("add", add)  
            , ("view", view)  
            , ("remove", remove)  
            ]  
   
main = do  
    (command:args) <- getArgs  
    let (Just action) = lookup command dispatch  
    action args  
  
add :: [String] -> IO ()  
add [fileName, todoItem] = appendFile fileName (todoItem ++ "\n")  
  
view :: [String] -> IO ()  
view [fileName] = do  
    contents <- readFile fileName  
    let todoTasks = lines contents  
        numberedTasks = zipWith (\n line -> show n ++ " - " ++ line) [0..] todoTasks  
    putStr $ unlines numberedTasks  
  
remove :: [String] -> IO ()  
remove [fileName, numberString] = do  
    handle <- openFile fileName ReadMode  
    (tempName, tempHandle) <- openTempFile "." "temp"  
    contents <- hGetContents handle  
    let number = read numberString  
        todoTasks = lines contents  
        newTodoItems = delete (todoTasks !! number) todoTasks  
    hPutStr tempHandle $ unlines newTodoItems  
    hClose handle  
    hClose tempHandle  
    removeFile fileName  
    renameFile tempName fileName  

Exceptions: only in IO because evaluation is stateful

a = do x <- [3..4]
       [1..2]
       return (x, 42)
is transformed during compilation into:
a = [3..4] >>= (\x -> [1..2] >>= (\_ -> return (x, 42)))

x // y = do
  a <- x  -- Extract the values "inside" x and y, if there are any.
  b <- y
  if b == 0 then Nothing else Just (a / b)
 
x // y = x >>= (\a -> y >>= (\b -> if b == 0 then Nothing else Just (a / b)))

http://www.haskell.org/arrows/index.html