Generic arrow functions in Typescript - Mini Project: Build & Apply

Generic Arrow Functions

📖 Scenario: You are building a small utility in TypeScript to work with different types of data. You want to create a generic arrow function that can take any type of input and return it unchanged. This is useful when you want to write flexible code that works with many data types.

🎯 Goal: Create a generic arrow function called identity that takes a value of any type and returns the same value. Then test it with a string and a number.

📋 What You'll Learn

Create a generic arrow function named identity with a type parameter T.

The function should take one parameter value of type T and return a value of type T.

Call identity with a string and store the result in resultString.

Call identity with a number and store the result in resultNumber.

Print both resultString and resultNumber.

💡 Why This Matters

🌍 Real World

Generic functions help write reusable code that works with many data types, saving time and reducing errors.

💼 Career

Understanding generics is important for TypeScript developers to build flexible and type-safe applications.

1

Create a generic arrow function

Create a generic arrow function called identity with a type parameter T. It should take one parameter value of type T and return the same value.

Typescript

# Your code here

Hint

Use the syntax const identity = <T>(value: T): T => value; to create a generic arrow function.

2

Call the generic function with a string

Call the generic arrow function identity with the string "Hello" and store the result in a variable called resultString.

Typescript

const identity = (value: T): T => value;
# Your code here

Hint

Call identity with "Hello" and specify the type string.

3

Call the generic function with a number

Call the generic arrow function identity with the number 42 and store the result in a variable called resultNumber.

Typescript

const identity = (value: T): T => value;
const resultString = identity("Hello");
# Your code here

Hint

Call identity with 42 and specify the type number.

4

Print the results

Print the values of resultString and resultNumber using two separate console.log statements.

Typescript

const identity = (value: T): T => value;
const resultString = identity("Hello");
const resultNumber = identity(42);
# Your code here

Hint

Use console.log(resultString); and console.log(resultNumber); to print the results.

Practice

1.

What does the <T> represent in a generic arrow function in TypeScript?

easy

A. A variable name for a function parameter

B. A placeholder for a type that will be specified later

C. A keyword to declare a constant

D. A special operator for comparison

Solution

1. Step 1: Understand generic type parameters

   The <T> syntax declares a generic type parameter, which acts as a placeholder for any type.

2. Step 2: Recognize its purpose in functions

   This allows the function to work with different types while keeping type safety.

3. Final Answer:

   A placeholder for a type that will be specified later -> Option B

4. Quick Check:

   Generic type parameter = placeholder type [OK]

Hint: Think of <T> as a flexible type placeholder [OK]

Common Mistakes:

• Confusing <T> with a variable name
• Thinking <T> is a keyword like const or let
• Assuming <T> is an operator

2.

Which of the following is the correct syntax for a generic arrow function that returns the same type it receives?

?

easy

A. const identity = <T> = (arg: T): T => arg;

B. const identity = <T>: (arg: T) => T => arg;

C. const identity = <T>(arg: T): T => arg;

D. const identity = <T> (arg: T) => { return arg; };

Solution

1. Step 1: Check generic arrow function syntax

   The generic type parameter <T> must come immediately after the function name without an equals sign.

2. Step 2: Verify arrow function structure

   The function takes an argument of type T and returns the same type T. const identity = <T>(arg: T): T => arg; matches this syntax correctly.

3. Final Answer:

   const identity = <T>(arg: T): T => arg; -> Option C

4. Quick Check:

   Correct generic arrow function syntax = const identity = <T>(arg: T): T => arg; [OK]

Hint: Generic syntax: const fn = <T>(arg: T): T => ... [OK]

Common Mistakes:

• Adding an equals sign after <T>
• Misplacing parentheses around <T>
• Using incorrect arrow function syntax

3.

What will be the output of this TypeScript code?

const wrapInArray = <T>(value: T): T[] => [value];

console.log(wrapInArray(5));
console.log(wrapInArray('hello'));

medium

A. [5]
['hello']

B. 5
hello

C. [5, 'hello']

D. Error: Type mismatch

Solution

1. Step 1: Understand the generic function behavior

   The function wrapInArray takes a value of any type T and returns an array containing that value.

2. Step 2: Analyze the console.log outputs

   Calling wrapInArray(5) returns [5], and wrapInArray('hello') returns ['hello'].

3. Final Answer:

   [5] ['hello'] -> Option A

4. Quick Check:

   Generic function returns array with input value [OK]

Hint: Generic function wraps input in array, output matches input type [OK]

Common Mistakes:

• Expecting output without array brackets
• Thinking it returns a tuple
• Confusing types causing errors

4.

Identify the error in this generic arrow function and choose the corrected version:

const getFirst = <T> = (arr: T[]): T => {
  return arr[0];
};

medium

A. const getFirst = <T> (arr: T[]): T => { return arr[0]; };

B. const getFirst = (arr: T[]): T => arr[0];

C. const getFirst = <T>: (arr: T[]) => T => arr[0];

D. const getFirst = <T>(arr: T[]): T => arr[0];

Solution

1. Step 1: Identify incorrect syntax in original code

   The original code incorrectly uses an equals sign after <T>, which is not valid syntax for generic arrow functions.

2. Step 2: Choose the correct syntax

   const getFirst = <T>(arr: T[]): T => arr[0]; correctly places <T> immediately after the function name without an equals sign and uses concise arrow function syntax.

3. Final Answer:

   const getFirst = <T>(arr: T[]): T => arr[0]; -> Option D

4. Quick Check:

   Generic arrow function syntax = const getFirst = <T>(arr: T[]): T => arr[0]; [OK]

Hint: No equals sign after <T> in generic arrow functions [OK]

Common Mistakes:

• Adding equals sign after <T>
• Omitting generic parameter <T>
• Incorrect arrow function syntax

5.

Given this generic arrow function, what is the output of mergeObjects({a: 1}, {b: 2})?

const mergeObjects = <T, U>(obj1: T, obj2: U): T & U => ({ ...obj1, ...obj2 });

console.log(mergeObjects({a: 1}, {b: 2}));

hard

A. { a: 1, b: 2 }

B. { a: 1 }

C. { b: 2 }

D. TypeError at runtime

Solution

1. Step 1: Understand the generic parameters and return type

   The function takes two objects of types T and U and returns their intersection type T & U, meaning it combines properties from both.

2. Step 2: Analyze the spread operator usage

   The spread operator merges properties from both objects into a new object containing all keys and values.

3. Step 3: Predict the output of the console.log

   Calling mergeObjects({a: 1}, {b: 2}) returns { a: 1, b: 2 }.

4. Final Answer:

   { a: 1, b: 2 } -> Option A

5. Quick Check:

   Spread merge of two objects = combined object [OK]

Hint: Spread operator merges objects, output has all keys [OK]

Common Mistakes:

• Expecting only first or second object properties
• Confusing intersection type with union
• Thinking it causes runtime error