What is a Higher-Order Function in Dart?

A higher-order function is a function that can take other functions as parameters, return a function as a result, or both. This concept is a fundamental aspect of functional programming and allows for more abstract and flexible code. In Dart, functions are first-class citizens, meaning they can be treated like any other variable.

Characteristics of Higher-Order Functions

• Accepting Functions as Arguments: Higher-order functions can take one or more functions as parameters.
• Returning Functions: They can also return a function as their result.
• Creating Abstractions: Higher-order functions enable the creation of more abstract and reusable code.

1. Example of a Higher-Order Function Accepting Functions as Arguments

In this example, we define a higher-order function called performOperation that takes two integers and a function as parameters. The function parameter defines the operation to be performed on the integers.

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

int subtract(int a, int b) {
    return a - b;
}

int performOperation(int a, int b, int Function(int, int) operation) {
    return operation(a, b); // Calling the passed function
}

void main() {
    int sum = performOperation(5, 3, add);
    int difference = performOperation(5, 3, subtract);
    
    print('Sum: $sum'); // Output: Sum: 8
    print('Difference: $difference'); // Output: Difference: 2
}

2. Example of a Higher-Order Function Returning a Function

In this example, we define a higher-order function called makeMultiplier that returns a function. The returned function multiplies its input by a specified factor.

Function makeMultiplier(int factor) {
    return (int value) => value * factor; // Returning a function
}

void main() {
    var multiplyByTwo = makeMultiplier(2); // Creating a function that multiplies by 2
    var multiplyByThree = makeMultiplier(3); // Creating a function that multiplies by 3

    print(multiplyByTwo(5)); // Output: 10
    print(multiplyByThree(5)); // Output: 15
}

3. Using Built-in Higher-Order Functions

Dart's collection classes provide several built-in higher-order functions, such as map, forEach, and reduce. These functions allow you to perform operations on collections in a functional style.

void main() {
    List<int> numbers = [1, 2, 3, 4, 5];

    // Using map to create a new list with each number multiplied by 2
    var doubled = numbers.map((number) => number * 2).toList();
    print('Doubled: $doubled'); // Output: Doubled: [2, 4, 6, 8, 10]

    // Using forEach to print each number
    numbers.forEach((number) {
        print('Number: $number');
    });
}
</int>

Conclusion

Higher-order functions are a powerful feature in Dart that enable you to write more abstract and reusable code. By allowing functions to accept other functions as parameters or return functions, you can create flexible and expressive code structures. Understanding higher-order functions is essential for effective functional programming in Dart.