Motivation

• Previously used map, fold, filter and bind over Lists
• Composition over lists inefficient

List.list(1, 2, 3, 4)
    .map(i -> i + 10)
    .filter(i -> i % 2 == 0)
    .map(i -> i  * 3);
// List.list(36,42)
						

• Inefficient memory usage - intermediate states
• Build better List
• Laziness improves modularity

Lazy Values

interface F0<A> {
    A f();
}
abstract class P1<A> implements F0<A> {
    abstract A _1();
    A f() {...}
    P1<B> map(F<A, B> f) {...}
    P1<B> bind(F<A, P1<B>> f) {...}
    P1<A> join(P1<P1<A>> p) {...}
    P1<C> liftM2(P1<B> p, F<A, B, C> f) {...}
    // more methods
}
abstract class P2<A, B> {
    abstract A _1();
    abstract B _2();
    // more methods
}

Creating Values

public static P1<A> p(A a) {
    return new P1<A>() {
        A _1() {
            return a;
        }
    };
}
P1<Integer> p1 = P.p(1);

public static P1<A> lazy(F0<A> f) {
    return new P1<A>() {
        A _1() {
            return f.f();
        }
    };
}
P1<Integer> p2 = P.lazy(() -> intFunction());

Lazy Boolean Operations

• Familiar: and, or

static boolean or(boolean b, F0<Boolean> f) {
    return b ? true : f.f();
}
or(true, () -> false);
or(true, () -> expensiveMethod());

static boolean and(boolean b, F0<Boolean> f) {
    return b ? f.f() : false;
}
and(false, () -> expensiveMethod());

					

Lazy If

static A if2(boolean b, F0<A> onTrue, F0<A> onFalse) {
    return b ? onTrue.f() : onFalse.f();
}

if2(false, () -> expensiveMethod(), () -> 3);
					

Cached Lazy Values

• If no effects then can cache result
• memoisation

P1<Integer> p = P.lazy(() -> factorial(100)).memo();
int a = p._1(); // very slow
int b = p._1(); // return calculated value
					

Streams

• A lazy list
• Eager head, lazy tail
• Composed functions on streams use single pass

abstract class Stream<A> {
    abstract A head();
    P1<Stream<A>> tail();

    static Stream<A> stream(A... as) { ... }
    static Stream<A> cons(A head, F0<Stream<A>> tail) { ... }

    <B> Stream<B> map(F<A, B> f) { ... }
    Stream<A> filter(F<A, Boolean> f) { ... }
    <B> B fold(F2<B, A, B> f, B b) { ... }
    <B> Stream<B> bind(F<A, Stream<B>> f) { ... }
}
					

Exercises

static <A> List<A> toList(Stream<A> s);
static <A> Stream<A> take(Stream<A> s, int n);
static <A> Stream<A> takeWhile(Stream<A> s, F<A, Boolean> f);
					

Separation of Concerns

• Laziness separates description from evaluation
• Describe large expression, evaluate part

Short Circuit Example

static <A> boolean exists(Stream<A> s, F<A, Boolean>) {
    if (s.isEmpty()) {
        return false;
    } else {
        return f.f(s.head()) ? true : exists(s.tail()._1(), f);
    }
}
					

Lazy Fold

static <A, B> B foldRight(Stream<A> s, F0<B> acc, F2<F0<B>, A, B> f) {
    if (s.isEmpty()) {
        return acc.f();
    } else {
        return f.f(() -> foldRight(s.tail()._1(), acc, f), s.head());
    }
}

static <A> boolean exists(Stream<A> s, F<A, Boolean> f) {
    return foldRight(s, () -> false, (lb, a) -> f.f(a) || lb.f());
}
					

• A lazy accumulator
• If the head satisfies the function then return
• Reuse foldRight due to laziness
• Strict foldRight requires early termination
• Laziness gives more reuse!

Exercise

• Use foldRight to implement forAll, takeWhile
• Implement map, filter, append and bind using foldRight

Example

F<Integer, Integer> add = i -> i + 10;
F<Integer, Boolean> even = i -> i % 2 == 0;
stream(1, 2, 3, 4).map(add).filter(even).toList();

Stream.cons(11, stream(2, 3, 4).map(add)).filter(even).toList();
Stream.stream(2, 3, 4).map(add).filter(even).toList();
Stream.cons(12, stream(3, 4).map(add)).filter(even).toList();
List.cons(12, stream(3, 4).map(add).filter(even)).toList();
List.cons(12, Stream.cons(13, stream(4).map(add)).filter(even).toList());
List.cons(12, stream(4).map(add).filter(even).toList());
List.cons(12, Stream.cons(14, Stream.nil().map(add)).filter(even).toList());
List.cons(12, List.cons(14, Stream.nil().map(add).filter(even).toList()));
List.cons(12, List.cons(14, List.nil());

					

• Process an element at a time
• Filter and map interleaved
• No intermediate answers, memory efficient
• Streams as first-class loops

Infinite Streams

• Can create infinite streams because tail is lazy
• Only process finite portion

Stream<Integer> s1 = Stream.range(1); // [1, 2, 3, ...]
List<Integer> list = s1.take(5).toList()
Stream<String> s2 = Stream.repeat("a"); // ["a", "a", "a", ...]
					

// assuming existence of cons
static <A> Stream<A> cons(A head, F0<Stream<A>> tail);

static <A> Stream<A> repeat(A a);
static Stream<Integer> from(int i);
static Stream<Integer> range(int low, int high); // [low, high)
static Stream<Integer> fibonacci(int a, int b);
static Stream<A> unfold(S s, F<S, Option<P2<A, S>>> f);
					

Unfold

• Unfold is co-recursive - what?
• Recursion consumes data and terminates
• Co-recursion produces data and is productive (co-terminates)
• Can always evaluate more in finite time

Summary

• Laziness is efficient and modular
• Separate description of infinite expression and evaluation
• Reuse description in different contexts
• Functions can evaluate different portion of infinite stream

Afterword

• Functional Programming in Scala, Chiusano and Bjarnason
• Chapter 5, Strictness and Laziness

Created by Mark Perry, @mprry, G+, Blog, LinkedIn, GitHub, maperry78@yahoo.com.au