Merge pull request #5 from total-typescript/matt/5.0

Matt/5.0

Author: tayiorbeii

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,8 @@
     "@types/node": "^18.6.5",
     "chokidar": "^3.5.3",
     "cross-fetch": "^3.1.5",
-    "typescript": "^4.8.3",
+    "prettier": "^2.8.7",
+    "typescript": "^5.0.2",
     "vitest": "^0.21.1"
   },
   "scripts": {
@@ -100,4 +101,4 @@
     "ts-toolbelt": "^9.6.0",
     "zod": "^3.19.1"
   }
-}
+}

package.json

@@ -0,0 +1,32 @@
+import { Equal, Expect } from "../helpers/type-utils";
+
+export const asConst = <T>(t: T) => t;
+
+const fruits = asConst([
+  {
+    name: "apple",
+    price: 1,
+  },
+  {
+    name: "banana",
+    price: 2,
+  },
+]);
+
+type tests = [
+  Expect<
+    Equal<
+      typeof fruits,
+      readonly [
+        {
+          readonly name: "apple";
+          readonly price: 1;
+        },
+        {
+          readonly name: "banana";
+          readonly price: 2;
+        }
+      ]
+    >
+  >
+];

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

@@ -0,0 +1,32 @@
+import { Equal, Expect } from "../helpers/type-utils";
+
+export const asConst = <const T>(t: T) => t;
+
+const fruits = asConst([
+  {
+    name: "apple",
+    price: 1,
+  },
+  {
+    name: "banana",
+    price: 2,
+  },
+]);
+
+type tests = [
+  Expect<
+    Equal<
+      typeof fruits,
+      readonly [
+        {
+          readonly name: "apple";
+          readonly price: 1;
+        },
+        {
+          readonly name: "banana";
+          readonly price: 2;
+        }
+      ]
+    >
+  >
+];

src/06-identity-functions/27-const-annotations.problem.ts

@@ -1,15 +1,8 @@
-import { F } from "ts-toolbelt";
 import { Equal, Expect } from "../helpers/type-utils";
+import { F } from "ts-toolbelt";
 
 export const asConst = <T>(t: F.Narrow<T>) => t;
 
-/**
- * Now, fruits is typed as:
- * [{ name: "apple"; price: 1 }, { name: "banana"; price: 2 }]
- *
- * Try changing the argument to asConst to see how it affects
- * the type.
- */
 const fruits = asConst([
   {
     name: "apple",
@@ -33,8 +26,8 @@ type tests = [
         {
           name: "banana";
           price: 2;
-        },
+        }
       ]
     >
-  >,
+  >
 ];

src/06-identity-functions/27-const-annotations.solution.1.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/27-as-const-alternative.solution.ts renamed to src/06-identity-functions/27-const-annotations.solution.2.ts

@@ -0,0 +1,47 @@
+import { it } from "vitest";
+import { Equal, Expect } from "../helpers/type-utils";
+
+type FruitsConstraint = readonly {
+  name: string;
+  price: number;
+}[];
+
+export const narrowFruits = <const TFruits extends FruitsConstraint>(
+  t: TFruits
+) => t;
+
+const fruits = narrowFruits([
+  {
+    name: "apple",
+    price: 1,
+  },
+  {
+    name: "banana",
+    price: 2,
+  },
+]);
+
+type tests = [
+  Expect<
+    Equal<
+      typeof fruits,
+      readonly [
+        {
+          readonly name: "apple";
+          readonly price: 1;
+        },
+        {
+          readonly name: "banana";
+          readonly price: 2;
+        }
+      ]
+    >
+  >
+];
+
+it("Should ONLY let you pass an array of fruits", () => {
+  const notAllowed = narrowFruits([
+    // @ts-expect-error
+    "not allowed",
+  ]);
+});

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

@@ -1,9 +1,13 @@
-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 ReadonlyArray<{
+    name: string;
+    price: number;
+  }>
+>(
+  t: TFruits
 ) => t;
 
 const fruits = narrowFruits([
@@ -21,18 +25,18 @@ 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;
+        }
       ]
     >
-  >,
+  >
 ];
 
 it("Should ONLY let you pass an array of fruits", () => {