From A to L: Designing Scala Libraries

This is a talk I gave for the Dutch Scala Enthusiasts meetup on April 25th 2013. It describes some intermediate-level Scala tips and tricks that I learned while developing an open source Scala library.

Transcript

1. From A to L Designing Scala Libraries Scala features, patterns, idioms, tips and tricks I picked up while reading other people’s library source code and writing my own SCALAPENOS
3. Where do I get these skillz? Writing lots of application code Making lots of mistakes Reading LOTS of Scala library source code Mostly: Spray source code
4. My Library:
5. Why? Most of the existing Scala Riak client libraries were dead projects None of them were compatible with Scala 2.10 or Akka 2.1.x None of them were non-blocking The official Java client library has a very (ugly) Java-ish API The official Java client library is blocking It was the Christmas holidays and I needed a new hobby project
6. “A scalable, highly-available, fault-tolerant, Dynamo-style distributed open-source key/value store” Riak in One Slide:
7. Design Goals: It should be completely non-blocking It should integrate well with Akka It should be simple and easy to use It should be easy to extend The API should be idiomatic Scala
8. Agenda: Type Aliasing Type Classes Context Bounds Manipulating Implicit Resolution Abstract Types vs Type Parameters
9. Type Aliasing
10. Using types external to your library will force you and your users to import those types whenever they need to be instantiated... The Problem:
11. The Solution: Now you and your users only need one import to rule them all!
12. Everyone else is doing it:
13. Type Classes
14. Wikipedia Definition: "... a type system construct that supports ad-hoc polymorphism. This is achieved by adding constraints to type variables in parametrically polymorphic types" Ehm...?
15. Other Definition: "A type of Adapter that uses Scala’s implicits to add some extra capabilities to an existing type without direct coupling" Ehm...?
16. The Problem: It would be nice if there were an easy way to constrain T to something that can be serialized and indexed without forcing users to extend their domain classes from my traits How do I turn a T into a RiakValue?
17. The Solution: Add a Serializer[T] implicit parameter Making the parameter implicit is the big trick that turns RiakSerializer into a type class
18. Not a very pretty solution... There must be a prettier way to specify this?!
19. Context Bounds: Can also be written using a Context Bound: And if you do need a reference to the unnamed implicit parameter, you can get one using implicitly(...)
20. A Nicer Solution: Use implicitly(...) to get a reference to any unnamed implicit value or parameter
21. Some Type Classes They are regular traits. It’s how you use them that makes them type classes.
22. @ImplicitNotFound * MINI TIP *
23. Helps your users understand what the compiler is looking for
24. “But how do I provide default implementations of these type classes without preventing custom implementations?” - Me, two months ago
25. Manipulating Implicit Resolution Implicits Without the Import Tax AND Without Blocking Your Users
26. The Problem: error: ambiguous implicit values: both ... and ... match expected ... When the Scala compiler tells you: When two implicits get resolved at the same level the compiler cannot choose between them
27. Implicit Resolution Rules: Implicits Defined in Current Scope Explicit Imports Wildcard Imports Same Scope in Other Files Companion Objects of a Type Implicit scope of an argument’s type Implicit scope of type arguments Outer Objects for Nested Types Other Dimensions Don’t worry, it’s easier than it sounds!
28. References:
29. References:
30. The Solution: Make sure your default implementations have the lowest possible implicit resolution priority
31. Meanwhile in Predef...
32. ClassTag & TypeTag Manifests 2.0 * MINI TIP * Yet more builtin type classes
33. Type Erasure Erased! No reflection required!
34. Abstract Types Just another way to say [T]
35. When [T] doesn’t make sense: When information about a type is only useful on the inside, don’t bother your users with a type parameter and use abstract types instead
36. That’s all folks!
37. SCALAPENOS Thank You WE ARE LOOKING FOR SCALA DEVELOPERS!!