Added explainers

Author: mattpocock

src/02-passing-type-arguments/11.5-fetch-wrapper-in-cal.com.explainer.ts

@@ -0,0 +1,3 @@
+// Explain fetch-wrapper.ts in cal.com repo
+
+export {};

src/03-art-of-type-arguments/14.5-literal-inference.explainer.ts

@@ -0,0 +1,31 @@
+// When returning the value only, it infers
+// the literal type
+const returnsValueOnly = <T>(t: T) => {
+  return t;
+};
+
+const result = returnsValueOnly("a");
+//    ^?
+
+// When returning an object or array, it doesn't infer the
+// literal type
+const returnsValueInAnObject = <T1>(t: T1) => {
+  return {
+    t,
+  };
+};
+
+const result2 = returnsValueInAnObject("abc");
+//    ^?
+
+// With a constraint, it narrows it to its literal
+const returnsValueInAnObjectWithConstraint = <T1 extends string>(t: T1) => {
+  return {
+    t,
+  };
+};
+
+const result3 = returnsValueInAnObjectWithConstraint("abc");
+//    ^?
+
+export {};

src/03-art-of-type-arguments/14.6-literal-inference-on-arguments.explainer.ts

@@ -0,0 +1,45 @@
+// When returning the value only, it infers
+// the literal type
+const acceptsValueOnly = <T>(t: T) => {
+  return t;
+};
+
+const result = acceptsValueOnly("a");
+//    ^?
+
+const acceptsValueInAnObject = <T>(obj: { input: T }) => {
+  return obj.input;
+};
+
+const result2 = acceptsValueInAnObject({ input: "abc" });
+//    ^?
+
+const result2WithAsConst = acceptsValueInAnObject({ input: "abc" } as const);
+//    ^?
+
+const acceptsValueInAnObjectFieldWithConstraint = <T extends string>(obj: {
+  input: T;
+}) => {
+  return obj.input;
+};
+
+const result3 = acceptsValueInAnObjectFieldWithConstraint({ input: "abc" });
+//    ^?
+
+const acceptsValueWithObjectConstraint = <
+  T extends {
+    input: string;
+  },
+>(
+  obj: T,
+) => {
+  return obj.input;
+};
+
+const result4 = acceptsValueWithObjectConstraint({ input: "abc" });
+
+const result4WithAsConst = acceptsValueWithObjectConstraint({
+  input: "abc",
+} as const);
+
+export {};

src/04-generics-advanced/17-you-say-goodbye-i-say-hello.solution.ts renamed to src/04-generics-advanced/17-you-say-goodbye-i-say-hello.solution.1.ts

@@ -0,0 +1,30 @@
+import { expect, it } from "vitest";
+import { Equal, Expect } from "../helpers/type-utils";
+
+type GreetingResult<TGreeting> = TGreeting extends "hello"
+  ? "goodbye"
+  : "hello";
+
+function youSayGoodbyeISayHello<TGreeting extends "hello" | "goodbye">(
+  greeting: TGreeting,
+) {
+  return (
+    greeting === "goodbye" ? "hello" : "goodbye"
+  ) as GreetingResult<TGreeting>;
+}
+
+it("Should return goodbye when hello is passed in", () => {
+  const result = youSayGoodbyeISayHello("hello");
+
+  type test = [Expect<Equal<typeof result, "goodbye">>];
+
+  expect(result).toEqual("goodbye");
+});
+
+it("Should return hello when goodbye is passed in", () => {
+  const result = youSayGoodbyeISayHello("goodbye");
+
+  type test = [Expect<Equal<typeof result, "hello">>];
+
+  expect(result).toEqual("hello");
+});