real-world scala design patterns
TRANSCRIPT
Between&
ZEROHEROTips & Tricks for the
Intermediate-Level Scala Developer
November 6th 2013
Formerly known as “Real-World Scala Design Patterns"
The Scala Skillz Gap
ZeroAbsolute beginners
heroMartin Odersky
Miles Sabin Viktor Klang
Daniel Spiewak Etc.
Target Audience
???Me
You?
> 50% ?
AgendaType Aliases Classtags Auto-lifted Partial Functions NoStackTrace !Type Classes Context Bounds & implicitly @implicitnotfound low priority default implicits
Tips{Tricks{
“Pattern” is such a big word
Type AliasesTip:
Creating an alternate name for a type, and sometimes for its companion object
“What would that be good for?”You:
Definition:Type Aliases
Type Aliases
When your API refers to external types...
...you force your users (and yourself) to always
have to import those types
Use Case: api usability
Type Aliases
By defining some type aliases in your base
package...
Use Case: api usability
...you give your users (and yourself) these dependencies for free
Use Case: simplificationType Aliases
Sometimes type signatures get in the way of understanding
A few well-placed type aliases can hide that complexity
And it saves a lot of typing too
Use Case: the standard library!Type Aliases
Tip:
ClassTagReflection without the Performance Tax
Mini
ClassTag
Easy access to erased class and type information without the runtime performance overhead
Explanation:
Auto-lifted Partial FunctionsTip:
You’re Probably Already Using This...
Mini
Explanation:Auto-lifted Partial Functions
When reading method signatures such as these:
You would think that you need to do this:
But in fact Scala allows you to do this:
Example:Auto-lifted Partial Functions
Don’t do this:
Auto-lifted Partial FunctionsExample:
Do this:
But watch out for MatchErrors if your partial function is not complete!
NoStackTraceTip:
Exceptions without the Performance Tax
Mini
The NoStackTrace TraitExplanation:
Remember this?
Huh?
For use in scala.util.Failure and other places that require Throwables without necessarily needing stack traces
Type ClassesTrick:
Demystified
Mystic
Type ClassesDefinition:
"A type of Adapter that uses Scala’s implicits to add some extra capabilities to an existing type
without direct coupling"
“Sort of like @Autowire for types...”
- Some guy on the internet
- Me
Type ClassesProblem:
It would be nice if there were an easy way to constrain T to something that can be
(de)serialized without forcing users to extend their domain classes from my traits
How do I turn a T into a RiakValue?
Type Classes
These are just regular Scala traits!
Step 1: define some useful traits
Type Classes
Making the parameter implicit is (most of) the big trick that turns RiakSerializer into a type class
Step 2: use them as implicit parameters
Context Bounds & ImplicitlyTrick:
Mini
Making Type Classes a little Prettier
Context Bounds & ImplicitlyExplanation:
Implicit parameters that look like this:
Can also be written like this:
You can always get a reference to any implicit value or parameter using the implicitly[T] function
Context Bounds & ImplicitlyExplanation:
You can add multiple context bounds to a type
@ImplicitNotFoundTrick:
Think of Your Users!
Mini
@ImplicitNotFoundExplanation:
Remember this?
When the compiler can’t find an implementation in implicit scope, it will complain in vague terms...
@ImplicitNotFoundExplanation:
The compiler errors can sometimes be a little confusing to unsuspecting developers...
@ImplicitNotFoundExplanation:
Ah, much better!
@ImplicitNotFoundExplanation:
Happier, less confused users
Low Priority Default ImplicitsTrick:
Making Type Classes Actually Useful
Final
Why?Low Priority Default Implicits
You want to provide some default implementations of your type classes so your users don’t have to do all the work.
The companion object for your type class is the perfect place for this, but....
Problem:Low Priority Default Implicits
You don't want your users to run into these kinds of problems when they want to override your defaults
Solution:Use the Scala rules for resolving implicits to your advantage
by making sure your defaults have the lowest possible implicit resolution priority
This is a very common trick in Scala libraries
Low Priority Default Implicits
Low Priority Default ImplicitsEven Predef.scala has them!
http://www.slideshare.net/DerekWyatt1/scala-implicits-not-to-be-feared http://danielwestheide.com/blog/2013/02/06/the-neophytes-guide-to-scala-part-12-type-classes.html
Type ClassesFurther Reading:
http://eed3si9n.com/revisiting-implicits-without-import-tax http://docs.scala-lang.org/tutorials/FAQ/finding-implicits.html
Low Priority Default ImplicitsFurther Reading:
