Fixed various issues reported by new hires

Author: lnewson

src/main/ts/Part2Ex2ArrayFunctions.ts

@@ -9,7 +9,7 @@ Its array module "Arr" is very handy, so let's explore it.
 We don't write loops if we can help it. Instead, we go up a level, and call functions that do the looping for us.
 The simplest of these is 'each' which just iterates.
 
-TODO: Run the followind code using this command:
+TODO: Run the following code using this command:
 yarn bedrock-auto -b chrome-headless -f src/test/ts/Exercise2ArrayFunctionsTest.ts
  */
 
@@ -84,11 +84,11 @@ export const evens = (xs: number[]): number[] =>
 // TODO: Write a function that returns all the frogs that ribbit
 // TODO: Run the provided test to check your answer.
 export const ribbitting = (frogs: Frog[]): Frog[] =>
-  []
+  [];
 
 // TODO: Write a function that returns all frogs aged 8 or older
 export const olderFrogs = (frogs: Frog[]): Frog[] =>
-  []
+  [];
 
 /*
 5. Arr.exists
@@ -111,7 +111,7 @@ This behaviour of running map then flatten is why this function is sometimes cal
 TODO: Write a function that takes a list of strings, each string containing a comma-separated list of values, and returns all of the values as an array.
  */
 export const splitCsvs = (csvs: string[]): string[] =>
-  []
+  [];
 
 /*
 7. Arr.find

src/main/ts/Part2Ex3Optional.ts

@@ -16,7 +16,7 @@ value in all cases. Some examples:
 
 There are many ways of representing these "empty" cases, including:
 - returning a special value, e.g. empty string, empty array, NaN
-- returining null or undefined
+- returning null or undefined
 - throwing an exception
 
 In TinyMCE, we use a different approach. We represent these scenarios with a data type called "Optional".
@@ -85,7 +85,7 @@ export const message = (e: Optional<string>): string =>
 // 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().
@@ -99,7 +99,7 @@ export const unsafeStuff = (e: Optional<string>): void => {
   if (e.isSome()) {
     console.log(e.getOrDie()); // AVOID
   }
-}
+};
 
 /*
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
@@ -114,10 +114,10 @@ export const unsafeStuff = (e: Optional<string>): void => {
 
 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.
+You can do this with fold, but getOr is a shortcut.
 */
 
-// TODO: Using getOrElse, take an Optional<{age: string}> and turn it into an {age: string}, using a default value of 0.
+// TODO: Using getOr, take an Optional<{age: string}> and turn it into an {age: string}, using a default value of 0.
 
 // TODO: Write the same function using fold
 

src/main/ts/Part2Ex4FP.ts

@@ -1,4 +1,4 @@
-import { Fun, Optional } from "@ephox/katamari";
+import { Arr, Fun, Optional } from "@ephox/katamari";
 
 /*
 Functional programming is about programming in functions. Functions in the mathematical sense. "Pure" functions.
@@ -80,8 +80,8 @@ TODO: Extract a pure function for the logic hiding in this (impure) function
 type Mode = 'code' | 'design' | 'markdown';
 
 const switchMode = (m: Mode): void => {
-  // pretend that something useful happens here
-}
+  // pretend that something useful happens here that causes a side effect
+};
 
 const nextMode = (m: Mode): void => {
   if (m === 'code') {
@@ -138,7 +138,7 @@ You can find this as Fun.constant in katamari.
 One way of writing it is below:
  */
 
-const constant = <A, B> (a: A) => (b: B) => a;
+const constant = <A> (a: A) => (...args: any[]): A => a;
 
 const always3 = constant(3);
 

src/main/ts/Part2Ex5Sugar.ts

@@ -58,7 +58,7 @@ We often have to traverse from an element to its relatives. The Traverse module
 
 // TODO: inspect the type of Traverse.parent and explain why that type was used.
 // Answer:
-}
+};
 
 
 
@@ -76,5 +76,5 @@ We often have to traverse from an element to its relatives. The Traverse module
   // TODO: starting at parent, find both kids
 
   // TODO: kid2 grew up - give it its own child node
-}
+};
 

src/test/ts/Exercise3OptionTest.ts

@@ -6,7 +6,7 @@ const tOptional = OptionalInstances.tOptional;
 
 UnitTest.test('getProtocol', () => {
   Assert.eq('simple https', Optional.some('https'), Ex.getProtocol('https://frog.com'), tOptional());
-  Assert.eq('simple http', Optional.some('https'), Ex.getProtocol('http://frog.com'), tOptional());
+  Assert.eq('simple http', Optional.some('http'), Ex.getProtocol('http://frog.com'), tOptional());
   Assert.eq('no protocol 1', Optional.none<string>(), Ex.getProtocol('frog.com'), tOptional());
   Assert.eq('no protocol 2', Optional.none<string>(), Ex.getProtocol('://frog.com'), tOptional());
   Assert.eq('malformed protocol', Optional.none<string>(), Ex.getProtocol('3ttp://frog.com'), tOptional());