trait Ops extends AnyRef
This trait has some nice methods for working with implicit Ops
classes. It is used to rewrite implicit conversions which "enrich"
a type with operators into code that does not allocate an implicit
instance.
- Alphabetic
- By Inheritance
- Ops
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Abstract Value Members
-
abstract
def
operatorNames: Map[String, String]
Map of symbolic -> textual name conversions.
Map of symbolic -> textual name conversions.
If this map is empty, the macros will not do any special rewriting and all names will be passed through.
Symbolic names should be written as Scala would represent them internally. For example,
+
should be written as$plus
.
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
binop[A, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A]): scala.reflect.macros.whitebox.Context.Expr[R]
Given context and an expression, this method rewrites the tree to call the "desired" method with the lhs and rhs parameters.
Given context and an expression, this method rewrites the tree to call the "desired" method with the lhs and rhs parameters. We find the symbol which is applying the macro and use its name to determine what method to call.
If we see code like:
lhs + rhs
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev).$plus(rhs: A): R
The macro should produce trees like:
ev.method(lhs: A, rhs: A): R
-
def
binopWithEv[A, Ev, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A])(ev: scala.reflect.macros.whitebox.Context.Expr[Ev]): scala.reflect.macros.whitebox.Context.Expr[R]
Like binop, but with ev provided to the method instead of to the implicit constructor.
Like binop, but with ev provided to the method instead of to the implicit constructor.
If we see code like:
lhs % rhs
After typing and implicit resolution, we get trees like:
conversion(lhs).$percent(rhs)(ev)
The macro should produce trees like:
ev.mod(lhs, rhs)
-
def
binopWithLift[A, Ev, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A])(ev1: scala.reflect.macros.whitebox.Context.Expr[Ev])(implicit arg0: scala.reflect.macros.whitebox.Context.WeakTypeTag[A]): scala.reflect.macros.whitebox.Context.Expr[R]
Combine an implicit enrichment with a lifting method.
Combine an implicit enrichment with a lifting method.
If we see code like:
lhs + 1
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev0).$plus(1)(ev1): R
The macro should produce trees like:
ev0.plus(lhs, ev1.fromInt(1))
In Spire, this lets us use
Ring
's fromInt method andConvertableTo
'sfromDouble
(etc.) before applying an op. Eventually, we should generalize the way we choose the lifting method. -
def
binopWithScalar[A, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A]): scala.reflect.macros.whitebox.Context.Expr[R]
Like binop, but where the implementation comes from a child member
Like binop, but where the implementation comes from a child member
If we see code like:
lhs * rhs
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev).$times(rhs)
The macro should produce trees like:
ev.scalar.times(lhs, rhs)
-
def
binopWithSelfLift[A, Ev, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A])(implicit arg0: scala.reflect.macros.whitebox.Context.WeakTypeTag[A]): scala.reflect.macros.whitebox.Context.Expr[R]
This is like binopWithLift, but we use the same evidence parameter to make the method call and do the lifting.
This is like binopWithLift, but we use the same evidence parameter to make the method call and do the lifting.
If we see code like:
lhs * 2
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev).$times(2): R
The macro should produce trees like:
ev.times(lhs, ev.fromInt(2))
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
findMethodName(c: Context): scala.reflect.macros.Universe.TermName
Provide a canonical mapping between "operator names" used in
Ops
classes and the actual method names used for type classes.Provide a canonical mapping between "operator names" used in
Ops
classes and the actual method names used for type classes.It's worth noting that a particular instance of
Ops
must always map a given symbol a single method name. If you want to be able to map the same symbol to different names in different contexts, you'll need to create multipleOps
instances and configure them appropriately.In general "textual" method names should just pass through to the typeclass--it is probably not wise to provide mappings for them here.
-
def
flip[A, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A]): scala.reflect.macros.whitebox.Context.Expr[R]
Similar to binop, but for situations where there is no evidence parameter, and we just want to call a method on the rhs.
Similar to binop, but for situations where there is no evidence parameter, and we just want to call a method on the rhs.
After typing and implicit resolution, we get trees like:
conversion(lhs).foo(rhs)
and we want to get out:
rhs.foo(lhs)
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
handleBinopWithChild[A, R](c: Context)(rhs: scala.reflect.macros.whitebox.Context.Expr[A])(childName: String): scala.reflect.macros.whitebox.Context.Expr[R]
Provided to make defining things like binopWithScalar easier.
- def handleUnopWithChild[R](c: Context)(childName: String): scala.reflect.macros.whitebox.Context.Expr[R]
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
rbinop[A, R](c: Context)(lhs: scala.reflect.macros.whitebox.Context.Expr[A]): scala.reflect.macros.whitebox.Context.Expr[R]
Like binop, but for right-associative operators (eg.
Like binop, but for right-associative operators (eg.
+:
).If we see code like:
lhs *: rhs
After typing and implicit resolution, we get trees like:
conversion(rhs)(ev).$times$colon(lhs)
The macro should produce trees like:
ev.timesl(lhs, rhs)
-
def
rbinopWithEv[A, Ev, R](c: Context)(lhs: scala.reflect.macros.whitebox.Context.Expr[A])(ev: scala.reflect.macros.whitebox.Context.Expr[Ev]): scala.reflect.macros.whitebox.Context.Expr[R]
Like rbinop, but with ev provided to the method instead of to the implicit constructor.
Like rbinop, but with ev provided to the method instead of to the implicit constructor.
If we see code like:
lhs *: rhs
After typing and implicit resolution, we get trees like:
conversion(rhs).$times$colon(lhs)(ev)
The macro should produce trees like:
ev.timesl(lhs, rhs)
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
unop[R](c: Context)(): scala.reflect.macros.whitebox.Context.Expr[R]
Given context, this method rewrites the tree to call the desired method with the lhs parameter.
Given context, this method rewrites the tree to call the desired method with the lhs parameter. We find the symbol which is applying the macro and use its name to determine what method to call.
If we see code like:
-lhs
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev).unary_-(): R
The macro should produce trees like:
ev.negate(lhs): R
-
def
unop0[R](c: Context): scala.reflect.macros.whitebox.Context.Expr[R]
A variant of unop which doesn't take an empty parameter list.
-
def
unopWithEv[Ev, R](c: Context)(ev: scala.reflect.macros.whitebox.Context.Expr[Ev]): scala.reflect.macros.whitebox.Context.Expr[R]
Like unop, but with ev provided to the method instead of to the implicit constructor.
Like unop, but with ev provided to the method instead of to the implicit constructor.
If we see code like:
lhs.abs
After typing and implicit resolution, we get trees like:
conversion(lhs).abs(ev: Ev): R
The macro should produce trees like:
ev.abs(lhs): R
-
def
unopWithEv2[Ev1, R](c: Context)(ev1: scala.reflect.macros.whitebox.Context.Expr[Ev1]): scala.reflect.macros.whitebox.Context.Expr[R]
Like unop and unopWithEv, but there is ev provided by the implicit constructor, and ev1 provided by the method.
Like unop and unopWithEv, but there is ev provided by the implicit constructor, and ev1 provided by the method.
If we see code like:
lhs.isId
After typing and implicit resolution, we get trees like:
conversion(lhs)(ev: Ev).isId(ev1: Ev1): R
The macro should produce trees like:
ev.isId(lhs)(ev1): R
- def unopWithScalar[R](c: Context)(): scala.reflect.macros.whitebox.Context.Expr[R]
- def unopWithScalar0[R](c: Context): scala.reflect.macros.whitebox.Context.Expr[R]
-
def
unpack[T[_], A](c: Context): (scala.reflect.macros.Universe.Tree, scala.reflect.macros.Universe.Tree)
Given context, this method pulls the 'ev' and 'lhs' values out of instantiations of implicit -
Ops
classes.Given context, this method pulls the 'ev' and 'lhs' values out of instantiations of implicit -
Ops
classes.For instance, given a tree like:
new FooOps(x)(ev)
This method would return
(ev, x)
. -
def
unpackWithoutEv(c: Context): scala.reflect.macros.Universe.Tree
Given context, this method pulls the 'lhs' value out of instantiations of implicit -
Ops
classes.Given context, this method pulls the 'lhs' value out of instantiations of implicit -
Ops
classes.For instance, given a tree like:
new FooOps(x)
This method would return
x
. -
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @throws( ... )
Inherited from AnyRef
Inherited from Any
Macros
Macro transformations for operators