Progress.

Author: Dylan Just

src/main/ts/Exercise3Optional.ts

@@ -52,13 +52,16 @@ Optional.from take a value which may be null, undefined or an actual value.
 - otherwise, it returns some() of the value
 
 Optional.from is useful for taking values from the "nullable" world to the Optional world.
+
+TODO: use Optional.from to implement the following DOM function
  */
 
-// TODO: use Optional.from to implement the following DOM function
 export const getNextSibling = (e: Element): Optional<ChildNode> => {
   throw new Error("TODO");
 };
 
+// TODO: use Optional.from to implement a similar wrapper for Element.getAttributeNode(string)
+
 /*
 How do we get data out of an Optional? Well, that's a bit tricky since there isn't always
 data in there! But, there's a way to do it and we call that function "fold".
@@ -129,17 +132,56 @@ Let's explore this by converting Optionals to and from Arrays.
 // TODO: Write a function that converts an A[] to an Optional<A>. If the array has more than one element, only consider the first element.
 
 
+/*
+One of the most useful functions on Optional is "map". We say this function "maps a function over the Optional".
+
+If the Optional is some, it runs the function over the some and returns the result as a "some".
+If the Optional. is none, it returns none.
+
+Above, we talked about how an Optional is like an array restricted to 0 or 1 elements, so mapping over an Optional
+is very similar to mapping over an array (which we did in Exercise 2).
+
+Some examples, then some exercises:
+ */
+
+const x: Optional<string> = Optional.some(3).map((x) => String(x)); // returns Optional.some("3")
+
+const y: Optional<string> = Optional.none<number>().map((x) => String(x)); // returns Optional.<string>none()
+
+// TODO: Write a function that takes an Optional<number> and adds 3 to the number
+
+// TODO: Write a function that takes an Optional<string> and prefixes the string with "hello"
+
+// TODO: If the below function is called, does it return a value or throw an exception? Write your answer in a comment, and explain why you think it behaves this way?
+const willItKersplode = (): Optional<string> => {
+  const z = Optional.none<string>();
+  return z.map<string>((s) => {
+    throw new Error("boom");
+  });
+};
+
 /*
 Well done! You've tackled the basis of Optionals. We'll dig into them a bit more in future exercises,
 but everything builds on what we've done here.
 
 TODO: head over to Exercise3OptionTest to write some test cases for the above.
+*/
 
 
-
+/*
 Below are some explanatory notes on some more advanced topics. Feel free to skip them if you're still learning.
 
 
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++ Aside: mapping
++
++ We've mapped over both Arrays and Optionals. A type that can be mapped over in this way
++ is called a Functor. Arrays and Optionals are Functors. Functors are a very useful abstraction,
++ but outside the scope of this tutorial.
++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 +
 + Aside: TypeScript type refinement
@@ -173,9 +215,11 @@ Below are some explanatory notes on some more advanced topics. Feel free to skip
 +
 + What if you want to take an object and get its fields? Well, that's called "destruction". We're
 + taking an object and destructing it into its constituent parts. You'll also find "destructuring assignment"
-+ as a feature of many languages, including TypeScript.
++ as a feature of many languages, including TypeScript. e.g. const { x } = { x: 3, y: 'foo' };
 +
 + Our "fold" function destructures the Option type. In category theory, "fold" is known as a "catamorphism".
 +
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
  */
+

src/main/ts/Exercise4FP.ts

@@ -1,13 +1,69 @@
+import { Option as Optional } from "@ephox/katamari";
+
+/*
+Functional programming is about programming in functions. Functions in the mathematical sense. "Pure" functions.
+
+A pure function is one that has no "side effects".
+1. It reads its arguments and returns a value.
+2. If you pass it the same input, it always produces the same output.
+3. It doesn't print anything to screen, send any network traffic, write to any databases.
+4. It doesn't mutate any state.
+
+Anyone seeing this list for the first time will say: well what's the point of FP if I can't do those useful things?
+
+Unfortunately, the answer is not satisfying to beginners: FP does have techniques to manage effects like these and
+still use pure functions, but we need to learn a few other things first. Also, these techniques are not well-suited
+to TypeScript.
+
+Well, that's a bit of a let-down. But, there's a silver lining... a very, very shiny silver lining, and that's this:
+
+*** You can do functional programming in limited situations and still reap a lot of the benefits. ***
+
+So, we try to write our TypeScript in as functional way as is practical.
+
+What are the benefits we're trying to get?
+- If functions only deal with their arguments and only return values, then they're easier to test.
+- By separating logic from effect, we structure our programs in a way that's easier to understand.
+- Pure functions are easier to refactor, as you don't have to worry about how many times you call them.
+- Pure functions in programming are the same as functions in math. When we use pure functions, we can make use of
+  the mathematical properties of functions. It turns out that math has ... to put it mildly ... rather a lot to say about functions.
+
+Now, for the sake of time, I'm not going to do any more hard-sell on why it's important - lots has already been written
+on this topic. For the rest of this exercise, we're just going to look at some of the basic techniques and common
+functions we use.
+*/
 
+/*
+Let's start with the simplest function there is: the identity function.
+It takes an argument and returns it.
+*/
+
+const identity = <A> (a: A): A => a;
 
 /*
-In functional programming, we aim to program
+ You can find this function in katamari as Fun.identity.
+
+ Now, what use is that? I already had that value!
+
+ Well, let's go back to something we did in Exercise 3 - providing a default value. We used the getOrElse function
+ on Optional. You can write a similar function like this:
+*/
+
+const getOrElse1 = <A> (oa: Optional<A>, other: A): A =>
+  oa.fold(
+    () => other,
+    (a) => a
+  );
+
+// Hang on - that looks familiar. The function we pass as the "some" case is the identity function.
+
+// TODO: write a version of getOrElse1 using Fun.identity.
+
 
 
- */
 
 // You can also use fold to do some kind of "side-effect" on each branch, as below.
-import { Option as Optional } from "@ephox/katamari";
+
 
 export const message2 = (e: Optional<string>): void =>
   e.fold(