[style]: run prettier on Markdown files (#145)

Author: ghaiklor

en/easy-concat.md

@@ -15,7 +15,7 @@ The output should be a new array that includes inputs in ltr order.
 For example:
 
 ```ts
-type Result = Concat<[1], [2]> // expected to be [1, 2]
+type Result = Concat<[1], [2]>; // expected to be [1, 2]
 ```
 
 ## Solution
@@ -40,14 +40,14 @@ Variadic Tuple Types allows us to model the same behavior in the type system.
 If we want to concatenate two generic arrays, we can return the new array where both arrays are behind the spread operator:
 
 ```ts
-type Concat<T, U> = [...T, ...U]
+type Concat<T, U> = [...T, ...U];
 ```
 
 We are getting the error “A rest element type must be an array type.”, though.
 Let us fix that by letting compiler know those types are arrays:
 
 ```ts
-type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]
+type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U];
 ```
 
 ## References

en/easy-first.md

@@ -13,19 +13,19 @@ Implement a generic `First<T>` that takes an Array `T` and returns it's first el
 For example:
 
 ```ts
-type arr1 = ['a', 'b', 'c']
-type arr2 = [3, 2, 1]
+type arr1 = ["a", "b", "c"];
+type arr2 = [3, 2, 1];
 
-type head1 = First<arr1> // expected to be 'a'
-type head2 = First<arr2> // expected to be 3
+type head1 = First<arr1>; // expected to be 'a'
+type head2 = First<arr2>; // expected to be 3
 ```
 
 ## Solution
 
 The first thing that could come up is to use lookup types and just write `T[0]`:
 
 ```ts
-type First<T extends any[]> = T[0]
+type First<T extends any[]> = T[0];
 ```
 
 But there is an edge case that we need to handle.

en/easy-if.md

@@ -14,8 +14,8 @@ Implement a utils `If` which accepts condition `C`, a truthy return type `T`, an
 For example:
 
 ```ts
-type A = If<true, 'a', 'b'> // expected to be 'a'
-type B = If<false, 'a', 'b'> // expected to be 'b'
+type A = If<true, "a", "b">; // expected to be 'a'
+type B = If<false, "a", "b">; // expected to be 'b'
 ```
 
 ## Solution

en/easy-includes.md

@@ -15,7 +15,7 @@ For example:
 
 ```typescript
 // expected to be `false`
-type isPillarMen = Includes<['Kars', 'Esidisi', 'Wamuu', 'Santana'], 'Dio'>
+type isPillarMen = Includes<["Kars", "Esidisi", "Wamuu", "Santana"], "Dio">;
 ```
 
 ## Solution

en/easy-pick.md

@@ -16,17 +16,17 @@ For example:
 
 ```ts
 interface Todo {
-  title: string
-  description: string
-  completed: boolean
+  title: string;
+  description: string;
+  completed: boolean;
 }
 
-type TodoPreview = MyPick<Todo, 'title' | 'completed'>
+type TodoPreview = MyPick<Todo, "title" | "completed">;
 
 const todo: TodoPreview = {
-  title: 'Clean room',
+  title: "Clean room",
   completed: false,
-}
+};
 ```
 
 ## Solution
@@ -50,7 +50,7 @@ The type of values itself are going to be without change.
 Although, we need to take its type from the original type and that is where lookup type is useful:
 
 ```ts
-type MyPick<T, K extends keyof T> = { [P in K]: T[P] }
+type MyPick<T, K extends keyof T> = { [P in K]: T[P] };
 ```
 
 We are saying “get everything from `K`, name it as `P` and make it as a new key in our new object with a value type taken from the input type”.

en/easy-push.md

@@ -12,7 +12,7 @@ Implement the generic version of `Array.push`.
 For example:
 
 ```typescript
-type Result = Push<[1, 2], '3'> // [1, 2, '3']
+type Result = Push<[1, 2], "3">; // [1, 2, '3']
 ```
 
 ## Solution
@@ -25,22 +25,22 @@ To get all the elements from an array, we can use variadic tuple types.
 So, let us return an array with the same elements from input type `T`:
 
 ```typescript
-type Push<T, U> = [...T]
+type Push<T, U> = [...T];
 ```
 
 Getting a compilation error “A rest element type must be an array type”.
 It means that we can not use variadic tuple type on non-array-like types.
 So let us add a generic constraint to show that we are working with arrays only:
 
 ```typescript
-type Push<T extends unknown[], U> = [...T]
+type Push<T extends unknown[], U> = [...T];
 ```
 
 Now, we have a copy of the incoming array in type parameter `T`.
 The only thing remains is to add an element from `U`:
 
 ```typescript
-type Push<T extends unknown[], U> = [...T, U]
+type Push<T extends unknown[], U> = [...T, U];
 ```
 
 That way, we have implemented a push operation in the type system.

en/easy-readonly.md

@@ -16,17 +16,17 @@ For example:
 
 ```ts
 interface Todo {
-  title: string
-  description: string
+  title: string;
+  description: string;
 }
 
 const todo: MyReadonly<Todo> = {
   title: "Hey",
-  description: "foobar"
-}
+  description: "foobar",
+};
 
-todo.title = "Hello" // Error: cannot reassign a readonly property
-todo.description = "barFoo" // Error: cannot reassign a readonly property
+todo.title = "Hello"; // Error: cannot reassign a readonly property
+todo.description = "barFoo"; // Error: cannot reassign a readonly property
 ```
 
 ## Solution
@@ -38,7 +38,7 @@ We are going to use the usual [Mapped Type](https://www.typescriptlang.org/docs/
 For each property in the type, we take its key and add a `readonly` modifier to it:
 
 ```ts
-type MyReadonly<T> = { readonly [K in keyof T]: T[K] }
+type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
 ```
 
 ## References

en/easy-tuple-length.md

@@ -13,11 +13,17 @@ For given a tuple, you need create a generic `Length`, pick the length of the tu
 For example:
 
 ```ts
-type tesla = ['tesla', 'model 3', 'model X', 'model Y']
-type spaceX = ['FALCON 9', 'FALCON HEAVY', 'DRAGON', 'STARSHIP', 'HUMAN SPACEFLIGHT']
-
-type teslaLength = Length<tesla> // expected 4
-type spaceXLength = Length<spaceX> // expected 5
+type tesla = ["tesla", "model 3", "model X", "model Y"];
+type spaceX = [
+  "FALCON 9",
+  "FALCON HEAVY",
+  "DRAGON",
+  "STARSHIP",
+  "HUMAN SPACEFLIGHT"
+];
+
+type teslaLength = Length<tesla>; // expected 4
+type spaceXLength = Length<spaceX>; // expected 5
 ```
 
 ## Solution
@@ -26,14 +32,14 @@ We know that we can use property `length` to access the length of the array in J
 We can do the same in types as well:
 
 ```ts
-type Length<T extends any> = T['length']
+type Length<T extends any> = T["length"];
 ```
 
 But going that way we will get the compilation error “Type 'length' cannot be used to index type 'T'.”.
 So we need to give a hint to TypeScript and tell that our input type parameter has this property:
 
 ```ts
-type Length<T extends { length: number }> = T['length']
+type Length<T extends { length: number }> = T["length"];
 ```
 
 ## References

en/easy-tuple-to-object.md

@@ -13,10 +13,10 @@ Given an array, transform to an object type and the key/value must in the given
 For example:
 
 ```ts
-const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const
+const tuple = ["tesla", "model 3", "model X", "model Y"] as const;
 
 // expected { tesla: 'tesla', 'model 3': 'model 3', 'model X': 'model X', 'model Y': 'model Y'}
-const result: TupleToObject<typeof tuple>
+const result: TupleToObject<typeof tuple>;
 ```
 
 ## Solution
@@ -28,7 +28,7 @@ We can get the values from an array by using `T[number]` construct.
 With the help of mapped types, we can iterate over those values in `T[number]` and return a new type where the key and value is the type from `T[number]`:
 
 ```ts
-type TupleToObject<T extends readonly any[]> = { [K in T[number]]: K }
+type TupleToObject<T extends readonly any[]> = { [K in T[number]]: K };
 ```
 
 ## References

en/easy-unshift.md

@@ -12,7 +12,7 @@ Implement the type version of `Array.unshift()`.
 For example:
 
 ```typescript
-type Result = Unshift<[1, 2], 0> // [0, 1, 2]
+type Result = Unshift<[1, 2], 0>; // [0, 1, 2]
 ```
 
 ## Solution
@@ -24,22 +24,22 @@ Here we do pretty the same, but in a different order.
 First, let us take all the elements from the incoming array:
 
 ```typescript
-type Unshift<T, U> = [...T]
+type Unshift<T, U> = [...T];
 ```
 
 With this snippet, we are getting the compilation error “A rest element type must be an array type”.
 Let us fix the error by adding a constraint over the type parameter:
 
 ```typescript
-type Unshift<T extends unknown[], U> = [...T]
+type Unshift<T extends unknown[], U> = [...T];
 ```
 
 Now, we have the same array as the incoming one.
 All we need is to add an element to the beginning of the tuple.
 Let’s do just that:
 
 ```typescript
-type Unshift<T extends unknown[], U> = [U, ...T]
+type Unshift<T extends unknown[], U> = [U, ...T];
 ```
 
 That way, we made an “unshift” function in the type system!

en/index.md

@@ -3,7 +3,7 @@ title: Type Challenges Solutions
 description: >-
   This project is aimed at helping you better understand how the type system
   works, writing your own utilities, or just having fun with the challenges.
-keywords: 'type, challenges, solutions, typescript, javascript'
+keywords: "type, challenges, solutions, typescript, javascript"
 lang: en
 comments: false
 ---

en/medium-absolute.md

@@ -28,7 +28,9 @@ Remove the “-” sign.
 We can approach it by checking if the type has a “-” sign in its template literal type, and if so, we infer the part without the “-” sign, otherwise return the type itself:
 
 ```typescript
-type Absolute<T extends number | string | bigint> = T extends `-${infer N}` ? N : T;
+type Absolute<T extends number | string | bigint> = T extends `-${infer N}`
+  ? N
+  : T;
 ```
 
 So, e.g. if we provide the type `T = “-50”`, it will match the `“-<N>”`, where `N` will become just “50”.
@@ -41,7 +43,9 @@ When providing a positive number, it will not match the literal type and return
 Let us fix that by wrapping our `T` in template literal type:
 
 ```typescript
-type Absolute<T extends number | string | bigint> = T extends `-${infer N}` ? N : `${T}`;
+type Absolute<T extends number | string | bigint> = T extends `-${infer N}`
+  ? N
+  : `${T}`;
 ```
 
 Still, some tests are failing.
@@ -50,7 +54,9 @@ Number will not match the template literal type of condition, so it will return
 To overcome this, we can convert the number to string:
 
 ```typescript
-type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer N}` ? N : `${T}`;
+type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer N}`
+  ? N
+  : `${T}`;
 ```
 
 As a result, we got a type that takes any `number`, `string`, `bigint` and converts it to the string.

en/medium-anyof.md

@@ -34,12 +34,10 @@ I don’t like it, take a look:
 
 ```typescript
 type AnyOf<T extends readonly any[], I = T[number]> = (
-  I extends any ?
-  I extends Falsy ?
-  false :
-  true :
-  never
-) extends false ? false : true;
+  I extends any ? (I extends Falsy ? false : true) : never
+) extends false
+  ? false
+  : true;
 ```
 
 So I’ve started thinking, can we make it more maintainable?
@@ -60,16 +58,16 @@ First, we can construct a type that represents false-y types.
 Let’s call it `Falsy`:
 
 ```typescript
-type Falsy = 0 | '' | false | [] | { [P in any]: never }
+type Falsy = 0 | "" | false | [] | { [P in any]: never };
 ```
 
 Having a type that represents false-y values, we can just use a conditional type to check if the `H` extends from the type:
 
 ```typescript
 type AnyOf<T extends readonly any[]> = T extends [infer H, ...infer T]
   ? H extends Falsy
-  ? never
-  : never
+    ? never
+    : never
   : never;
 ```
 
@@ -80,8 +78,8 @@ So we can continue recursively:
 ```typescript
 type AnyOf<T extends readonly any[]> = T extends [infer H, ...infer T]
   ? H extends Falsy
-  ? AnyOf<T>
-  : never
+    ? AnyOf<T>
+    : never
   : never;
 ```
 
@@ -92,8 +90,8 @@ So we just exit from recursion by returning `true` type literal:
 ```typescript
 type AnyOf<T extends readonly any[]> = T extends [infer H, ...infer T]
   ? H extends Falsy
-  ? AnyOf<T>
-  : true
+    ? AnyOf<T>
+    : true
   : never;
 ```
 
@@ -104,21 +102,21 @@ We can return `false` in such case:
 ```typescript
 type AnyOf<T extends readonly any[]> = T extends [infer H, ...infer T]
   ? H extends Falsy
-  ? AnyOf<T>
-  : true
+    ? AnyOf<T>
+    : true
   : false;
 ```
 
 That’s how we made an implementation of `AnyOf` function in the type system.
 For the reference here is the whole implementation:
 
 ```typescript
-type Falsy = 0 | '' | false | [] | { [P in any]: never }
+type Falsy = 0 | "" | false | [] | { [P in any]: never };
 
 type AnyOf<T extends readonly any[]> = T extends [infer H, ...infer T]
   ? H extends Falsy
-  ? AnyOf<T>
-  : true
+    ? AnyOf<T>
+    : true
   : false;
 ```