Updates to cs194 week 1 page

master
Levi Pearson 2014-08-24 00:54:17 -06:00
parent 1fe0979739
commit c6c9baaee2
1 changed files with 94 additions and 1 deletions

View File

@ -61,23 +61,116 @@ x = 3
* `div` for integer division * `div` for integer division
* `mod` for integer remainder * `mod` for integer remainder
* Backticks turn named functions to infix operators * Backticks turn named functions to infix operators
* Operands must have the same type - no implicit coercion
* `fromIntegral` converts from any integral type to any numeric type
* `round`, `floor`, `ceiling` convert from floating point numbers to
Int or Integer
## Boolean Logic ## Boolean Logic
* * Type is `Boolean`
* Infix operators: `&&`, `||`
* `not` for negation
* Equality comparison: `==`, `/=`
* Order comparison: `<`, `>`, `<=`, `>=`
* Conditional: `if` *boolean* `then` *t_exp* `else` f_exp*
* Both *t_exp* and *f_exp* must have the same type
## Defining Basic Functions ## Defining Basic Functions
* Definition by cases
* `sumtorial :: Integer -> Integer` means "function from Integer to
Integer"
* Clauses are checked from top to bottom, first match chosen
* Values must be the same to match, variables match anything
* Choice by Boolean expression can be made by *guards*
* `otherwise` is a synonym for `True`
* Don't use conditional or guards to pick `True` or `False`; just
use the conditional directly
## Pairs ## Pairs
* Syntax for type and value is `(` *x* `,` *y* `)`
* Types of *x* and *y* don't have to be the same
* Extract values via pattern-matching
* *n*-tuples for *n* > 2 also exist, but recommend against them
## Using Functions, Multiple Arguments ## Using Functions, Multiple Arguments
* Application via juxtaposition of function with arguments.
* Multi-argument function types look like `Int -> Int -> Int -> Int`
* Reason for the arrows to be revealed later
* Function application is **higher precedence** than any infix
operators
## Lists ## Lists
* List types look like `nums :: [Integer]` which is a "list of Integers"
* List value syntax sugar: `[1,2,3]`
* Ranges: `[1..100]`; `[2,4..100]` enumerates only evens
* Type `String` means the same as `[Char]`
* Value `"hello"` means the same as `['h','e','l','l','o']`
## Constructing Lists ## Constructing Lists
* Empty list: `[]`
* *cons* operator: *x* `:` *xs* where *xs* is a list of values of
the same type as *x*, possibly the empty list.
* Value `[2,3,4]` is the same as `2 : 3 : 4 : []`
## Functions on Lists ## Functions on Lists
* Define by cases; one for empty list, the other for a cons operator
* The pattern `_` can be used in place of a variable when the value
won't be used.
## Combining Functions ## Combining Functions
* Build complex functions by combining simple ones
* Lazy evaluation means list elements are only calculated as needed
* Don't be afraid to write small functions that transform entire
structures and combine them; it's not as inefficient as it might
seem
## A Word About Error Messages ## A Word About Error Messages
* **Don't fear error messages**
* How to interpret type match errors
# Homework Assignment
The first problem involves validating credit card numbers.
1. Find the digits of a number; write the functions:
~~~ {.haskell}
toDigits :: Integer -> [Integer]
toDigitsRev :: Integer -> [Integer]
~~~
2. Double every other digit *from the right*
~~~ {.haskell}
doubleEveryOther :: [Integer] -> [Integer]
~~~
3. Sum the digits
~~~ {.haskell}
sumDigits :: [Integer] -> Integer
~~~
4. The number is valid iff the remainder when the sum is divided by
10 is 0
~~~ {.haskell}
validate :: Integer -> Bool
~~~
The second problem is to solve the Towers of Hanoi puzzle.
~~~ {.haskell}
type Peg = String
type Move = (Peg, Peg)
hanoi :: Integer -> Peg -> Peg -> Peg -> [Move]
~~~