Higher-Order Functions

Here’s a collection of 20 programs that showcase the use of Higher-Order Functions in Dart. Each example highlights a different way higher-order functions can be used.

1. Basic Example: Passing a Function as an Argument

void execute(Function action) {

 action();

}

void main() {

 execute(() => print("Hello, Dart!")); // Output: Hello, Dart!

}

2. Returning a Function

Function greet(String name) {

 return () => print("Hello, $name!");

}

void main() {

 var greetJohn = greet("John");

 greetJohn(); // Output: Hello, John!

}

4. Transforming a List with map

void main() {

 var numbers = [1, 2, 3];

 var squares = numbers.map((number) => number * number).toList();

 print(squares); // Output: [1, 4, 9]

}

5. Filtering a List with where

void main() {

 var numbers = [10, 15, 20, 25];

 var evens = numbers.where((number) => number.isEven).toList();

 print(evens); // Output: [10, 20]

}

6. Combining with reduce

void main() {

 var numbers = [1, 2, 3, 4];

 var sum = numbers.reduce((a, b) => a + b);

 print(sum); // Output: 10

}

7. Using fold with Initial Value

void main() {

 var numbers = [1, 2, 3];

 var product = numbers.fold(1, (prev, element) => prev * element);

 print(product); // Output: 6

}

8. Custom Filter Function

List<int> filter(List<int> list, bool Function(int) condition) {

 return list.where(condition).toList();

}

void main() {

 var numbers = [1, 2, 3, 4, 5];

 print(filter(numbers, (n) => n > 3)); // Output: [4, 5]

}

9. Chaining map and where

void main() {

 var numbers = [1, 2, 3, 4];

 var result = numbers.where((n) => n.isEven).map((n) => n * n).toList();

 print(result); // Output: [4, 16]

}

10. Sorting with a Custom Comparator

void main() {

 var fruits = ["apple", "banana", "cherry"];

 fruits.sort((a, b) => b.length.compareTo(a.length));

 print(fruits); // Output: [banana, cherry, apple]

}

11. Using a Timer with a Higher-Order Function

import 'dart:async';

void delayExecution(Duration duration, Function action) {

 Timer(duration, action);

}

void main() {

 delayExecution(Duration(seconds: 2), () => print("Action executed!"));

}

12. Creating a Function Wrapper

Function wrapFunction(Function fn) {

 return () => print("Wrapped: ${fn()}");

}

void main() {

 var wrapped = wrapFunction(() => "Hello");

 wrapped(); // Output: Wrapped: Hello

}

13. Using List any

void main() {

 var numbers = [1, 2, 3];

 var hasEven = numbers.any((n) => n.isEven);

 print(hasEven); // Output: true

}

14. Using List every

void main() {

 var numbers = [2, 4, 6];

 var allEven = numbers.every((n) => n.isEven);

 print(allEven); // Output: true

}

15. Partitioning a List

void partition(List<int> list, bool Function(int) condition) {

 var pass = list.where(condition).toList();

 var fail = list.where((x) => !condition(x)).toList();

 print("Pass: $pass, Fail: $fail");

}

void main() {

 partition([1, 2, 3, 4], (n) => n.isEven);

 // Output: Pass: [2, 4], Fail: [1, 3]

}

16. Custom Transform Function

List<T> transform<T>(List<int> list, T Function(int) transformer) {

 return list.map(transformer).toList();

}

void main() {

 var result = transform([1, 2, 3], (n) => "Number $n");

 print(result); // Output: [Number 1, Number 2, Number 3]

}

17. Function Composition

Function compose(Function f, Function g) {

 return (x) => f(g(x));

}

void main() {

 var doubleIt = (int x) => x * 2;

 var square = (int x) => x * x;

 var doubleThenSquare = compose(square, doubleIt);

 print(doubleThenSquare(3)); // Output: 36

}

18. Reusable Retry Logic

void retry(Function action, int attempts) {

 for (int i = 0; i < attempts; i++) {

   try {

     action();

     return;

   } catch (e) {

     print("Attempt ${i + 1} failed.");

   }

 }

}

void main() {

 retry(() => print("Trying..."), 3);

}

19. Conditional Execution

void conditionalExecute(bool condition, Function action) {

 if (condition) action();

}

void main() {

 conditionalExecute(5 > 3, () => print("Condition met!")); // Output: Condition met!

}

20. Debouncing

Function debounce(Function action, Duration delay) {

 Timer? timer;

 return () {

   if (timer != null) timer!.cancel();

   timer = Timer(delay, action);

 };

}

void main() {

 var debouncedAction = debounce(() => print("Debounced!"), Duration(seconds: 2));

 debouncedAction();

 debouncedAction(); // Only the last one will execute

}

A function can accept other functions as parameters or return a function. 

void main() {

 // A function that accepts a function as a parameter

 void applyFunction(int num, Function operation) {

   print("Result: ${operation(num)}");

 }

 // Passing different functions as arguments

 applyFunction(5, (x) => x * x); // Passing a lambda function

 applyFunction(5, (x) => x + 10); // Another lambda function

}

------------------------------------------------------------------------------------------------------------------------------------------------------------------

A higher-order function is a function that either takes one or more functions as arguments or returns a function as its result. These functions are powerful for building flexible, reusable code.

1. Using map to Transform a List

void main() {

 List<int> numbers = [1, 2, 3, 4];

 List<int> squares = numbers.map((n) => n * n).toList();

 print(squares); // Output: [1, 4, 9, 16]

}

2. Using filter to Get Even Numbers from a List

void main() {

 List<int> numbers = [1, 2, 3, 4, 5, 6];

 List<int> evens = numbers.where((n) => n % 2 == 0).toList();

 print(evens); // Output: [2, 4, 6]

}

3. Passing a Function as a Parameter

void main() {

 void performOperation(int a, int b, int Function(int, int) operation) {

   print("Result: ${operation(a, b)}");

 }

 performOperation(5, 3, (a, b) => a + b); // Output: Result: 8

 performOperation(5, 3, (a, b) => a * b); // Output: Result: 15

}

4. Using reduce to Sum Elements in a List

void main() {

 List<int> numbers = [1, 2, 3, 4];

 int sum = numbers.reduce((a, b) => a + b);

 print("Sum: $sum"); // Output: Sum: 10

}

5. Creating a Function That Returns Another Function

void main() {

 Function multiplier(int factor) {

   return (int x) => x * factor;

 }

 var triple = multiplier(3);

 print(triple(4)); // Output: 12

}

6. Using forEach to Print List Elements

void main() {

 List<String> names = ["Alice", "Bob", "Charlie"];

 names.forEach((name) => print("Hello, $name!"));

 // Output:

 // Hello, Alice!

 // Hello, Bob!

 // Hello, Charlie!

}

7. Applying Multiple Functions Using map

void main() {

 List<String> words = ["dart", "flutter", "programming"];

 List<String> capitalizedWords = words.map((word) => word.toUpperCase()).toList();

 print(capitalizedWords); // Output: [DART, FLUTTER, PROGRAMMING]

}

8. Custom applyTwice Function

void main() {

 int applyTwice(int x, int Function(int) f) => f(f(x));

 int doubleValue(int x) => x * 2;

 print(applyTwice(5, doubleValue)); // Output: 20

}

9. Using sort with a Custom Comparator

void main() {

 List<int> numbers = [10, 5, 20, 3];

 numbers.sort((a, b) => b.compareTo(a)); // Sorting in descending order

 print(numbers); // Output: [20, 10, 5, 3]

}

10. Function That Executes a Given Function Multiple Times

void main() {

 void repeatTask(int times, Function task) {

   for (int i = 0; i < times; i++) {

     task();

   }

 }

 repeatTask(3, () => print("Hello!"));

 // Output:

 // Hello!

 // Hello!

 // Hello!

}

These examples demonstrate the use of higher-order functions in Dart. Functions like map, where, forEach, and reduce are examples of built-in higher-order functions. Additionally, creating custom higher-order functions, such as applyTwice or repeatTask, adds flexibility to your code.