add intermediate ts challenges

Author: diaz-rodrigo

Languages/Typescript/Generics/00008-medium-readonly-2.ts

@@ -0,0 +1,106 @@
+/*
+  8 - Readonly 2
+  -------
+  by Anthony Fu (@antfu) #medium #readonly #object-keys
+
+  ### Question
+
+  Implement a generic `MyReadonly2<T, K>` which takes two type argument `T` and `K`.
+
+  `K` specify the set of properties of `T` that should set to Readonly. When `K` is not provided, it should make all properties readonly just like the normal `Readonly<T>`.
+
+  For example
+
+  ```ts
+  interface Todo {
+    title: string
+    description: string
+    completed: boolean
+  }
+
+  const todo: MyReadonly2<Todo, 'title' | 'description'> = {
+    title: "Hey",
+    description: "foobar",
+    completed: false,
+  }
+
+  todo.title = "Hello" // Error: cannot reassign a readonly property
+  todo.description = "barFoo" // Error: cannot reassign a readonly property
+  todo.completed = true // OK
+  ```
+
+  > View on GitHub: https://tsch.js.org/8
+*/
+
+/* _____________ Your Code Here _____________ */
+
+type MyReadonly<T> = { readonly [P in keyof T]: T[P] };
+
+type MyReadonly3<T, K = void> = K extends void
+  ? MyReadonly<T>
+  : K extends T
+  ? { readonly [P in keyof K]: K[P] }
+  : {[P in keyof T]: T[P]};
+
+type MyReadonly2<T, K extends keyof T = keyof T> = Omit<T, K> &
+  Readonly<Pick<T, K>>;
+
+const test: MyReadonly2<Todo2, "title" | "description"> = {
+  title: 'h',
+  description: '',
+  completed: false,
+
+}
+
+const full: MyReadonly2<Todo1> = {
+  title: "ho",
+  description: "des",
+  completed: true,
+};
+// @ts-expect-error
+full.completed = false;
+
+/* _____________ Test Cases _____________ */
+import type { Alike, Expect } from "@type-challenges/utils";
+
+type cases = [
+  Expect<Alike<MyReadonly2<Todo1>, Readonly<Todo1>>>,
+  Expect<Alike<MyReadonly2<Todo1, "title" | "description">, Expected>>,
+  Expect<Alike<MyReadonly2<Todo2, "title" | "description">, Expected>>,
+  Expect<Alike<MyReadonly2<Todo2, "description">, Expected>>,
+  Expect<Alike<MyReadonly2<Todo1>, Full>>
+];
+
+// @ts-expect-error
+type error = MyReadonly2<Todo1, "title" | "invalid">;
+
+interface Todo1 {
+  title: string;
+  description?: string;
+  completed: boolean;
+}
+
+interface Todo2 {
+  readonly title: string;
+  description?: string;
+  completed: boolean;
+}
+
+interface Expected {
+  readonly title: string;
+  readonly description?: string;
+  completed: boolean;
+}
+
+interface Full {
+  readonly title: string;
+  readonly description?: string;
+  readonly completed: boolean;
+}
+
+/* _____________ Further Steps _____________ */
+/*
+  > Share your solutions: https://tsch.js.org/8/answer
+  > View solutions: https://tsch.js.org/8/solutions
+  > More Challenges: https://tsch.js.org
+*/

Languages/Typescript/Generics/00009-medium-deep-readonly.ts

@@ -0,0 +1,128 @@
+/*
+  9 - Deep Readonly
+  -------
+  by Anthony Fu (@antfu) #medium #readonly #object-keys #deep
+
+  ### Question
+
+  Implement a generic `DeepReadonly<T>` which make every parameter of an object - and its sub-objects recursively - readonly.
+
+  You can assume that we are only dealing with Objects in this challenge. Arrays, Functions, Classes and so on do not need to be taken into consideration. However, you can still challenge yourself by covering as many different cases as possible.
+
+  For example:
+
+  ```ts
+  type X = {
+    x: {
+      a: 1
+      b: 'hi'
+    }
+    y: 'hey'
+  }
+
+  type Expected = {
+    readonly x: {
+      readonly a: 1
+      readonly b: 'hi'
+    }
+    readonly y: 'hey'
+  }
+
+  type Todo = DeepReadonly<X> // should be same as `Expected`
+  ```
+
+  > View on GitHub: https://tsch.js.org/9
+*/
+
+/* _____________ Your Code Here _____________ */
+
+type DeepReadonly<T> = T extends Function
+  ? T
+  : T extends object
+  ? {
+      readonly [P in keyof T]: DeepReadonly<T[P]>;
+    }
+  : T;
+
+type X = {
+  x: {
+    a: 1;
+    b: "hi";
+  };
+  y: "hey";
+};
+
+type Expected = {
+  readonly x: {
+    readonly a: 1;
+    readonly b: "hi";
+  };
+  readonly y: "hey";
+};
+type Todo = DeepReadonly<X>; // should be same as `Expected`
+
+/* _____________ Test Cases _____________ */
+import type { Equal, Expect } from "@type-challenges/utils";
+
+type cases = [
+  Expect<Equal<DeepReadonly<X1>, Expected1>>,
+  Expect<Equal<DeepReadonly<X2>, Expected2>>,
+  Expect<Equal<DeepReadonly<Todo>, Expected>>
+];
+
+type X1 = {
+  a: () => 22;
+  b: string;
+  c: {
+    d: boolean;
+    e: {
+      g: {
+        h: {
+          i: true;
+          j: "string";
+        };
+        k: "hello";
+      };
+      l: [
+        "hi",
+        {
+          m: ["hey"];
+        }
+      ];
+    };
+  };
+};
+
+type X2 = { a: string } | { b: number };
+
+type Expected1 = {
+  readonly a: () => 22;
+  readonly b: string;
+  readonly c: {
+    readonly d: boolean;
+    readonly e: {
+      readonly g: {
+        readonly h: {
+          readonly i: true;
+          readonly j: "string";
+        };
+        readonly k: "hello";
+      };
+      readonly l: readonly [
+        "hi",
+        {
+          readonly m: readonly ["hey"];
+        }
+      ];
+    };
+  };
+};
+
+type Expected2 = { readonly a: string } | { readonly b: number };
+
+/* _____________ Further Steps _____________ */
+/*
+  > Share your solutions: https://tsch.js.org/9/answer
+  > View solutions: https://tsch.js.org/9/solutions
+  > More Challenges: https://tsch.js.org
+*/

Languages/Typescript/Generics/00010-medium-tuple-to-union.ts

@@ -0,0 +1,41 @@
+/*
+  10 - Tuple to Union
+  -------
+  by Anthony Fu (@antfu) #medium #infer #tuple #union
+
+  ### Question
+
+  Implement a generic `TupleToUnion<T>` which covers the values of a tuple to its values union.
+
+  For example
+
+  ```ts
+  type Arr = ['1', '2', '3']
+
+  type Test = TupleToUnion<Arr> // expected to be '1' | '2' | '3'
+  ```
+
+  > View on GitHub: https://tsch.js.org/10
+*/
+
+/* _____________ Your Code Here _____________ */
+
+type TupleToUnion<T extends any[]> = T[number];
+type Arr = ["1", "2", "3"];
+
+type Test = TupleToUnion<Arr>; // expected to be '1' | '2' | '3'
+
+/* _____________ Test Cases _____________ */
+import type { Equal, Expect } from "@type-challenges/utils";
+
+type cases = [
+  Expect<Equal<TupleToUnion<[123, "456", true]>, 123 | "456" | true>>,
+  Expect<Equal<TupleToUnion<[123]>, 123>>
+];
+
+/* _____________ Further Steps _____________ */
+/*
+  > Share your solutions: https://tsch.js.org/10/answer
+  > View solutions: https://tsch.js.org/10/solutions
+  > More Challenges: https://tsch.js.org
+*/

Languages/Typescript/Generics/00015-medium-last-of-array.ts

@@ -0,0 +1,48 @@
+/*
+  15 - Last of Array
+  -------
+  by Anthony Fu (@antfu) #medium #array
+
+  ### Question
+
+  > TypeScript 4.0 is recommended in this challenge
+
+  Implement a generic `Last<T>` that takes an Array `T` and returns its last element.
+
+  For example
+
+  ```ts
+  type arr1 = ['a', 'b', 'c']
+  type arr2 = [3, 2, 1]
+
+  type tail1 = Last<arr1> // expected to be 'c'
+  type tail2 = Last<arr2> // expected to be 1
+  ```
+
+  > View on GitHub: https://tsch.js.org/15
+*/
+
+/* _____________ Your Code Here _____________ */
+
+type Last<T extends any[]> = ["dummy",...T][T["length"]];
+type arr1 = ["a", "b", "c"];
+type arr2 = [3, 2, 1];
+
+type tail1 = Last<arr1>; // expected to be 'c'
+type tail2 = Last<arr2>; // expected to be 1
+
+/* _____________ Test Cases _____________ */
+import type { Equal, Expect } from "@type-challenges/utils";
+
+type cases = [
+  Expect<Equal<Last<[2]>, 2>>,
+  Expect<Equal<Last<[3, 2, 1]>, 1>>,
+  Expect<Equal<Last<[() => 123, { a: string }]>, { a: string }>>
+];
+
+/* _____________ Further Steps _____________ */
+/*
+  > Share your solutions: https://tsch.js.org/15/answer
+  > View solutions: https://tsch.js.org/15/solutions
+  > More Challenges: https://tsch.js.org
+*/

Languages/Typescript/Generics/00016-medium-pop.ts

@@ -0,0 +1,55 @@
+/*
+  16 - Pop
+  -------
+  by Anthony Fu (@antfu) #medium #array
+
+  ### Question
+
+  > TypeScript 4.0 is recommended in this challenge
+
+  Implement a generic `Pop<T>` that takes an Array `T` and returns an Array without it's last element.
+
+  For example
+
+  ```ts
+  type arr1 = ['a', 'b', 'c', 'd']
+  type arr2 = [3, 2, 1]
+
+  type re1 = Pop<arr1> // expected to be ['a', 'b', 'c']
+  type re2 = Pop<arr2> // expected to be [3, 2]
+  ```
+
+  **Extra**: Similarly, can you implement `Shift`, `Push` and `Unshift` as well?
+
+  > View on GitHub: https://tsch.js.org/16
+*/
+
+/* _____________ Your Code Here _____________ */
+
+type Pop<T extends any[]> = T extends []
+  ? []
+  : T extends [...infer P, infer _]
+  ? P
+  : never;
+
+type arr1 = ["a", "b", "c", "d"];
+type arr2 = [3, 2, 1];
+
+type re1 = Pop<arr1>; // expected to be ['a', 'b', 'c']
+type re2 = Pop<arr2>; // expected to be [3, 2]
+
+/* _____________ Test Cases _____________ */
+import type { Equal, Expect } from "@type-challenges/utils";
+
+type cases = [
+  Expect<Equal<Pop<[3, 2, 1]>, [3, 2]>>,
+  Expect<Equal<Pop<["a", "b", "c", "d"]>, ["a", "b", "c"]>>,
+  Expect<Equal<Pop<[]>, []>>
+];
+
+/* _____________ Further Steps _____________ */
+/*
+  > Share your solutions: https://tsch.js.org/16/answer
+  > View solutions: https://tsch.js.org/16/solutions
+  > More Challenges: https://tsch.js.org
+*/