Arrow Functions

Arrow functions in Dart provide a concise way to write short functions. They're perfect when you need a quick, one-line function without all the ceremony of a full function declaration. Think of them as the "shorthand" version of regular functions!

Arrow functions use the => syntax (called the "fat arrow") to create compact function expressions. They're especially useful for simple operations that can be expressed in a single expression.

Basic Syntax

The basic syntax for arrow functions is:

returnType functionName(parameters) => expression;

Here's a simple example:

// Regular function
int add(int a, int b) {
  return a + b;
}

// Arrow function - much more concise!
int addArrow(int a, int b) => a + b;

When to Use Arrow Functions

Arrow functions are perfect for:

• Simple calculations
• Quick transformations
• Callback functions
• One-line operations

Examples

Let's look at some practical examples:

Simple Mathematical Operations

// Square a number
int square(int x) => x * x;

// Check if a number is even
bool isEven(int number) => number % 2 == 0;

// Get absolute value
int absolute(int x) => x < 0 ? -x : x;

String Operations

// Convert to uppercase
String shout(String text) => text.toUpperCase();

// Get string length
int getLength(String text) => text.length;

// Create greeting
String greet(String name) => 'Hello, $name!';

Working with Collections

Arrow functions shine when working with lists and collections:

void main() {
  List<int> numbers = [1, 2, 3, 4, 5];
  
  // Using arrow functions with map
  List<int> doubled = numbers.map((n) => n * 2).toList();
  print(doubled); // [2, 4, 6, 8, 10]
  
  // Using arrow functions with where (filter)
  List<int> evenNumbers = numbers.where((n) => n % 2 == 0).toList();
  print(evenNumbers); // [2, 4]
  
  // Using arrow functions with forEach
  numbers.forEach((n) => print('Number: $n'));
}

Arrow Functions vs Regular Functions

Arrow Functions	Regular Functions
Single expression only	Multiple statements allowed
Implicit return	Explicit return needed
More concise	More verbose
Great for simple operations	Better for complex logic

Important Notes

1. Single Expression Only: Arrow functions can only contain a single expression, not multiple statements.

// ✅ This works - single expression
int multiply(int a, int b) => a * b;

// ❌ This won't work - multiple statements
int complexOperation(int x) => {
  int result = x * 2;  // This would cause an error
  return result + 1;
};

2. Implicit Return: Arrow functions automatically return the result of the expression - no need for the return keyword.

3. Type Inference: Dart can often infer the return type, but it's good practice to be explicit:

// Type inferred
var getName = (String first, String last) => '$first $last';

// Explicit type (recommended)
String getName(String first, String last) => '$first $last';

Arrow functions make your Dart code cleaner and more readable, especially when dealing with simple operations and functional programming patterns. They're a powerful tool that every Dart developer should master!