Table of Contents

• Introduction
• Understanding Index Signatures
  • What is an Index Signature?
  • Defining Index Signatures
  • Common Use Cases
  • Limitations of Index Signatures
• Dynamic Object Typing
  • Using Record Type for Dynamic Objects
  • Using Index Signatures with Dynamic Keys
  • Working with Objects with Varying Properties
• Combining Index Signatures with Other Types
• Practical Examples
• Conclusion

---

Introduction

In TypeScript, objects are a fundamental data structure, and being able to define them dynamically based on keys is crucial for building flexible and scalable applications. Index signatures are a key feature in TypeScript that allow you to define object types with dynamic keys. This enables you to create objects with unknown property names or property names determined at runtime while maintaining type safety.

In this article, we’ll explore index signatures and how to leverage them for dynamic object typing in TypeScript. We’ll also look at how to combine these with other types and their practical applications.

---

Understanding Index Signatures

What is an Index Signature?

An index signature allows you to define the type of property names and their corresponding values for objects with unknown keys. Essentially, an index signature is a way to say “this object can have any number of properties, but each key must be of a specific type, and each value must be of another specified type.”

In TypeScript, index signatures are defined with a specific syntax:

interface MyObject {
  [key: string]: string;
}

This means that any object conforming to the MyObject interface can have any number of string keys, and each key must correspond to a string value.

Defining Index Signatures

You define an index signature in an object type using square brackets [] around the key type (usually string, number, or symbol) and the value type.

Example: Index Signature for Objects with String Keys

interface User {
  [key: string]: string;
}

let user: User = {
  name: "John",
  email: "[email protected]",
  role: "admin"
};

console.log(user.name); // Output: John

In the example above, the User interface uses an index signature to allow dynamic keys of type string, with each value being of type string. Any number of properties can be added to the user object, as long as they follow this structure.

Common Use Cases

Index signatures are commonly used when working with objects whose keys cannot be predetermined, such as:

• Storing user settings where each setting is identified by a unique key.
• Mapping dynamic data such as key-value pairs returned from APIs.
• Handling objects with dynamic property names like configuration files, dictionaries, or logs.

Example: Index Signature for Mapping Key-Value Pairs

interface Settings {
  [key: string]: number;
}

let settings: Settings = {
  volume: 10,
  brightness: 80
};

settings.mute = 0; // Adding new property dynamically

Here, Settings can have any number of properties with string keys and numeric values. As long as the value is a number, it will be accepted.

Limitations of Index Signatures

While index signatures are useful, they come with certain limitations:

1. No specific properties: You cannot define specific properties along with the index signature, unless you use a more restrictive approach like method overloading or combining interfaces.
2. Consistency in value type: All values must adhere to the type defined in the index signature. This means you cannot mix different types for the values of dynamic properties unless you define more flexible types.

---

Dynamic Object Typing

Dynamic object typing refers to the process of working with objects where the structure is flexible and may change over time. The key idea is that the object can have properties that are not known at compile-time but are defined dynamically at runtime.

Using Record Type for Dynamic Objects

TypeScript provides the built-in Record utility type, which is commonly used for creating dynamic objects with known key types and value types. It is essentially a more concise way of writing index signatures.

The Record<K, T> type defines an object where keys are of type K and values are of type T.

Example: Using Record Type

type Product = Record<string, number>;

let productPrices: Product = {
  apple: 1.5,
  banana: 0.8
};

productPrices.orange = 2.0; // Dynamically adding properties

In this example, the Product type is equivalent to an object with any number of string keys and number values.

Using Index Signatures with Dynamic Keys

You can combine index signatures with specific types for the keys to ensure stricter typing.

Example: Dynamic Keys with Limited Options

interface Employee {
  [key: string]: string | number;
}

let employeeDetails: Employee = {
  id: 1234,
  name: "Alice",
  department: "Engineering"
};

employeeDetails.age = 30; // Adding a new property dynamically

This allows you to add dynamic keys to the employeeDetails object, but the values can be either a string or a number.

Working with Objects with Varying Properties

Often, objects have varying properties depending on the context. Index signatures allow you to create objects with such structures while still keeping track of their property types.

Example: Varying Properties for Different User Types

interface Admin {
  role: string;
  permissions: string[];
  [key: string]: string | string[];
}

let admin: Admin = {
  role: "superadmin",
  permissions: ["read", "write"],
  location: "New York"
};

admin.permissions.push("execute"); // Modifying the permissions property

Here, the Admin interface defines both fixed properties (role and permissions) and an index signature, which allows additional properties with keys of type string and values that can be string or string[].

---

Combining Index Signatures with Other Types

You can combine index signatures with other types to create more complex and flexible structures. For instance, you can combine them with union types, intersection types, or even optional properties to define sophisticated objects.

Example: Combining with Union Types

interface StudentGrades {
  [subject: string]: string | number;
}

let grades: StudentGrades = {
  math: 95,
  science: "A",
  history: 88
};

Here, the values can either be a string (like a grade) or a number (like a score). This flexibility allows us to model diverse data structures.

Example: Combining with Optional Properties

interface ProductDetails {
  name: string;
  [key: string]: string | number | undefined;
}

let product: ProductDetails = {
  name: "Laptop",
  price: 1200,
  color: "Silver"
};

In this case, the object can contain properties that are either string, number, or undefined, allowing for more complex and flexible structures.

---

Practical Examples

Example 1: Using Index Signatures for Dynamic API Responses

interface ApiResponse {
  [key: string]: any;
}

let response: ApiResponse = {
  status: 200,
  message: "Request successful",
  data: { userId: 1, userName: "john_doe" }
};

console.log(response.status); // Output: 200
console.log(response.data.userName); // Output: john_doe

Here, we define an ApiResponse interface that can accommodate any number of dynamic keys, making it perfect for working with API responses that can vary in structure.

Example 2: Using Index Signatures for Configuration Settings

interface Config {
  [key: string]: string | number | boolean;
}

let appConfig: Config = {
  theme: "dark",
  version: 1.0,
  isLoggedIn: true
};

appConfig.theme = "light"; // Dynamically updating properties

In this example, the Config interface is used to define a flexible configuration object where values can be string, number, or boolean.

---

Conclusion

Index signatures and dynamic object typing are powerful features in TypeScript that allow developers to define objects with flexible, yet type-safe, structures. By using index signatures, you can handle dynamic keys and values efficiently, while the Record utility type offers a concise syntax for defining dynamic objects.

When combined with other types like unions or optional properties, index signatures can be used to create highly flexible and maintainable code for a variety of use cases, from API responses to configuration management.

By mastering index signatures and dynamic typing, you can write more robust and adaptable TypeScript code.

Table of Contents

• Introduction
• Understanding readonly Properties
  • Basic Usage of readonly
  • Readonly Arrays
  • Preventing Property Re-assignment
• Understanding Optional Properties
  • Basic Usage of Optional Properties
  • Optional Properties with Interfaces
  • Handling Undefined in Optional Properties
• Combining readonly and Optional Properties
• Practical Examples
• Conclusion

---

Introduction

TypeScript offers powerful tools for typing objects, providing a level of flexibility that ensures type safety while maintaining code readability. Two such tools are readonly and optional properties, which enhance the way we define object structures. Readonly properties make an object immutable after its initialization, while optional properties allow properties to be missing or undefined.

In this article, we will explore how to use readonly and optional properties effectively, along with practical examples.

---

Understanding readonly Properties

Basic Usage of readonly

The readonly modifier is used to make properties of an object immutable. Once a property is set, it cannot be changed. This can prevent bugs where properties are accidentally modified after their initial assignment, which is especially useful in large codebases or when working with shared objects.

Example: Using readonly with Object Properties

interface Person {
  readonly name: string;
  age: number;
}

let person: Person = {
  name: "John",
  age: 30
};

person.age = 35; // Valid: age can be reassigned
person.name = "Alice"; // Error: Cannot assign to 'name' because it is a read-only property

In the above example, the name property of the Person object is readonly. Once it is set, any attempt to reassign name will result in an error.

Readonly Arrays

You can also apply the readonly modifier to arrays. This ensures that the array itself and its elements are immutable.

Example: Using readonly with Arrays

let numbers: readonly number[] = [1, 2, 3];
numbers[0] = 4; // Error: Index signature in type 'readonly number[]' only permits reading
numbers.push(5); // Error: Property 'push' does not exist on type 'readonly number[]'.

Here, the numbers array is immutable. Both the elements of the array and any array methods (such as push) that modify the array are not allowed.

Preventing Property Re-assignment

In addition to arrays, the readonly modifier can be used to make individual object properties immutable.

Example: Preventing Property Re-assignment

interface Product {
  readonly id: number;
  name: string;
}

let product: Product = { id: 101, name: "Laptop" };
product.name = "Tablet"; // Valid: name can be reassigned
product.id = 102; // Error: Cannot assign to 'id' because it is a read-only property

In this example, the id property of the Product object cannot be changed once it is assigned.

---

Understanding Optional Properties

Basic Usage of Optional Properties

The ? symbol is used to mark a property as optional. This means that the property can either be present or undefined in an object. Optional properties are especially useful in cases where an object may not have all properties during initialization.

Example: Using Optional Properties

interface Person {
  name: string;
  age?: number; // Optional property
}

let person1: Person = { name: "John" }; // Valid: age is optional
let person2: Person = { name: "Alice", age: 30 }; // Valid: age is provided

In the above example, the age property is optional, so we can create a Person object with or without the age property.

Optional Properties with Interfaces

Optional properties are commonly used with interfaces. These properties allow flexibility in how objects conform to the interface, making the code easier to maintain, especially when dealing with objects that may have variable structures.

Example: Optional Properties in Interfaces

interface Address {
  street: string;
  city?: string; // Optional property
}

let home: Address = { street: "123 Main St" }; // Valid: city is optional

In this case, city is optional, so the home object can either include or omit this property.

Handling Undefined in Optional Properties

When a property is optional, its value can be undefined if not explicitly provided. TypeScript ensures type safety, which means you need to handle cases where the property is missing.

Example: Handling Undefined

interface Product {
  name: string;
  description?: string;
}

let product: Product = { name: "Phone" };

if (product.description) {
  console.log(product.description.length); // Safe: `description` is guaranteed to be defined inside the block
} else {
  console.log("No description available.");
}

Here, description is optional. We check if it’s defined before accessing its properties, ensuring that we don’t encounter a runtime error when trying to access undefined.

---

Combining readonly and Optional Properties

You can combine readonly and optional properties in the same object. This combination is particularly useful in cases where you want to define immutable objects with optional attributes that can be left out or undefined.

Example: Combining readonly and Optional Properties

interface Product {
  readonly id: number;
  name: string;
  description?: string; // Optional property
}

let product: Product = { id: 101, name: "Phone" };
product.name = "Smartphone"; // Valid: name is mutable
product.description = "A high-end smartphone."; // Valid: description can be added
product.id = 102; // Error: Cannot assign to 'id' because it is a read-only property

In this example, id is read-only and cannot be changed after initialization. The description property is optional and can be omitted or updated freely.

---

Practical Examples

Example 1: Readonly and Optional in Function Arguments

function updateProduct(id: number, product: { name: string; readonly price: number; description?: string }) {
  // Cannot change product.price because it's readonly
  console.log(`Updating product ${id}: ${product.name} - Price: ${product.price}`);
}

const product1 = { name: "Laptop", price: 1500, description: "A powerful laptop" };
updateProduct(1, product1); // Valid

product1.price = 1600; // Error: Cannot assign to 'price' because it is a read-only property

Example 2: Optional Properties in Object Merging

interface User {
  name: string;
  email?: string;
}

function createUser(user: User) {
  console.log(`Name: ${user.name}`);
  if (user.email) {
    console.log(`Email: ${user.email}`);
  } else {
    console.log("Email is not provided.");
  }
}

const user1: User = { name: "Alice" };
createUser(user1); // "Email is not provided."

---

Conclusion

In TypeScript, the readonly and optional properties are powerful tools for creating flexible and robust object structures. By using readonly, you ensure that certain properties cannot be modified after their initialization, enhancing immutability and preventing bugs. Optional properties, on the other hand, allow you to define more flexible objects that can accommodate missing or undefined properties.

Combining both readonly and optional properties gives you the ability to define highly adaptable and secure types, allowing you to write safer and more maintainable code.

By leveraging these features, you can better handle complex data structures and avoid common pitfalls that arise from mutable or incomplete objects.

Table of Contents

• Introduction
• Typing Object Structures
  • Basic Object Typing
  • Optional and Required Properties
  • Read-Only Properties
• Typing Nested Objects
  • Nested Object Structures
  • Accessing Nested Properties
• Type Inference in Object Structures
• Using Interfaces with Object Structures
• Combining Object Structures with Union Types and Type Aliases
• Conclusion

---

Introduction

In TypeScript, one of the most powerful features is the ability to provide strict typings for object structures. By specifying exact types for the properties within objects, TypeScript helps prevent common runtime errors, ensures type safety, and provides better auto-completion support in your IDE. As objects are a key part of JavaScript (and TypeScript) programming, mastering how to type them is essential for writing robust and maintainable code.

In this article, we will explore how to type object structures in TypeScript, from basic objects to more complex nested objects, and how to use TypeScript’s various features like interfaces, type aliases, and type inference to handle objects effectively.

---

Typing Object Structures

Basic Object Typing

In TypeScript, you can type an object by specifying the type of its properties. This is done using object literal types or by defining an interface or type alias.

Example: Basic Object Typing

let person: { name: string; age: number } = {
  name: "John",
  age: 30
};

Here, we are defining a person object with two properties: name (a string) and age (a number). TypeScript will enforce this structure, so trying to assign a value with incorrect types will result in a compilation error.

person = {
  name: "Alice",
  age: "30" // Error: '30' is not a number
};

Optional and Required Properties

You can specify whether a property in an object is optional by appending a question mark (?) after the property name. This allows flexibility in object structure without breaking type safety.

Example: Optional Properties

let person: { name: string; age?: number } = {
  name: "John"
};

In this case, the age property is optional. The object person can either have or omit the age property.

Example: Required Properties with Partial Type

You can use Partial<T> to make all properties of an object type optional:

let person: Partial<{ name: string; age: number }> = {
  name: "John"
};

The object can now optionally include both name and age properties, but it doesn’t need to include either.

---

Read-Only Properties

In certain situations, you may want to make a property of an object immutable after its initial assignment. To achieve this, you can use the readonly modifier.

Example: Read-Only Properties

let person: { readonly name: string; age: number } = {
  name: "John",
  age: 30
};

// The following line would cause an error because `name` is read-only:
person.name = "Alice"; // Error: Cannot assign to 'name' because it is a read-only property.

The readonly modifier ensures that the name property cannot be reassigned after the object is initialized.

---

Typing Nested Objects

Nested Object Structures

Objects in TypeScript can also contain nested objects, and you can type these nested structures similarly to how you type top-level objects. When working with nested objects, it’s essential to ensure that TypeScript properly understands the nested structure.

Example: Typing Nested Objects

let person: {
  name: string;
  address: {
    street: string;
    city: string;
    zip: number;
  };
} = {
  name: "John",
  address: {
    street: "123 Main St",
    city: "Springfield",
    zip: 12345
  }
};

In this example, the person object contains a nested object address. The address object itself has three properties: street, city, and zip, each with their corresponding types.

Accessing Nested Properties

Accessing nested properties works the same as accessing top-level properties. TypeScript ensures type safety when accessing these properties.

console.log(person.address.city); // "Springfield"

Attempting to access properties with incorrect types will result in a type error.

console.log(person.address.zip); // Correct
console.log(person.address.city = 123); // Error: Type 'number' is not assignable to type 'string'.

Deeply Nested Objects

When dealing with more deeply nested objects, you can specify the type for each level, just as you would for the top-level object.

Example: Deeply Nested Objects

let company: {
  name: string;
  employees: {
    name: string;
    department: {
      name: string;
      budget: number;
    };
  }[];
} = {
  name: "TechCorp",
  employees: [
    {
      name: "Alice",
      department: {
        name: "Engineering",
        budget: 50000
      }
    },
    {
      name: "Bob",
      department: {
        name: "Marketing",
        budget: 30000
      }
    }
  ]
};

In this case, we have a company object with an employees array. Each employee has a name and a department, and the department itself has a name and a budget.

---

Type Inference in Object Structures

TypeScript is intelligent enough to infer the types of object properties when you initialize the object, even if you don’t explicitly specify the types. However, it’s always a good practice to explicitly type your objects for better clarity and error prevention.

Example: Type Inference in Objects

let person = {
  name: "John",
  age: 30
};

person.name = "Alice"; // Valid
person.age = "30"; // Error: Type 'string' is not assignable to type 'number'.

In the above example, TypeScript infers that person is of type { name: string; age: number } based on the assigned values. However, it still provides type safety, preventing the assignment of a string to the age property.

---

Using Interfaces with Object Structures

Interfaces are often used to define object structures in TypeScript. They provide a flexible way to define the shape of an object, ensuring that the object adheres to a specific contract.

Example: Using Interfaces

interface Address {
  street: string;
  city: string;
  zip: number;
}

interface Person {
  name: string;
  age: number;
  address: Address;
}

let person: Person = {
  name: "John",
  age: 30,
  address: {
    street: "123 Main St",
    city: "Springfield",
    zip: 12345
  }
};

Here, we’ve used the Address and Person interfaces to define the types for the address and person objects. Interfaces allow for easier reuse and more readable code.

---

Combining Object Structures with Union Types and Type Aliases

You can combine object structures with union types and type aliases to create more flexible and reusable types. Union types allow a property to hold one of several possible types, while type aliases provide a more concise way to define complex types.

Example: Union Types with Objects

type Person = {
  name: string;
  age: number | string; // Age can be a number or a string
};

let person1: Person = { name: "John", age: 30 };
let person2: Person = { name: "Alice", age: "Thirty" };

In this example, the age property can accept either a number or a string, making the Person type flexible.

---

Conclusion

Typing object structures and nested objects in TypeScript is an essential skill for ensuring type safety and consistency across your codebase. Whether you are working with simple objects, nested objects, or more complex structures, TypeScript provides powerful tools to define object types and ensure that they are used correctly.

By using features like optional properties, read-only properties, type aliases, interfaces, and union types, you can make your object structures flexible, reusable, and easy to manage. With proper typing, TypeScript helps catch errors early in development, making your code more robust and maintainable.

Table of Contents

• Introduction to Arrow Functions and Regular Functions
• Differences Between Arrow Functions and Regular Functions
  • Syntax Comparison
  • The this Keyword
  • The Arguments Object
• Arrow Functions and Typing in TypeScript
• Regular Functions and Typing in TypeScript
• When to Use Arrow Functions vs Regular Functions
• Conclusion

---

Introduction to Arrow Functions and Regular Functions

In TypeScript (and JavaScript), functions are a fundamental concept. However, the way they are defined and how they behave can vary depending on whether you are using arrow functions or regular functions. Both have unique features and advantages, especially when it comes to their behavior, such as how they handle the this keyword and typing.

In this article, we will compare arrow functions and regular functions in TypeScript, focusing on their syntax, behavior (specifically around this), and how to type them.

---

Differences Between Arrow Functions and Regular Functions

Syntax Comparison

The most apparent difference between arrow functions and regular functions is their syntax.

Arrow Function Syntax

Arrow functions have a more concise syntax, making them ideal for short, one-liner functions. The syntax for arrow functions is as follows:

const add = (a: number, b: number): number => {
  return a + b;
};

Key characteristics:

• No function keyword.
• The arrow (=>) separates the parameters from the body.
• Implicit returns can be used for single-expression functions (no need for braces and the return keyword).

Example of implicit return:

const add = (a: number, b: number): number => a + b;

Regular Function Syntax

Regular functions, on the other hand, use the function keyword to define a function, and the syntax is more verbose:

function add(a: number, b: number): number {
  return a + b;
}

Key characteristics:

• The function keyword is mandatory.
• Requires explicit use of return for returning values.

---

The this Keyword

One of the most critical differences between arrow functions and regular functions is how they handle the this keyword.

Arrow Functions and this

Arrow functions do not have their own this context. Instead, they inherit the this value from the surrounding lexical context. This means that this in an arrow function will refer to the object or scope that contains the arrow function, not the object that calls the function.

Example:

const person = {
  name: 'John',
  greet: function() {
    setTimeout(() => {
      console.log(this.name); // 'John', `this` refers to the person object
    }, 1000);
  }
};

person.greet();

In this example, this inside the arrow function refers to the person object because the arrow function inherits the this from the greet method.

Regular Functions and this

Regular functions, however, have their own this context, which means the value of this is determined by how the function is called.

const person = {
  name: 'John',
  greet: function() {
    setTimeout(function() {
      console.log(this.name); // undefined, because `this` refers to the global object
    }, 1000);
  }
};

person.greet();

In the above example, this inside the regular function refers to the global object (window in the browser or global in Node.js), so this.name is undefined.

To resolve this issue, we could bind the this context explicitly or use an arrow function:

// Using bind
setTimeout(function() {
  console.log(this.name); // 'John', because `this` is explicitly bound
}.bind(this), 1000);

Or:

// Using arrow function
setTimeout(() => {
  console.log(this.name); // 'John', because arrow functions inherit `this`
}, 1000);

---

The Arguments Object

Another important distinction is how the arguments object is handled.

Arrow Functions and the Arguments Object

Arrow functions do not have their own arguments object. Instead, they inherit the arguments from the enclosing function, if available. This is important when you need to access the arguments of a function.

function printArgs() {
  const arrowFunc = () => {
    console.log(arguments); // Inherits `arguments` from `printArgs`
  };
  arrowFunc(1, 2, 3); // [1, 2, 3]
}

printArgs(1, 2, 3);

In this example, the arrowFunc inherits the arguments from the printArgs function.

Regular Functions and the Arguments Object

Regular functions have their own arguments object, which contains all the arguments passed to the function, regardless of how they are defined.

function printArgs() {
  console.log(arguments); // Arguments are available here
}

printArgs(1, 2, 3); // [1, 2, 3]

In this case, arguments is an array-like object that contains all the arguments passed to the function.

---

Arrow Functions and Typing in TypeScript

Arrow functions can be typed in TypeScript just like regular functions. You can specify parameter types, return types, and even define the function signature using the => syntax.

Typing Arrow Functions

const add = (a: number, b: number): number => {
  return a + b;
};

This example specifies the types of the parameters (a and b are numbers) and the return type (number).

You can also use the shorthand syntax if the function body is a single expression:

const add = (a: number, b: number): number => a + b;

Typing Arrow Functions with this Context

If you need to type an arrow function that uses the this context, you can do so by explicitly specifying the type of this. For example, in a method of a class:

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }

  greet = (): void => {
    console.log(`Hello, ${this.name}`);
  };
}

const john = new Person('John');
john.greet(); // 'Hello, John'

In this case, the arrow function greet correctly captures the this context from the Person class.

---

Regular Functions and Typing in TypeScript

Regular functions can also be typed in TypeScript, with a more traditional approach using the function keyword. You can specify parameter types, return types, and even overload the function if needed.

Typing Regular Functions

function add(a: number, b: number): number {
  return a + b;
}

This example is similar to the arrow function, but here, we use the function keyword. The parameter and return types are specified explicitly.

Typing Regular Functions with this Context

When working with this inside regular functions, you can specify the type of this using TypeScript’s this type.

class Person {
  name: string;
  constructor(name: string) {
    this.name = name;
  }

  greet(): void {
    console.log(`Hello, ${this.name}`);
  }
}

const john = new Person('John');
john.greet(); // 'Hello, John'

In this example, this is inferred to be of type Person, since the method is called on an instance of the Person class.

To specify the type of this explicitly, you can use the this type annotation:

function greet(this: Person): void {
  console.log(`Hello, ${this.name}`);
}

Here, the function greet is typed to expect this to be of type Person.

---

When to Use Arrow Functions vs Regular Functions

Use Arrow Functions When:

• You want to preserve the this context from the surrounding lexical scope (e.g., inside event handlers, callbacks, or nested functions).
• You prefer a more concise syntax for short functions.
• You need a single-expression function that can be written with an implicit return.

Use Regular Functions When:

• You need dynamic this binding, particularly in methods where this needs to refer to the object calling the function (such as when the function is used as a method in an object).
• You need to use the arguments object, as arrow functions do not have their own arguments.
• You are working with constructor functions and methods inside classes where dynamic binding of this is important.

---

Conclusion

Arrow functions and regular functions have distinct differences in TypeScript. Arrow functions offer a concise syntax and behave differently with respect to the this keyword, making them ideal for callbacks and functions that require lexical scoping. On the other hand, regular functions provide more flexibility with this binding and the arguments object, making them suitable for methods and cases where dynamic binding is needed.

Understanding when to use each function type is key to writing clean, maintainable, and bug-free TypeScript code. Always consider how this will behave, the need for the arguments object, and whether you need the function to be concise or flexible when choosing between arrow and regular functions.