I recommend you to have a quick overview on it.
Type-safe composition of interceptors : Premises
Briefly, we'll just see how the first "future work" as been addressed. That is, avoid boilerplate for interceptors composition.
A quick recall, when we had to compose such Interceptors we had to take care our-selves of the validation results and the combined result (tuple or whatever).
The real problem that is under the sea here, is that tuples are not so easily generalizable (no append method, roughly).
So I decided to use the Shapeless library (thx to @milessabin).
Shapeless has an amazing core structure that enables type-and-value chaining (somehow). The HList type is a kind of list but each element is one value and one type. For instance, it has the head value and the Head type on top of the Stack. Here is the kind of stuffs that we can do with Shapeless:
val | = false
val thisIsNotAPipe = "this" :: 15 :: false :: "a" :: | :: HNil
> thisIsNotAPipe: shapeless.::[java.lang.String,shapeless.::[Int,shapeless.::[Boolean,shapeless.::[java.lang.String,shapeless.::[Boolean,shapeless.HNil]]]]] = this :: 15 :: false :: a :: false :: HNil
>Type-safe list of stuffs<
While trying to use HList generically I had problem with the implicits that are needed to prepend two lists, but StackOverflow has brought me the answer here.
I'm not gonna tackle here how I did, by I'll demonstrate what is now possible with the new composition functionalities added to Interceptors.
First of all, I had to declare an Interceptor for HList and the related implicit conversion. After what, I added three methods:
- hlist this method on Intercept is able to convert a classical one to a HList one
- ~::~ this one is available to compose any interceptors that is not defined using HList with an HList one. It will create a new Interceptor with the new composed HList as result
- ~:::~ this one enable to compose two Interceptor defined with HList, the results will be the concatanation of the two HList.
Note: concatanation of HLists preserves the type sequence, actually we can see that as if it concat two lists of values and two list of types.
Let's see how we can deal with them:
Easy no? Combine interceptors and use compile-time type-checking to validate the required kinds of items.