Scala Collections : Java 8 on Steroids

Scala Collections : Java 8 on Steroids
François Garillot
Twitter : @huitseeker
francois.garillot@typesafe.com
1

What this talk is
A look at Java 8 gives you
2-a

What this talk is
... and what it doesn’t
2-b

What this talk is
A look at Scala collections
2-c

What this talk is
A look at Scala collections
A look at the why and how of collections
2-d

What this talk is not
New stuﬀ
3-a

New stuﬀ
Rocket Science
3-b

New stuﬀ
Rocket Science
Polemic
3-c

What I’m hoping for
A discussion
4-a

A discussion
Making things a tad more clear
4-b

A discussion
... or just less overlooked ?
4-c

A discussion
... or just less overlooked ?
Not too boring
4-d

What (functional, new things) you can do with Java 8
Lambda-expressions
(String first, String second) ->
Integer.compare(first.length(), second.length)
Functional Interfaces
Runnable r = () -> System.out.println("I am Runnable!");
Method references
button.setOnAction(System.out::println);
Constructor references
List<String> labels = ... ;
Stream<Button> buttonsStream = labels.stream().map(Button::new);
Buttons[] buttonsArray = labels.stream().toArray(Button::new);
int[]::new;
5

The devil is in the details
Optional<T>, Optional.of(), Optional.ofNullable(), Optional.empty()
Default methods in interfaces.
list.forEach(System.out::println)
... beware: SuperClasses win, Interfaces clash. ... And the standard library was not
entirely rewritten (Path/Paths)
Important topics : variable capture in closures, parallel execution.
int[] counter = new int[1];
button.setOnAction(event -> counter[0]++);
6

And also, Streams
Any Collection has a stream()
Stream.of() with a vararg, an array
filter, map, flatMap, as well as plumbing: split, concat, limit
Lazy processing, parallel() processing (you enforce statelessness)
terminal reductions, e.g. reduce
collector:
HashSet<String> result =
stream.collect(HashSet::new, HashSet::add, HashSet::addAll)
Collector implementations (toList, toMap, ...)
counting, maxBy, groupinBy, mapping, ...
Beware: think about reuse.
7

Interlude
Does that make Java a functional programming language ?
8-a

Interlude
First class functions
8-b

Interlude
Technicalities
8-c

Interlude
Technicalities
Does that make Java a Scala competitor ?
8-d

Interlude
Technicalities
Does that make Java a Scala competitor ?
Scala has never had a feature poverty problem.
8-e

What you can’t do with Java 8 (yet)
1. Case classes
2. Pattern matching
3. Tail call elimination
4. Scoped access
5. Lazy keyword
6. Traits (well-scoped)
7. Rich Imports (local, aliased)
8. Macros
9. Backend (Miguel Garcia)
10. Specialization (Vlad Ureche)
11. Value classes
12. Implicits
13. Cake !
9

Collections
The signatures of map
Type classes & implicits
Design goals
10

def map[B](f: (A) ⇒ B) : Map[B]
11-a

But ... Type Constructor Polymorphism
11-b

trait TraversableLike[+Elem, +Coll[+x]] {
def map[NewElem](f: Elem ⇒ NewElem): Coll[NewElem]
def filter(p: Elem ⇒ Boolean): Coll[Elem]
}
11-c

}
The idea that, whatever map needs, it will always deal with:
11-d

}
The idea that, whatever map needs, it will always deal with:
(Collection[Elements],
Elements ⇒ OtherElements,
Collection[OtherElements])
11-e

trait TraversableLike[+Elem, +Repr] {
protected[this] def newBuilder: Builder[Elem, Repr] // deferred
def foreach[U](f: Elem ⇒ U) // deferred
def filter(p: Elem ⇒ Boolean): Repr = {
val b = newBuilder
foreach { elem <- if (p(elem)) b += elem }
b.result
}
}
class Builder[-Elem, +To] {
def +=(elem: Elem): this.type = . . .
def result(): To = . . .
def clear() = . . .
def mapResult[NewTo](f: To ⇒ NewTo): Builder[Elem, NewTo] = . . .
}
12-b

trait TraversableLike[+Elem, +Repr] {
protected[this] def newBuilder: Builder[Elem, Repr] // deferred
def foreach[U](f: Elem ⇒ U) // deferred
def filter(p: Elem ⇒ Boolean): Repr = {
val b = newBuilder
foreach { elem <- if (p(elem)) b += elem }
b.result
}
}
class Builder[-Elem, +To] {
def +=(elem: Elem): this.type = . . .
def result(): To = . . .
def clear() = . . .
def mapResult[NewTo](f: To ⇒ NewTo): Builder[Elem, NewTo] = . . .
}
Why do we care ? Extensibility.
12-c

The signatures of map (cont’d)
13

13-a

def map[B, That](f: ((A,B)) ⇒ B)
(implicit bf:CanBuildFrom[Map[A,B], B, That]):That
13-b

Why ?
13-c

Why ?
Dealing with (Bitset, Int, BitSet) and
(Bitset, String, Set[String])
13-d

Why ?
Dealing with (Bitset, Int, BitSet) and
(Bitset, String, Set[String])
Dealing with (Map[A, B], (A, B)) ⇒ (B, A), Map[B, A]) and
(Map[A, B], (A, B)) ⇒ T, Iterable[T])
13-e

With Implicits
trait CanBuildFrom[-Collection, -NewElem, +Result] {
def apply(from: Collection): Builder[NewElem, Result]
}
trait TraversableLike[+A, +Repr] {
def repr: Repr = . . .
def foreach[U](f: A ⇒ U): Unit = . . .
def map[B, To](f: A ⇒ B)(implicit cbf: CanBuildFrom[Repr, B, To]): To = {
val b = cbf(repr) // get the builder from the CanBuildFrom instance
for (x <- this) b += f(x) // transform element and add
b.result
}
}
14

trait SetLike[+A, +Repr] extends TraversableLike[A, Repr] { }
trait BitSetLike[+This <: BitSetLike[This] with Set[Int]]
extends SetLike[Int, This] {}
trait Traversable[+A] extends TraversableLike[A, Traversable[A]]
trait Set[+A] extends Traversable[A] with SetLike[A, Set[A]]
class BitSet extends Set[Int] with BitSetLike[BitSet]
object Set {
implicit def canBuildFromSet[B] = new CanBuildFrom[Set[_], B, Set[B]] {
def apply(from: Set[_]) = . . .
}
}
object BitSet {
implicit val canBuildFromBitSet = new CanBuildFrom[BitSet, Int, BitSet] {
def apply(from: BitSet) = . . .
}
}
15

Conclusion
A word about design.
16

Scala Collections : Java 8 on Steroids

More Related Content

What's hot (19)

Similar to Scala Collections : Java 8 on Steroids (20)

More from François Garillot (9)

Recently uploaded (20)

Scala Collections : Java 8 on Steroids