diff options
Diffstat (limited to 'haskell.html.markdown')
| -rw-r--r-- | haskell.html.markdown | 68 |
1 files changed, 30 insertions, 38 deletions
diff --git a/haskell.html.markdown b/haskell.html.markdown index 5ffc63f3..a5a6117f 100644 --- a/haskell.html.markdown +++ b/haskell.html.markdown @@ -50,10 +50,10 @@ not False -- True 'You cant use single quotes for strings.' -- error! -- Strings can be added too! -"Hello " ++ "world!" #=> "Hello world!" +"Hello " ++ "world!" -- "Hello world!" -- A string can be treated like a list of characters -"This is a string" !! 0 #=> 'T' +"This is a string" !! 0 -- 'T' ---------------------------------------------------- @@ -75,11 +75,9 @@ not False -- True 0:[1..5] -- [0, 1, 2, 3, 4, 5] -- indexing into a list - [0..] !! 5 -- 4 -- more list operations - head [1..5] -- 1 tail [1..5] -- [2, 3, 4, 5] init [1..5] -- [1, 2, 3, 4] @@ -89,7 +87,7 @@ last [1..5] -- 5 [x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] -- with a conditional -[x*2 | x <- [1..5], x*2 > 4] # [6, 8, 10] +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] -- Every element in a tuple can be a different type, but a tuple has a fixed length. -- A tuple: @@ -112,9 +110,7 @@ add 1 2 -- 3 1 `add` 2 -- 3 -- You can also define functions that have no characters! This lets you define --- your own operators: - --- Here's an operator that does integer division +-- your own operators! Here's an operator that does integer division (//) a b = a `div` b 35 // 4 -- 8 @@ -123,20 +119,19 @@ fib x | x < 2 = x | otherwise = fib (x - 1) + fib (x - 2) --- You can do the same thing with pattern matching. +-- Pattern matching is similar. Here we have given three different +-- definitions for fib. Haskell will automatically call the first +-- function that matches the pattern of the value. fib 1 = 1 fib 2 = 2 fib x = fib (x - 1) + fib (x - 2) --- So we have given three different definitions for fib. --- Haskell will automatically call the first function that matches --- the pattern of the value. - -- Pattern matching on tuples: foo (x, y) = (x + 1, y + 2) -- Pattern matching on arrays. Here `x` is the first element --- in the array, and `xs` is the rest of the array: +-- in the array, and `xs` is the rest of the array. We can write +-- our own map function: map func [x] = [func x] map func (x:xs) = func x:(map func xs) @@ -149,12 +144,12 @@ map (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] foldl1 (\acc x -> acc + x) [1..5] -- 15 ---------------------------------------------------- --- 4. Some fancy things you can do with functions +-- 4. More functions ---------------------------------------------------- -- currying: if you don't pass in all the arguments to a function, -it gets "curried". That means it returns a function that takes the -rest of the arguments. +-- it gets "curried". That means it returns a function that takes the +-- rest of the arguments. add a b = a + b foo = add 10 -- foo is now a function that takes a number and adds 10 to it @@ -165,10 +160,9 @@ foo = (+10) foo 5 -- 15 -- function composition -the (.) function chains functions together. -For example, here foo is a function that takes a value. It adds 10 to it, -multiplies the result of that by 5, and then returns the final value. - +-- the (.) function chains functions together. +-- For example, here foo is a function that takes a value. It adds 10 to it, +-- multiplies the result of that by 5, and then returns the final value. foo = (*5) . (+10) -- (5 + 10) * 5 = 75 @@ -176,9 +170,9 @@ foo 5 -- 75 -- fixing precedence -- Haskell has another function called `$`. This changes the precedence -so that everything to the left of it gets computed first and then applied -to everything on the right. You can use `.` and `$` to get rid of a lot -of parentheses: +-- so that everything to the left of it gets computed first and then applied +-- to everything on the right. You can use `.` and `$` to get rid of a lot +-- of parentheses: -- before (even (double 7)) -- true @@ -190,18 +184,18 @@ even . double $ 7 -- true -- 5. Type signatures ---------------------------------------------------- -Haskell has a very strong type system, and everything has a type signature. +-- Haskell has a very strong type system, and everything has a type signature. -Some basic types: +-- Some basic types: 5 :: Integer "hello" :: String True :: Bool -Functions have types too. -Not takes a boolean and returns a boolean: +-- Functions have types too. +-- `not` takes a boolean and returns a boolean: not :: Bool -> Bool -Here's a function that takes two arguments: +-- Here's a function that takes two arguments: add :: Integer -> Integer -> Integer ---------------------------------------------------- @@ -216,19 +210,13 @@ haskell = if 1 == 1 then "awesome" else "awful" --- case statements - --- Here's how you could parse command line arguments in Haskell - +-- case statements: Here's how you could parse command line arguments in Haskell case args of "help" -> printHelp "start" -> startProgram _ -> putStrLn "bad args" - --- loops: recursion -- Haskell doesn't have loops because it uses recursion instead. - -- map a function over every element in an array map (*2) [1..5] -- [2, 4, 6, 8, 10] @@ -237,8 +225,10 @@ map (*2) [1..5] -- [2, 4, 6, 8, 10] for array func = map func array -- and then use it +for [0..5] $ \i -> show i -for [0..5] $ \i -> print i +-- we could've written that like this too: +for [0..5] show ---------------------------------------------------- -- 7. Data Types @@ -248,7 +238,7 @@ for [0..5] $ \i -> print i data Color = Red | Blue | Green -Now you can use it in a function: +-- Now you can use it in a function: say :: Color -> IO String say Red = putStrLn "You are Red!" @@ -288,3 +278,5 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater where lesser = filter (< p) xs greater = filter (>= p) xs ``` + +Haskell is easy to install. Get it [here](http://www.haskell.org/platform/). |