Community!

Key to Scala's success
Investments:
- Simplify process
- Infrastructure (CI on EC2, standardize build,...)
  - contribute from browser!
- Modularization (more to come in 2.13)
  - community owned (merge PRs, push tag to release)

`java.util.stream.Stream`

/* https://gist.github.com/adriaanm/892d6063dd485d7dd221
Original Java 8 version: 
http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples

$ scala -Xexperimental                                            */
scala> import java.util.stream.{Stream, IntStream}
scala> import java.util.{Arrays, List}

// List<String> myList= Arrays.asList("a1", "a2", "b1", "c2", "c1");
scala> val myList = Arrays.asList("a1", "a2", "b1", "c2", "c1")
myList: java.util.List[String] = [a1, a2, b1, c2, c1]

/*
myList
    .stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);
*/
scala> myList.stream.
         filter(_.startsWith("c")).
         map(_.toUpperCase).
         sorted.
         forEach(println)
C1
C2

/*
Arrays.stream(new int[] {1, 2, 3})
    .map(n -> 2 * n + 1)
    .average()
    .ifPresent(System.out::println);  // 5.0
*/
scala> Arrays.stream(Array(1, 2, 3)).
         map(n => 2 * n + 1).average.ifPresent(println)
5.0


/*
Stream.of("a1", "a2", "a3")
    .map(s -> s.substring(1))
    .mapToInt(Integer::parseInt)
    .max()
    .ifPresent(System.out::println);  // 3
*/
scala> Stream.of("a1", "a2", "a3").
          map[String](_ substring 1).
          mapToInt(Integer.parseInt).
          max.
          ifPresent(println)
3

// wildcard capture is tricky, whence the `map[String]` above
scala> Stream.of("a1", "a2", "a3").map(_ substring 1)
res: java.util.stream.Stream[?0] = ReferencePipeline$3@4ef37659

/*
Stream.of(1.0, 2.0, 3.0)
    .mapToInt(Double::intValue)
    .mapToObj(i -> "a" + i)
    .forEach(System.out::println);
*/
scala> Stream.of(1.0, 2.0, 3.0).mapToInt(_.intValue).
         mapToObj(i => "a" + i).forEach(println)
a1
a2
a3

/*
Stream.of("d2", "a2", "b1", "b3", "c")
    .filter(s -> {
        System.out.println("filter: " + s);
        return s.startsWith("a");
    })
    .sorted((s1, s2) -> {
        System.out.printf("sort: %s; %s\n", s1, s2);
        return s1.compareTo(s2);
    })
    .map(s -> {
        System.out.println("map: " + s);
        return s.toUpperCase();
    })
    .forEach(s -> System.out.println("forEach: " + s));
*/
scala> Stream of ("d2", "a2", "b1", "b3", "c") filter { s =>
           println("filter: " + s)
           s.startsWith("a")
       } sorted { (s1, s2) =>
           println(f"sort: $s1%s; $s2%s\n")
           s1.compareTo(s2)
       } map { s =>
           println("map: " + s)
           s.toUpperCase
       } forEach { s =>
           println("forEach: " + s)
       }
filter: d2
filter: a2
filter: b1
filter: b3
filter: c
map: a2
forEach: A2

SAM Synthesis

scala> Stream of ("d2", "a2", "b1", "b3", "c") filter { s => 
         println(s"filter: $s"); true
       }

// Behind the scenes, scalac generated:
scala> Stream of ("d2", "a2", "b1", "b3", "c") filter { 
    def test$body(s: String): Boolean = println(s"filter: $s"); true

    new Predicate { def test(s: String): Boolean = test$body(s) }
  }

Function subtyping

Java: `Function`'s users must encode expected subtyping

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

Scala: `=>` said how type arguments determine subtyping

def map[R](mapper: T => R): Stream[R]

definition	ensuring fun subtyping
`trait =>[-T, +R]`	`=>[Arg, Res]`
`trait F[T, R]`	`F[_ >: Arg, _ <: Res]`

Scala 2.12 and Beyond

Adriaan @adriaanm Moors

Scala Team Lead

adriaanm.github.io/reveal.js/scala-next.html