Upgrade to Pro — share decks privately, control downloads, hide ads and more …

From A to L: Designing Scala Libraries

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.


Age Mooij

April 26, 2013

More Decks by Age Mooij

Other Decks in Programming


  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
  2. None
  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!