177 lines
4.5 KiB
Plaintext
177 lines
4.5 KiB
Plaintext
---
|
|
title: Week One Notes
|
|
toc: no
|
|
format: markdown
|
|
...
|
|
|
|
# Week One - Haskell Basics
|
|
|
|
## What Is Haskell?
|
|
|
|
* Created in late 1980s by academics
|
|
* Functional
|
|
* Pure
|
|
* Lazy
|
|
* Statically Typed
|
|
|
|
## Course Themes
|
|
|
|
* Types
|
|
* Abstraction
|
|
* Wholemeal Programming
|
|
|
|
## Literate Haskell
|
|
|
|
* Only lines preceded by '>' are code
|
|
* All other lines are comments
|
|
|
|
## Declarations of Variables
|
|
|
|
~~~ {.haskell}
|
|
x :: Int
|
|
x = 3
|
|
~~~
|
|
|
|
* Declares a variable `x` of type `Int`
|
|
* Defines the value of the variable `x` to be `3`
|
|
* `=` is *definition*, not *assignment*
|
|
* variables are just names for values
|
|
|
|
## Basic Types
|
|
|
|
* `Int` - Machine-sized integers
|
|
* `Integer` - Arbitrary-precision integers
|
|
* `Double` - Double-precision floating point
|
|
* `Bool` - Booleans
|
|
* `Char` - Unicode characters
|
|
* `String` - Lists of characters with special syntax
|
|
|
|
## GHCi
|
|
|
|
* A Haskell Read Eval Print Loop (REPL)
|
|
* `:load` - load a haskell file
|
|
* `:reload` - reload the file
|
|
* `:type` - return the type of an expression
|
|
* `:?` - give a list of commands
|
|
|
|
## Arithmetic
|
|
|
|
* Infix operators, `+`, `-`, `*`, `\`, `^`
|
|
* Negation needs parens: `(-3)`
|
|
* `div` for integer division
|
|
* `mod` for integer remainder
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* 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
|
|
|
|
* **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]
|
|
~~~
|