Getting started with Functional Programming

Functional Programming in Dart by @passsy (Pascal Welsch)
Functional Programming in Dart
Pascal Welsch
Google Developer Expert
CTO at phntm GmbH
Co-Founder of wiredash.io
Droidcon London 2022
@passsy

View Slide


View Slide

Pascal Welsch
CTO at phntm GmbH
@passsy

View Slide

PHNTM
['fæntəm]
Flutter Agency with 15 Flutter Experts from all across Germany

View Slide

You won’t learn today
- Either, Task
- Monads, Functors
- Composition, pipelining
- Pattern matching
- Algebraic data types
- Tail-recursion

View Slide

You’ll learn today
Function programming basics:
- 🍀 Pure functions
- 🥶 Immutable data structures
- 🌼 First-class functions
- 🌸 High-order functions
Outlook what the Dart team is working on

View Slide

Dart and Functional Programming?
“Dart is a class-based, single-inheritance,
pure object-oriented programming language.”
ECMA-408 - 6. Overview

View Slide


View Slide

List _products = [];
SortOrder sortOrder = SortOrder.desc;
SortField sortField = SortField.price;

View Slide

class Product {
final String name;
final int price;
final int originalPrice;
final double rating;
int get discount => originalPrice - price;
}

View Slide

enum SortOrder {
asc,
desc,
}
enum SortField {
name,
price,
discount,
rating,
}

View Slide


View Slide

…
label: InkWell(
onTap: () {
if (sortField == field) {
// same field, just flip the sort order
sortOrder = sortOrder.flip();
} else {
// field changed, reset sort order
sortOrder = SortOrder.desc;
sortField = field;
}

View Slide

…
label: InkWell(
onTap: () {
if (sortField == field) {
// same field, just flip the sort order
sortOrder = sortOrder.flip();
} else {
// field changed, reset sort order
sortOrder = SortOrder.desc;
sortField = field;
}
// sort the products based on the new sort order
// TODO: update _products
}

View Slide

The naive approach
Use Dart built-in List.sort([int compare(E a,E b)?]) function
Compare products by selected property using
Comparable.compareTo(T other): int
if (SortField.discount == sortField) {
_products.sort((a, b) {
return sortOrder == SortOrder.asc
? a.discount.compareTo(b.discount)
: b.discount.compareTo(a.discount);
});
}

View Slide

switch (sortField) {
case SortField.name:
? a.name.compareTo(b.name)
: b.name.compareTo(a.name);
case SortField.discount:
case SortField.price:
? a.price.compareTo(b.price)
: b.price.compareTo(a.price);
case SortField.rating:
? a.rating.compareTo(b.rating)
: b.rating.compareTo(a.rating);
}
});
Today’s task:
Let’s make this
code functional 🥷

View Slide

Functional Programming

View Slide

Functions
Also called:
Lambda, Closure, Method, Callback, Routine,
Subtypes (but still just functions):
top-level, anonymous, predicate, high-order, first-class, …

View Slide

String formatPrice(int cents) {...}
Input Output
12 0.12€
100 1.00€
2000 20.00€

View Slide

MoneyFormatter globalEuroFormatter;
Input Output
12 + globalEuroFormatter 0.12€ || -,12€
100 + globalEuroFormatter 1.00€ || 1€
2000 + globalEuroFormatter 20.00€ || 20,00€ || 20EUR

View Slide

MoneyFormatter globalEuroFormatter;
Input Output
12 + globalEuroFormatter 0.12€ || -,12€ + globalEuroFormatter
100 + globalEuroFormatter 1.00€ || 1€ + globalEuroFormatter
2000 + globalEuroFormatter 20.00€ || 20,00€ || 20EUR + globalEuroFormatter

View Slide

🍀 pure function
No side-effects
Doesn’t mutate the input
Always returns the same result for the same input
Does not call an impure function
Can be replaced with a lookup table
But why?

View Slide

Pure Function Advantages
Can be executed in any order
Can be executed in parallel
Results can be cached, or pre-computed at compile time
Easy to test in isolation
Easy to focus on, no surprises
Requirement:
Only use immutable data structures

View Slide

🥶 Immutable data structures
final list = [1, 2, 3];
list.add(4); // mutation: Bad
// Good: make a copy
final copy = [...list, 4];

View Slide

Immutable data structures
final user = User(id: '27', name: 'Pascal', email: '[email protected]');
user.email = '[email protected]'; // Bad, email is mutable
// Better, make a copy
final updatedUser = user.copyWith(email: '[email protected]');
// user.email: '[email protected]' (unchanged)
// updatedUser.email: '[email protected]'

View Slide

Immutable packages

View Slide


View Slide

Functional Programming Style
Avoid mutations
Avoid side-effects

View Slide

}
});

View Slide

}
});
Mutation of _products
Access of class property sortOrder

View Slide

// Extract pure function
List sortProducts(List products, SortField sortField, SortOrder sortOrder) {
// make a copy, mutation of inputs isn’t pure
final copy = products.toList();
copy.sort((a, b) {
// …
}
});
// return an immutable list
return List.unmodifiable(copy);
}
// Call the pure function
_products = sortProducts(_products, sortField, sortOrder);

View Slide

// Extract pure function
// ...
}
// Call the pure function

View Slide

// ...
}

View Slide

// Use our existing sort code
copy.sort((a, b) {
// …
}
});
}
What a nice,
pure function!

View Slide

Pure Function Advantages
Can be executed in any order
Can be executed in parallel
Results can be cached, or pre-computed at compile time
Easy to test in isolation
Easy to focus on, no surprises

View Slide

Level 1 completed: You learned the concept of pure functions!

View Slide

Functions
Pascal Welsch

View Slide

🌼 High order functions
A higher-order function is a function that takes functions as parameters, or
returns a function.
// Takes a function as input
Result myFunction(Function fn) {
// …
}
// Returns a function
Function myFunction() {
// …
}
// both, input and output are functions
Function myFunction(Function fn) {
// …
}

View Slide

// Let’s refactor!
List getProductsWith4StarPlusRating() {
final List result = [];
for (final product in _products) {
if (product.rating > 4) {
result.add(product);
}
}
return result;
}

View Slide

}
}
return result;
}

View Slide

List getProductsWithRating(double minRating) {
if (product.rating > minRating) {
}
}
return result;
}

View Slide

}
}
return result;
}

View Slide

List getProducts(bool Function(Product) predicate) {
if (predicate(product)) {
}
}
return result;
}
getProducts((product) => product.rating > 4);

View Slide

List getProducts(bool Function(Product) predicate) {
if (predicate(product)) {
}
}
return result;
}
_products.where((product) => product.rating > 4);

View Slide

// List getProducts(bool Function(Product) predicate) {
// final List result = [];
// for (final product in _products) {
// if (predicate(product)) {
// result.add(product);
// }
// }
// return result;
// }
//
// getProducts((product) => product.rating > 4);
// getProducts((product) => product.rating > 3);

View Slide


View Slide

}
}
return result;
}
}
}
return result;
}

View Slide

Isn’t creating lambdas
like (product) => product.rating > 4
expensive at scale?

View Slide

Function references
// function as lambda
bool has4StarPlusRating(Product product) {
return product.rating > 4;
}
// function reference
_products.where(has4StarPlusRating);

View Slide

🌸 Functions as first-class citizens
Functions can be stores in variables and data structures and can be passed as
arguments or returned from higher-order functions
bool has4StarPlusRating(Product product) {
return product.rating > 4;
}
final bool Function(Product) savedFunction = has4StarPlusRating;
final List list = [has4StarPlusRating, has3StarPlusRating];
list.add((Product) => true);

View Slide

copy.sort((a, b) {
// …
}
});
}

View Slide

// replace switch case with long nested if-else
if (sortOrder == SortOrder.asc) {
copy.sort((a, b) => a.discount.compareTo(b.discount));
} else {
copy.sort((a, b) => b.discount.compareTo(a.discount));
}
} else {
// …
}
}

View Slide

copy.sort((a, b) => a.discount.compareTo(b.discount));
} else {
copy.sort((a, b) => b.discount.compareTo(a.discount));
}
} else {
// …
}
}

View Slide

late int Function(Product a, Product b) compare;
compare = (a, b) => a.discount.compareTo(b.discount);
} else {
compare = (a, b) => b.discount.compareTo(a.discount);
}
} else {
// …
}
copy.sort(compare);
}

View Slide

} else {
}
} else {
// …
}
copy.sort(compare);
}

View Slide

final Map sortFunctionsByFieldAsc = {
SortField.rating: (a, b) => a.rating.compareTo(b.rating),
SortField.name: (a, b) => a.name.compareTo(b.name),
SortField.discount: (a, b) => a.discount.compareTo(b.discount),
SortField.price: (a, b) => a.price.compareTo(b.price),
};
} else {
}
} else {
// …
}
copy.sort(compare);

View Slide

} else {
}
} else {
// …
}
copy.sort(compare);
}
};

View Slide

final Function(Product a, Product b) compare = sortFunctionsByFieldAsc[sortField]!;
copy.sort(compare);
}
};

View Slide

var Function(Product a, Product b) compare = sortFunctionsByFieldAsc[sortField]!;
if (sortOrder == SortOrder.desc) {
compare = compare.reverse;
}
copy.sort(compare);
}
};
extension Reverse on int Function(T, T) {
int Function(T, T) get reverse => (a, b) => this(b, a);
}

View Slide

var compare = sortFunctionsByFieldAsc[sortField]!;
}
return List.unmodifiable(products.toList()..sort(compare));
}
};
}

View Slide

Vanilla Dart solution
}
}
};
}

View Slide

What about
functional programming
dart packages?

View Slide

}
}
};
}

View Slide

import 'package:kt_dart/kt.dart';
compare = compare.reverse();
}
}
};
// extension Reverse on int Function(T, T) {
// int Function(T, T) get reverse => (a, b) => this(b, a);
// }

View Slide

import 'package:dartx/dartx.dart';
compare = compare.reverse();
}
// return List.unmodifiable(products.toList()..sort(compare));
return products.sortedWith(comparator);
}
};
// extension Reverse on int Function(T, T) {
// int Function(T, T) get reverse => (a, b) => this(b, a);
// }

View Slide

var comparator = sortFunctionsByFieldAsc[sortField]!;
comparator = compare.reverse();
}
}
};

View Slide

var comparator = compareBy(fieldSelectors[sortField]!);
comparator = comparator.reverse();
}
}
final Map fieldSelectors = {
SortField.rating: (it) => it.rating,
SortField.name: (it) => it.name,
SortField.discount: (it) => it.discount,
SortField.price: (it) => it.price,
};

View Slide

var comparator = compareBy(fieldSelectors[sortField]!);
comparator = comparator.reverse();
}
}
final Map fieldSelectors = {
SortField.rating: (it) => it.rating,
SortField.name: (it) => it.name,
SortField.discount: (it) => it.discount,
SortField.price: (it) => it.price,
};
Functional darty solution

View Slide

}
});
The naive approach

View Slide

Convinced,
that FP is better?

View Slide

Functional Code >>> Imperative Code
Easy to test
Pure functions can’t be flaky - by design
Easy to debug
Easy to refactor
Thread-safe by design, easy to parallelize

View Slide

Is Dart good choice for Functional Programming?
Pro
- Functions are first-class citizens
- one-line lambdas are supported
- Immutable references (final)
- Generics
- Extension functions
- Type inference
Cons
- No immutable collections
- No algebraic data types (unions)
- No pattern matching
- Many dart:core functions have
side-effects and throw exceptions
- Lambda are quite verbose

View Slide

Functional Programming -
a new tool in your toolbox

View Slide

Dart and Functional Programming?
“Dart is a class-based, single-inheritance,
pure object-oriented programming language.”
ECMA-408 - 6. Overview

View Slide


View Slide

A bright functional future for Dart?
“Patterns and related features” is in the “impl” phase (dart-lang/language/546)

View Slide


View Slide

Immutable data structures
No official support by Dart.
Use kt_dart or fast_immutable_collection

View Slide

You learned today
Function programming basics:
- 🍀 Pure functions - no side effects. input -> output
- 🥶 Immutable data structures - freezed, kt_dart
- 🌼 First-class functions - function are like objects
- 🌸 High-order functions
// both, input and output can be functions
Function myFunction(Function fn) {…}

View Slide

Do yourself a favour and
write more functional code.
Thank me later
Pascal Welsch 👋

View Slide

Pascal Welsch
CTO at phntm GmbH
@passsy

View Slide

Getting started with Functional Programming

Getting started with Functional Programming

Pascal Welsch

More Decks by Pascal Welsch

Other Decks in Programming

Featured

Transcript