scott wrote:
> The tutorial was good up until step 7.

Hmm, maybe I should write my own?



 > 2 + 2
That was easy, eh?

 > 2 + 3 * 4
The usual operator precedence rules apply.

 > (2 + 3) * 4
You can override operator precedence manually in the usual way.

 > sqrt 144
This is a function call. (Notice the lack of brackets!)

 > div 10 3
This is a 2-argument function. (Again, notice the lack of any brackets.) 
It performs integer division (i.e., division to the nearest whole number.)

 > 10 / 3
Does the same calculation, but with floating-point arithmetic.

 > 10 `div` 3
This does the same thing as the first one, but it looks more natural. 
The backticks work for any 2-argument function.

 > sin 1 + cos 1
This is sin(1) + cos(2).

 > sin (1 + cos 1)
This does a different calculation.

 > sin -1
This gives an error, because it thinks you mean "sin - 1", which is 
invalid. (Yes, we all think it's very annoying.)

 > sin (-1)
This works properly.

 > "This is a string."

 > 'X'
This is a single character.

 > "X"
This is a string that only contains 1 character.

 > ""
This is an empty string.

 > [8, 3, 11, 2]
This is a list of numbers.

 > ['X', 'Y', 'Z']
This is a list of characters. Note that a string *is* a list of characters!

 > ['X', 3]
A list can contain elements of any type, but all elements must be of 
*the same* type. This example is therefore invalid. (Nice clear error 
message, eh?)

 > sort [8, 3, 11, 2]
 > reverse [8, 3, 11, 2]
 > sum [8, 3, 11, 2]
 > 3 `elem` [8, 3, 11, 2]
 > 4 `elem` [8, 3, 11, 2]
Haskell has many, many list functions.

 > [1, 2, 3] ++ [4, 5, 6]
This joins two lists together.

 > [1..10]
This is a shorthand for writing lists.

 > sum [1..100]
Add up these numbers.

 > product [1..100]
Multiply these numbers. (Notice that even though the answer is huge, 
Haskell computes it exactly.)

 > take 3 [5,4,6,3,7,2,8,1,9]
Get the first 3 elements.

 > drop 3 [5,4,6,3,7,2,8,1,9]
Remove the first 3 elements.

 > [5,4,6,3,7,2,8,1,9] !! 5
Get the 6th element. (The first element is index zero, not index one!)

 > filter odd [5,4,6,3,7,2,8,1,9]
Filter a list according to a condition.

 > filter (> 5) [5,4,6,3,7,2,8,1,9]
Filter with a different condition.

 > map (*2) [5,4,6,3,7,2,8,1,9]
Double all the numbers in the list.

 > map toUpper "This is a string."
Since strings are just lists that contain characters, all list functions 
work on strings.

 > sin
You can't print this out, so you get an error.

 > :t sin
This tells the interpretter to only print the type signature, not 
*execute* the code. (This is an interpretter command, not a Haskell 
command.)

 > (5, 'x')
This is a "tuple". Tuples can contain any number of elements, and they 
can be of different types. Their main use is in returning several 
results from a single function call.

 > partition odd [5,4,6,3,7,2,8,1,9]
This splits the list into two lists, containing odd and not-odd numbers. 
The lists are returned as a size-2 tuple.

 > :t fst
Take a look at this type signature. Can you figure out what it means?

 > fst (5, 'x')
Did that do what you expected?

 > let x = 5 in x + 1
This is how you define local variables. (The interpretter unfortunately 
doesn't let you define things and then use them later. Everything has to 
go into a single giant let-expression.)

 > let x = 5; y = 8 in x + y
This is how you define multiple variables.

 > iterate (*2) 1
This starts with 1, and applies the "times two" function to it over and 
over again, creating an infinite list of results. (Again, the 
interpretter doesn't display the whole thing.)

 > let factorial n = product [1..n] in factorial 6
This is how you define a new function. (Normally it wouldn't be a local 
variable, but the interpretter unfortunately doesn't allow top-level 
definitions.)

 > :t (+1)
This is a function that adds one to a number.

 > :t (*2)
This is a function that multiplies a number by two.

 > :t (+1) . (*2)
The "." operator takes two functions and combines them together. Here 
we've made a function that takes a number, multiplies it by two and then 
adds one. (Note carefully the order - RIGHT TO LEFT!)

 > map ((+1) . (*2)) [1..10]
Apply this function to a list of numbers.

 > :t div
This is a 2-argument function that does integer division.

 > :t div 10
This is not a syntax error. It's a 1-argument function. WTF?

 > :t div 10 5
This is a calculation that produces a number.

 > div 10 5
This divides 10 by 5.

 > map (div 10) [1..10]
See if you can work out what's going on.



OK, I'm going to stop now...

Post a reply to this message