Intermediate factory that creates an Instances trait based on provided Implicits.
Normally, this factory is used as implicit constructor parameter of base classes for companion objects
of RPC traits (e.g. DefaultRestApiCompanion)
or ADTs (e.g. RestDataCompanion).
This all serves to reduce boilerplate associated with companion declarations and makes RPC trait or ADT
definitions as concise as possible. It also lets the programmer easily inject additional implicits into
macro-materialization of typeclasses aggregated by Instances trait.
Instances is a trait that aggregates multiple macro materialized typeclass instances.
There is no fixed interface for Instances, its abstract methods are inspected by
MacroInstances.materialize macro and implemented automatically as <methodReturnTypeCompanion>.materialize
Therefore, return type type of each method must have a companion object which contains materialize macro.
The Implicits type is typically a trait with a collection of implicit definitions whose companion object
implements that trait, e.g. DefaultRestImplicits.
When the macro implements apply method of MacroInstances contents of Implicits are imported into the
body of apply and visible further by macros that materialize InstancesTrait.
If you don't want to inject additional implicits, declare Implicits as Unit.
If MacroInstances is accepted as implicit super constructor parameter of a companion object
(which is the typical situation) then this reference should be passed as companion.
This is in order to work around https://github.com/scala/bug/issues/7666.
Actual typeclass instances aggregated by Instances trait should be extracted into implicit lazy val
definitions in the companion base class. See e.g. RestDataCompanion
for an example of how it's done.
Intermediate factory that creates an
Instancestrait based on providedImplicits. Normally, this factory is used as implicit constructor parameter of base classes for companion objects of RPC traits (e.g. DefaultRestApiCompanion) or ADTs (e.g. RestDataCompanion). This all serves to reduce boilerplate associated with companion declarations and makes RPC trait or ADT definitions as concise as possible. It also lets the programmer easily inject additional implicits into macro-materialization of typeclasses aggregated byInstancestrait.Instancesis a trait that aggregates multiple macro materialized typeclass instances. There is no fixed interface forInstances, its abstract methods are inspected byMacroInstances.materializemacro and implemented automatically as<methodReturnTypeCompanion>.materializeTherefore, return type type of each method must have a companion object which containsmaterializemacro.Example of
Instances: ClientInstancesThe
Implicitstype is typically a trait with a collection of implicit definitions whose companion object implements that trait, e.g. DefaultRestImplicits. When the macro implementsapplymethod ofMacroInstancescontents ofImplicitsare imported into the body ofapplyand visible further by macros that materializeInstancesTrait. If you don't want to inject additional implicits, declareImplicitsasUnit.If
MacroInstancesis accepted as implicit super constructor parameter of a companion object (which is the typical situation) thenthisreference should be passed ascompanion. This is in order to work around https://github.com/scala/bug/issues/7666. Actual typeclass instances aggregated byInstancestrait should be extracted intoimplicit lazy valdefinitions in the companion base class. See e.g. RestDataCompanion for an example of how it's done.