Dart - 34 - Functional Programming Concepts

Functional Programming Concepts in Dart

Functional programming is a paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data. Dart, a versatile programming language, supports key functional programming concepts that enable developers to write more concise and expressive code. In this discussion, we’ll explore essential functional programming concepts in Dart, including pure functions, immutability, higher-order functions, and more, with practical examples.

Pure Functions

Pure functions are at the core of functional programming. They are functions that always produce the same output for the same input and have no side effects, meaning they don’t modify any external state. In Dart, pure functions are important for predictable and testable code.

Here’s an example of a pure function in Dart:


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

void main() {
    final result = add(3, 4);
    print(result); // Output: 7
}

Immutability

Immutability is the concept of not changing the state of data after it’s created. In functional programming, immutable data structures are preferred. In Dart, you can create immutable objects using `final` and `const` keywords.

Here’s an example of using `final` for immutability in Dart:


void main() {
    final List numbers = [1, 2, 3, 4];
    // numbers.add(5); // Error: Cannot add to an unmodifiable list.
}

Higher-Order Functions

Higher-order functions are functions that can accept other functions as parameters or return functions as results. They enable functional operations on collections and promote code reusability.

Here’s an example of a higher-order function in Dart:


void forEach(List numbers, void Function(int) action) {
    for (var number in numbers) {
        action(number);
    }
}

void main() {
    final numbers = [1, 2, 3, 4, 5];
    forEach(numbers, (number) {
        print(number);
    });
}

First-Class Functions

In Dart, functions are first-class citizens, which means they can be assigned to variables, passed as arguments to other functions, and returned from functions. This enables dynamic and reusable code.

Here’s an example of first-class functions in Dart:


void greet(String name) {
    print('Hello, $name!');
}

void main() {
    final Function sayHello = greet;
    sayHello('Alice'); // Output: Hello, Alice!
}

Map, Filter, and Reduce

Functional programming often involves operations like mapping, filtering, and reducing collections. Dart provides higher-order functions for these operations, making data transformations more concise.

Here’s an example of mapping in Dart:


void main() {
    final numbers = [1, 2, 3, 4, 5];
    final doubledNumbers = numbers.map((number) => number * 2);
    print(doubledNumbers); // Output: (2, 4, 6, 8, 10)
}

Recursion

Recursion is a technique where a function calls itself to solve a problem. It’s used extensively in functional programming. In Dart, recursive functions can be elegant for solving complex problems.

Here’s an example of a recursive function to calculate factorial in Dart:


int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

void main() {
    final result = factorial(5);
    print(result); // Output: 120
}

Lambda Expressions

Dart supports lambda expressions (anonymous functions), which are concise and often used in functional programming. They can be handy for creating short, one-off functions.

Here’s an example of using lambda expressions in Dart:


void main() {
    final List numbers = [1, 2, 3, 4, 5];
    final evenNumbers = numbers.where((number) => number % 2 == 0);
    print(evenNumbers); // Output: (2, 4)
}

Conclusion

Functional programming concepts in Dart offer powerful tools for writing expressive and efficient code. By understanding and applying concepts such as pure functions, immutability, higher-order functions, and more, you can write code that is more predictable, testable, and maintainable.

Dart – 34 – Functional Programming Concepts