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