merging in new pointer section from origin

3 files changed, 306 insertions, 9 deletions

diff --git a/c.html.markdown b/c.html.markdown
index e5a6520f..78083ea5 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -216,28 +216,43 @@ printf("%d\n", (char)100.0);
 // Pointers
 ///////////////////////////////////////
 
-// You can retrieve the memory addresses of your variables and perform
-// operations on them.
+// A pointer is a variable declared to store a memory address. Its declaration will
+// also tell you the type of data it points to. You can retrieve the memory address 
+// of your variables, then mess with them.
 
 int x = 0;
 printf("%p\n", &x); // Use & to retrieve the address of a variable
 // (%p formats a pointer)
 // => Prints some address in memory;
 
-int x_array[20]; // Arrays are a good way to allocate a contiguous block 
-                 // of memory
+// Pointer types end with * in their declaration
+int* px; // px is a pointer to an int
+px = &x; // Stores the address of x in px
+printf("%p\n", px); // => Prints some address in memory
+
+// To retreive the value at the address a pointer is pointing to,
+// put * in front to de-reference it.
+printf("%d\n", *px); // => Prints 0, the value of x, which is what px is pointing to the address of
+
+// You can also change the value the pointer is pointing to.
+// We'll have to wrap the de-reference in parenthesis because
+// ++ has a higher precedence than *.
+(*px)++; // Increment the value px is pointing to by 1
+printf("%d\n", *px); // => Prints 1
+printf("%d\n", x); // => Prints 1
+
+int x_array[20]; // Arrays are a good way to allocate a contiguous block of memory
 int xx;
 for (xx=0; xx<20; xx++) {
     x_array[xx] = 20 - xx;
 } // Initialize x_array to 20, 19, 18,... 2, 1
 
-// Pointer types end with *
+// Declare a pointer of type int and initialize it to point to x_array
 int* x_ptr = x_array;
 // x_ptr now points to the first element in the array (the integer 20). 
 // This works because arrays are actually just pointers to their first element.
 
-// Put a * in front to de-reference a pointer and retrieve the value,
-// of the same type as the pointer, that the pointer is pointing at.
+// Arrays are pointers to their first element
 printf("%d\n", *(x_ptr)); // => Prints 20
 printf("%d\n", x_array[0]); // => Prints 20
 
diff --git a/haskell.html.markdown b/haskell.html.markdown
new file mode 100644
index 00000000..a5a6117f
--- /dev/null
+++ b/haskell.html.markdown
@@ -0,0 +1,282 @@
+---
+language: haskell
+author: Adit Bhargava
+author_url: http://adit.io
+---
+
+Haskell was designed as a practical, purely functional programming language. It's famous for
+it's monads and it's type system, but I keep coming back to it because of it's elegance. Haskell
+makes coding a real joy for me.
+
+```haskell
+-- Single line comments start with two dashes.
+{- Multiline comments can be enclosed
+in a block like this.
+-}
+
+----------------------------------------------------
+-- 1. Primitive Datatypes and Operators
+----------------------------------------------------
+
+-- You have numbers
+3 -- 3
+
+-- Math is what you would expect
+1 + 1 -- 2
+8 - 1 -- 7
+10 * 2 -- 20
+35 / 5 -- 7.0
+
+-- Division is not integer division by default
+35 / 4 -- 8.75
+
+-- integer division
+35 `div` 4 -- 8
+
+-- Boolean values are primitives
+True
+False
+
+-- Boolean operations
+not True -- False
+not False -- True
+1 == 1 -- True
+1 /= 1 -- False
+1 < 10 -- True
+
+-- Strings and characters
+"This is a string."
+'a' -- character
+'You cant use single quotes for strings.' -- error!
+
+-- Strings can be added too!
+"Hello " ++ "world!" -- "Hello world!"
+
+-- A string can be treated like a list of characters
+"This is a string" !! 0 -- 'T'
+
+
+----------------------------------------------------
+-- Lists and Tuples
+----------------------------------------------------
+
+-- Every element in a list must have the same type.
+-- Two lists that are the same
+[1, 2, 3, 4, 5]
+[1..5]
+
+-- You can also have infinite lists in Haskell!
+[1..] -- a list of all the natural numbers
+
+-- joining two lists
+[1..5] ++ [6..10]
+
+-- adding to the head of a list
+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]
+last [1..5] -- 5
+
+-- list comprehensions
+[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
+
+-- with a conditional
+[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:
+("haskell", 1)
+
+-- accessing elements of a tuple
+fst ("haskell", 1) -- "haskell"
+snd ("haskell", 1) -- 1
+
+----------------------------------------------------
+-- 3. Functions
+----------------------------------------------------
+-- A simple function that takes two variables
+add a b = a + b
+
+-- Using the function
+add 1 2 -- 3
+
+-- You can also put the function name between the two arguments with backticks:
+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
+(//) a b = a `div` b
+35 // 4 -- 8
+
+-- Guards: an easy way to do branching in functions
+fib x
+  | x < 2 = x
+  | otherwise = fib (x - 1) + fib (x - 2)
+
+-- 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)
+
+-- 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. We can write
+-- our own map function:
+map func [x] = [func x]
+map func (x:xs) = func x:(map func xs)
+
+-- Anonymous functions are created with a backslash followed by all the arguments.
+map (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
+
+-- using fold (called `inject` in some languages) with an anonymous function.
+-- foldl1 means fold left, and use the first value in the array as the initial
+-- value for the accumulator.
+foldl1 (\acc x -> acc + x) [1..5] -- 15
+
+----------------------------------------------------
+-- 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.
+
+add a b = a + b
+foo = add 10 -- foo is now a function that takes a number and adds 10 to it
+foo 5 -- 15
+
+-- Another way to write the same thing
+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.
+foo = (*5) . (+10)
+
+-- (5 + 10) * 5 = 75
+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:
+
+-- before
+(even (double 7)) -- true
+
+-- after
+even . double $ 7 -- true
+
+----------------------------------------------------
+-- 5. Type signatures
+----------------------------------------------------
+
+-- Haskell has a very strong type system, and everything has a type signature.
+
+-- Some basic types:
+5 :: Integer
+"hello" :: String
+True :: Bool
+
+-- Functions have types too.
+-- `not` takes a boolean and returns a boolean:
+not :: Bool -> Bool
+
+-- Here's a function that takes two arguments:
+add :: Integer -> Integer -> Integer
+
+----------------------------------------------------
+-- 6. Control Flow
+----------------------------------------------------
+
+-- if statements
+haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+
+-- if statements can be on multiple lines too, indentation is important
+haskell = if 1 == 1
+            then "awesome"
+            else "awful"
+
+-- case statements: Here's how you could parse command line arguments in Haskell 
+case args of
+  "help" -> printHelp
+  "start" -> startProgram
+  _ -> putStrLn "bad args"
+
+-- 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]
+
+-- you can make a for function using map
+for array func = map func array
+
+-- and then use it
+for [0..5] $ \i -> show i
+
+-- we could've written that like this too:
+for [0..5] show
+
+----------------------------------------------------
+-- 7. Data Types
+----------------------------------------------------
+
+-- Here's how you make your own data type in Haskell
+
+data Color = Red | Blue | Green
+
+-- Now you can use it in a function:
+
+say :: Color -> IO String
+say Red = putStrLn "You are Red!"
+say Blue = putStrLn "You are Blue!"
+say Green = putStrLn "You are Green!"
+
+-- Your data types can have parameters too:
+
+data Maybe a = Nothing | Just a
+
+-- These are all of type Maybe
+Nothing
+Just "hello"
+Just 1
+
+----------------------------------------------------
+-- 8. The Haskell REPL
+----------------------------------------------------
+
+-- Start the repl by typing `ghci`.
+-- Now you can type in Haskell code. Any new values
+-- need to be created with `let`:
+
+let foo = 5
+
+-- You can see the type of any value with `:t`:
+
+>:t foo
+foo :: Integer
+```
+
+There's a lot more to Haskell, including typeclasses and monads. These are the big ideas that make Haskell such fun to code in. I'll leave you with one final Haskell example: an implementation of quicksort in Haskell:
+
+```haskell
+qsort [] = []
+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/).
diff --git a/python.html.markdown b/python.html.markdown
index a17b7645..4cfecbbd 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -34,11 +34,11 @@ to Python 2.x. Look for another tour of Python 3 soon!
 
 # Division is a bit tricky. It is integer division and floors the results
 # automatically.
-11 / 4 #=> 2
+5 / 2 #=> 2
 
 # To fix division we need to learn about floats.
 2.0     # This is a float
-5.0 / 2.0 #=> 2.5 ahhh...much better
+11.0 / 4.0 #=> 2.75 ahhh...much better
 
 # Enforce precedence with parentheses
 (1 + 3) * 2 #=> 8