Making the assertions in AboutUnit pass

What did I learn?...
(...not a lot really)

+ unit is a bit like void except it's an actual type.
+ It's a type that only has one value and this value is represented with ()
+ For example, it's used for parameterless functions so they actually take unit as their argument...

        let sayHello() =
            "hello"

        let result = sayHello()

+ Functions and expressions that don't return an actual value evaluate to the unit type
Making the assertions in AboutTuples pass

What did I learn?

+ Declare a tuple with:

	let items = ("apple", "dog")

  ...the items in the tuple can be different types.

+ Its type is reported with an asterisk:

	val items : string * string = ("apple", "dog")

+ A tuple with two values is a special case. The values can be accessed using the fst and snd functions:

	let fruit = fst items
	let animal = snd items

+ In the general case, you access the values by unpacking them into variables. (Note the use of the wildcard character '_' to avoid creating an identifier you don't need):

	let _, animal = items

  ...This is an example of 'pattern matching' in F#. (_, animal) on the left-hand side is the pattern. The expression on the right-hand side is matched against the pattern.  There'll be more on patterns later!

+ Functions that return a tuple can be treat as if they're returning multiple values:

	let squared, cubed = squareAndCube 3.0

   ...squareAndCube is actually returning a tuple then using pattern matching to unpack the tuple into the two values