## What is Fat Arrow Notation in Dart and when do you use it?

In Dart, Fat Arrow Notation, also known as “Arrow Function Syntax” or “Fat Arrow Functions,” is a concise way of defining anonymous functions or closures. It provides a more compact syntax for writing short and simple functions.

The traditional way of defining a function in Dart is with the `functionName() {}`

syntax. However, when you have a function with just a single expression, you can use the Fat Arrow Notation to create the function more concisely.

The syntax for Fat Arrow Notation is as follows:

```
(parameters) => expression;
```

Here’s an example of a regular function and its equivalent using the Fat Arrow Notation:

- Regular function:

```
int add(int a, int b) {
return a + b;
}
```

- Fat Arrow Notation:

```
int add(int a, int b) => a + b;
```

As you can see, the Fat Arrow Notation condenses the function definition into a single line, making it shorter and more readable for simple functions.

When to use Fat Arrow Notation:

Fat Arrow Notation is particularly useful and recommended in the following scenarios:

- For Short Functions: When you have short functions with a single expression, using Fat Arrow Notation makes the code more concise and easier to read.
- For Improved Readability: In some cases, the arrow notation can enhance code readability, especially for functions that perform simple calculations or transformations.
- For Inline Callbacks: When passing callbacks to higher-order functions (e.g.,
`map()`

,`forEach()`

,`where()`

), Fat Arrow Notation can make the code more compact and cleaner.

Example using Fat Arrow Notation in an inline callback:

```
List<int> numbers = [1, 2, 3, 4, 5];
List<int> doubledNumbers = numbers.map((number) => number * 2).toList();
```

While Fat Arrow Notation is helpful for concise code, it’s essential to strike a balance between brevity and readability. For complex functions or functions with multiple statements, it’s often better to use the traditional function syntax for clarity and maintainability.