Added const generics instructions

Author: mattpocock

notes/FUTURE.md

@@ -67,7 +67,6 @@ With a non-generic external library
 ### 6. Identity Functions
 
 ✅ No generics on objects!
-✅ F.Narrow vs as const
 ✅ F.NoInfer
 ✅ Lodash (MAYBE REVISIT AND ADD COMPLEXITY)
 

package-lock.json

@@ -8,7 +8,7 @@
     "@types/node": "^18.6.5",
     "chokidar": "^3.5.3",
     "cross-fetch": "^3.1.5",
-    "typescript": "^4.8.3",
+    "typescript": "^5.0.2",
     "vitest": "^0.21.1"
   },
   "scripts": {

package.json

@@ -1,19 +1,5 @@
 import { Equal, Expect } from "../helpers/type-utils";
 
-/**
- * This is an identity function. It takes a value and returns the same value.
- * Except that it doesn't work great on arrays, or object values.
- *
- * Below, you can see that fruits is typed as
- *
- * { name: string; price: number }[]
- *
- * instead of [{ name: "apple"; price: 1 }, { name: "banana"; price: 2 }]
- *
- * We could handle this using 'as const', but sometimes that isn't possible.
- *
- * So, we can use F.Narrow from ts-toolbelt instead.
- */
 export const asConst = <T>(t: T) => t;
 
 const fruits = asConst([
@@ -31,16 +17,16 @@ type tests = [
   Expect<
     Equal<
       typeof fruits,
-      [
+      readonly [
         {
-          name: "apple";
-          price: 1;
+          readonly name: "apple";
+          readonly price: 1;
         },
         {
-          name: "banana";
-          price: 2;
-        },
+          readonly name: "banana";
+          readonly price: 2;
+        }
       ]
     >
-  >,
+  >
 ];

src/06-identity-functions/27-as-const-alternative.problem.ts

@@ -1,7 +1,6 @@
-import { F } from "ts-toolbelt";
 import { Equal, Expect } from "../helpers/type-utils";
 
-export const asConst = <T>(t: F.Narrow<T>) => t;
+export const asConst = <const T>(t: T) => t;
 
 /**
  * Now, fruits is typed as:
@@ -25,16 +24,16 @@ type tests = [
   Expect<
     Equal<
       typeof fruits,
-      [
+      readonly [
         {
-          name: "apple";
-          price: 1;
+          readonly name: "apple";
+          readonly price: 1;
         },
         {
-          name: "banana";
-          price: 2;
-        },
+          readonly name: "banana";
+          readonly price: 2;
+        }
       ]
     >
-  >,
+  >
 ];

src/06-identity-functions/27-as-const-alternative.solution.ts

@@ -1,12 +1,6 @@
-import { F } from "ts-toolbelt";
 import { it } from "vitest";
 import { Equal, Expect } from "../helpers/type-utils";
 
-/**
- * We know that asConst works, but we now also want to be
- * able to narrow the type to only allow an array
- * of fruits.
- */
 export const narrowFruits = <TFruits>(t: TFruits) => t;
 
 const fruits = narrowFruits([
@@ -24,14 +18,14 @@ type tests = [
   Expect<
     Equal<
       typeof fruits,
-      [
+      readonly [
         {
-          name: "apple";
-          price: 1;
+          readonly name: "apple";
+          readonly price: 1;
         },
         {
-          name: "banana";
-          price: 2;
+          readonly name: "banana";
+          readonly price: 2;
         }
       ]
     >

src/06-identity-functions/28-constraints-with-f.narrow.problem.ts renamed to src/06-identity-functions/28-constraints-with-const-generics.problem.ts

@@ -1,9 +1,8 @@
-import { F } from "ts-toolbelt";
 import { it } from "vitest";
 import { Equal, Expect } from "../helpers/type-utils";
 
-export const narrowFruits = <TFruits extends { name: string; price: number }[]>(
-  t: F.Narrow<TFruits>,
+export const narrowFruits = <const TFruits extends readonly { name: string; price: number }[]>(
+  t: TFruits,
 ) => t;
 
 const fruits = narrowFruits([
@@ -21,14 +20,14 @@ type tests = [
   Expect<
     Equal<
       typeof fruits,
-      [
+      readonly [
         {
-          name: "apple";
-          price: 1;
+          readonly name: "apple";
+          readonly price: 1;
         },
         {
-          name: "banana";
-          price: 2;
+          readonly name: "banana";
+          readonly price: 2;
         },
       ]
     >

src/06-identity-functions/28-constraints-with-f.narrow.solution.ts renamed to src/06-identity-functions/28-constraints-with-const-generics.solution.ts

@@ -6,7 +6,7 @@ interface Fruit {
 }
 
 export const wrapFruit = (fruits: unknown[]) => {
-  const getFruit = (name: unknown): unknown => {
+  const getFruit = (name: unknown) => {
     return fruits.find((fruit) => fruit.name === name);
   };
 
@@ -32,6 +32,6 @@ const apple = fruits.getFruit("apple");
 const notAllowed = fruits.getFruit("not-allowed");
 
 type tests = [
-  Expect<Equal<typeof apple, { name: "apple"; price: 1 }>>,
-  Expect<Equal<typeof banana, { name: "banana"; price: 2 }>>,
+  Expect<Equal<typeof apple, { readonly name: "apple"; readonly price: 1 }>>,
+  Expect<Equal<typeof banana, { readonly name: "banana"; readonly price: 2 }>>
 ];

src/07-challenges/32-narrow-with-arrays.problem.ts

@@ -1,14 +1,11 @@
 import { Equal, Expect } from "../helpers/type-utils";
-import { F } from "ts-toolbelt";
 
 interface Fruit {
   name: string;
   price: number;
 }
 
-export const wrapFruit = <TFruits extends Fruit[]>(
-  fruits: F.Narrow<TFruits>
-) => {
+export const wrapFruit = <const TFruits extends readonly Fruit[]>(fruits: TFruits) => {
   const getFruit = <TName extends TFruits[number]["name"]>(name: TName) => {
     return fruits.find((fruit) => fruit.name === name) as Extract<
       TFruits[number],
@@ -38,6 +35,6 @@ const apple = fruits.getFruit("apple");
 const notAllowed = fruits.getFruit("not-allowed");
 
 type tests = [
-  Expect<Equal<typeof apple, { name: "apple"; price: 1 }>>,
-  Expect<Equal<typeof banana, { name: "banana"; price: 2 }>>
+  Expect<Equal<typeof apple, { readonly name: "apple"; readonly price: 1 }>>,
+  Expect<Equal<typeof banana, { readonly name: "banana"; readonly price: 2 }>>
 ];