Progress.

Author: Dylan Just

src/main/ts/Exercise3Optional.ts

@@ -76,24 +76,106 @@ export const message = (e: Optional<string>): string =>
     (s) => "The value was " + s
   );
 
-// TODO:
+// TODO: Implement a function using fold, that takes an Optional<number>. If it's some, double it. If it's none, return 0;
 
+// TODO: Implement a function that takes an Optional<T> for any type T. Return true if it's some, and false if it's none.
+const trueIfSome = <T> (x: T): Optional<T> => {
+  throw new Error("TODO");
+}
+
+/*
+The last function you implemented is already part of the Optional type, and is called isSome().
+There's a corresponding isNone().
 
+In some VERY LIMITED SITUATIONS you can use isSome() and then the UNSAFE getOrDie() function.
+It's acceptible to do this in tests, or where nested folding is incredibly cumbersome.
+ */
 
+export const unsafeStuff = (e: Optional<string>): void => {
+  if (e.isSome()) {
+    console.log(e.getOrDie()); // AVOID
+  }
+}
 
 /*
-Aside: Constructing and Destructing
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++
++ Aside: But you said we used "static" functions, not methods on objects!
++
++ Yeah, mostly we do. But Optional is from a time before we pushed that concept very hard.
++ At some point, we intend to replace Optional's API with something fully static.
++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+A common way to handle an Optional value is to provide a default value if in the case of none.
+
+You can do this with fold, but getOrElse is a shortcut.
+*/
 
-Many developers are familiar with the idea of a "constructor". You pass values into a constructor
-to construct an object. While we're not using TypeScript classes here, the functions "some" and
-"none" are still considered the constructors for the data type.
+// TODO: Using getOrElse, take an Optional<{age: string}> and turn it into an {age: string}, using a default value of 0.
 
-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.
+// TODO: Write the same function using fold
 
-Our "fold" function destructures the Option type. In category theory, "fold" is known as a "catamorphism".
 
+/*
+Another way of thinking about an Optional, is that it's an array that contains either 0 or 1 elements.
+
+Let's explore this by converting Optionals to and from Arrays.
  */
 
-// TODO: head over to Exercise3OptionTest to write some test cases for the above.
+// TODO: Write a function that converts an Optional<A> to an A[] for any type A.
+
+// 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.
+
+
+/*
+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: TypeScript type refinement
++
++ Why can't we use type refinement to turn an Optional<T> to a Some<T> and make getOrDie() safe?
++ It's to do with how we encode Optional. We use Church Encoding, so Optional is defined like this:
++ interface Optional<A> {
++   fold: <B> (ifNone: () => B, ifSome: (a: A) => B)
++ }
++
++ whereas TypeScript encourages you to encode union types like this:
++
++ type None<A> = { kind: 'none' };
++ type Some<A> = { kind: 'some', value: A };
++ type Optional<A> = Some<A> | None<A>
++
++ Our Optional implementation predates TypeScript, so this wasn't an option at the time.
++ That's not to say Church Encoding is bad. There are pros and cons, but that's a story for another day.
++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+
+
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++
++ Aside: Constructing and Destructing
++
++ Many developers are familiar with the idea of a "constructor". You pass values into a constructor
++ to construct an object. While we're not using TypeScript classes here, the functions "some" and
++ "none" are still considered the constructors for the data type.
++
++ 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.
++
++ Our "fold" function destructures the Option type. In category theory, "fold" is known as a "catamorphism".
++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ */

src/main/ts/Exercise4FP.ts

@@ -28,3 +28,4 @@ export const message3 = (e: Optional<string>): void => {
   console.log(m);
 }
 
+

src/test/ts/Exercise3OptionTest.ts

@@ -17,4 +17,4 @@ UnitTest.test('toPositiveInteger', () => {
   // NOTE the examples above - due to how Optional is implemented, we can't compare values as JS objects/arrays/values,
   // and we need to pass in the tOption() equality value
 
-});
+});