Krasnyanskiy

def flip[X, Y, Z](f: X => Y => Z): Y => X => Z = {
  x => y => f(y)(x)
}

def foo(a: Int)(b: Long): Boolean = a + b > 10

flip { foo } { 1L } { 10 }

Krasnyanskiy

public int[] merge(int[] left, int[] right) {
    int i = 0;
    int j = 0;
    int k = 0;

    int leftLen = left.length;
    int rightLen = right.length;

    int[] merged = new int[leftLen + rightLen];

Krasnyanskiy

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString

Krasnyanskiy

function min(x, y) {
    return x >= y ? y : x;
}

function isEven(n) {
    if (n < 0)  n = Math.abs(n); // alternative: n = n * -1
    if (n == 0) return true;
    if (n == 1) return false;
    return isEven(n - 2);
}

Krasnyanskiy

The Easy-Peasy-Lemon-Squeezy, Statically-Typed, Purely Functional Programming Workshop for All!

John A. De Goes — @jdegoes

---

Agenda

• Functions
• Types, Kinds, & More Functions
• FP Toolbox

Krasnyanskiy

int sum = asList("abc", "de", "fghij")
                .stream()
                .map(String::length)
                .reduce(0, (x, y) -> x + y);

List<String> list = asList("lbc", "ed", "ighfjka")
                .parallelStream()
                .flatMap(s -> asList(s.split("")).stream())
                .sorted()

Krasnyanskiy

public int foo(int v) {
    int counter = 0;
    switch (v) {
        default: counter += 1;
        case  1: counter += 2;
        case  2: counter += 3;
    }
    return counter;
}

Krasnyanskiy

class User

object User {
  type Aux[I, A] = User {
    type IdType = I
    type Address = A
  }
}

Krasnyanskiy

public class TimestampMap<V> extends HashMap<Timestamp, V> {

    public static <T> TimestampMap<T> of(T... ts) {
        return new TimestampMap<T>() {
            @Override
            public T put(Timestamp k, T v) {
                for (T t : ts) {
                    this.put(now(), t); // potential SO (!) + useless initialization | will super.* fix the SO error?
                }
                return null;

Krasnyanskiy

function findPrime(array) {
    var sieve = [], i, j, max = 1000000;
    for (i = 2; i <= max; ++i) {
        if (!sieve[i]) {
            var parsed = ('' + i).split('').map(function (e) {
                return parseInt(e, 10);
            });
            if (JSON.stringify(parsed) === JSON.stringify(array)) {
                return i;
            }