Scala Compiler2.12.21 < Back
 

# Packages

-  package root

  The Scala compiler and reflection APIs.

  The Scala compiler and reflection APIs.

  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package reflect
  Definition Classes
    scala
-  package reify
  Definition Classes
    reflect
-  package codegen
  Definition Classes
    reify
-  package phases
  Definition Classes
    reify
-  package utils
  Definition Classes
    reify
- Errors
- Phases
- Reifier
- States
- Taggers

c

scala.reflect.reify

# Reifier 

###

#### abstract class Reifier extends States with Phases with Errors with Utils

Given a tree or a type, generate a tree that when executed at runtime produces the original tree or type. See more info in the comments to `reify` in scala.reflect.api.Universe.

Source
  Reifier.scala
Since

  2.10

Linear Supertypes
Utils, StdAttachments, SymbolTables, Extractors, NodePrinters, Errors, Phases, Reify, GenUtils, GenPositions, GenAnnotationInfos, GenTrees, GenNames, GenTypes, GenSymbols, Metalevels, Calculate, Reshape, States, AnyRef, Any
Known Subclasses
ApplyReifier, Reifier, UnapplyReifier
 
Ordering

1. Alphabetic
2. By Inheritance

Inherited

1. Reifier
2. Utils
3. StdAttachments
4. SymbolTables
5. Extractors
6. NodePrinters
7. Errors
8. Phases
9. Reify
10. GenUtils
11. GenPositions
12. GenAnnotationInfos
13. GenTrees
14. GenNames
15. GenTypes
16. GenSymbols
17. Metalevels
18. Calculate
19. Reshape
20. States
21. AnyRef
22. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Instance Constructors

1.  new Reifier()

### Type Members

1.  class State extends AnyRef
   Definition Classes
     States
2.  case class Reification(name: tools.nsc.Global.Name, binding: tools.nsc.Global.Tree, tree: tools.nsc.Global.Tree) extends Product with Serializable
   Definition Classes
     GenSymbols
3.  implicit class RichCalculateSymbol extends AnyRef
   Definition Classes
     Calculate
4.  implicit class RichCalculateType extends AnyRef
   Definition Classes
     Calculate
5.  sealed abstract class FreeDefExtractor extends AnyRef
   Definition Classes
     Extractors
6.  case class ReifyAliasAttachment(sym: tools.nsc.Global.Symbol, alias: tools.nsc.Global.TermName) extends Product with Serializable
   Definition Classes
     StdAttachments
7.  case class ReifyBindingAttachment(binding: tools.nsc.Global.Tree) extends Product with Serializable
   Definition Classes
     StdAttachments
8.  class SymbolTable extends AnyRef
   Definition Classes
     SymbolTables

### Abstract Value Members

1.  abstract val concrete: Boolean
2.  abstract val global: Global
   Definition Classes
     Reifier → Utils
3.  abstract val mirror: tools.nsc.Global.Tree
4.  abstract val reifee: Any
5.  abstract val typer: (analyzer)#Typer
   Definition Classes
     Reifier → Utils
6.  abstract val universe: tools.nsc.Global.Tree

### Concrete Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from Reifier to any2stringadd[Reifier] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  def ->[B](y: B): (Reifier, B)
   Implicit
     This member is added by an implicit conversion from Reifier to ArrowAssoc[Reifier] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
5.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
6.  def CannotConvertManifestToTagWithoutScalaReflect(tpe: tools.nsc.Global.Type, manifestInScope: tools.nsc.Global.Tree): Nothing
   Definition Classes
     Errors
7.  def CannotReifyCompoundTypeTreeWithNonEmptyBody(ctt: tools.nsc.Global.CompoundTypeTree): Nothing
   Definition Classes
     Errors
8.  def CannotReifyErroneousPrefix(prefix: tools.nsc.Global.Tree): Nothing
   Definition Classes
     Errors
9.  def CannotReifyErroneousReifee(reifee: Any): Nothing
   Definition Classes
     Errors
10.  def CannotReifyInvalidLazyVal(tree: tools.nsc.Global.ValDef): Nothing
    Definition Classes
      Errors
11.  def CannotReifyRuntimeSplice(tree: tools.nsc.Global.Tree): Nothing
    Definition Classes
      Errors
12.  def CannotReifyType(tpe: tools.nsc.Global.Type): Nothing
    Definition Classes
      Errors
13.  def CannotReifyUntypedPrefix(prefix: tools.nsc.Global.Tree): Nothing
    Definition Classes
      Errors
14.  def CannotReifyUntypedReifee(reifee: Any): Nothing
    Definition Classes
      Errors
15.  def CannotReifyWeakType(details: Any): Nothing
    Definition Classes
      Errors
16.  final def asInstanceOf[T0]: T0
    Definition Classes
      Any
17.  def boundSymbolsInCallstack: List[tools.nsc.Global.Symbol]
    Definition Classes
      Reify
18.  val calculate: tools.nsc.Global.Traverser { ... /* 2 definitions in type refinement */ }

    Merely traverses the reifiee and records symbols local to the reifee along with their metalevels.

    Merely traverses the reifiee and records symbols local to the reifee along with their metalevels.

    Definition Classes
      Calculate
19.  def call(fname: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
20.  def clone(): AnyRef
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
21.  def current: Any
    Definition Classes
      Reify
22.  def currents: List[Any]
    Definition Classes
      Reify
23.  def defaultErrorPosition: tools.nsc.Global.Position
    Definition Classes
      Errors
24.  def ensuring(cond: (Reifier) ⇒ Boolean, msg: ⇒ Any): Reifier
    Implicit
      This member is added by an implicit conversion from Reifier to Ensuring[Reifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
25.  def ensuring(cond: (Reifier) ⇒ Boolean): Reifier
    Implicit
      This member is added by an implicit conversion from Reifier to Ensuring[Reifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
26.  def ensuring(cond: Boolean, msg: ⇒ Any): Reifier
    Implicit
      This member is added by an implicit conversion from Reifier to Ensuring[Reifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
27.  def ensuring(cond: Boolean): Reifier
    Implicit
      This member is added by an implicit conversion from Reifier to Ensuring[Reifier] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
28.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
29.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
30.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
31.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
32.  def getReifier: Reifier { val global: Reifier.this.global.type }
    Definition Classes
      Reifier → Utils
33.  def hasReifier: Boolean
    Definition Classes
      Reifier → Utils
34.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
35.  def isCrossStageTypeBearer(tree: tools.nsc.Global.Tree): Boolean
    Definition Classes
      GenUtils
36.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
37.  def isSemiConcreteTypeMember(tpe: tools.nsc.Global.Type): Boolean
    Definition Classes
      GenUtils
38.  val metalevels: tools.nsc.Global.Transformer { ... /* 4 definitions in type refinement */ }

    Makes sense of cross-stage bindings.

    Makes sense of cross-stage bindings.

    Analysis of cross-stage bindings becomes convenient if we introduce the notion of metalevels. Metalevel of a tree is a number that gets incremented every time you reify something and gets decremented when you splice something. Metalevel of a symbol is equal to the metalevel of its definition.

    Example 1. Consider the following snippet:

    reify { val x = 2 // metalevel of symbol x is 1, because it's declared inside reify val y = reify{x} // metalevel of symbol y is 1, because it's declared inside reify // metalevel of Ident(x) is 2, because it's inside two reifies y.splice // metalevel of Ident(y) is 0, because it's inside a designator of a splice }

    Cross-stage bindings are introduced when symbol.metalevel != curr_metalevel. Both bindings introduced in Example 1 are cross-stage.

    Depending on what side of the inequality is greater, the following situations might occur:

    1) symbol.metalevel < curr_metalevel. In this case reifier will generate a free variable that captures both the name of the symbol (to be compiled successfully) and its value (to be run successfully). For example, x in Example 1 will be reified as follows: Ident(newFreeVar("x", IntTpe, x))

    2) symbol.metalevel > curr_metalevel. This leads to a metalevel breach that violates intuitive perception of splicing. As defined in macro spec, splicing takes a tree and inserts it into another tree - as simple as that. However, how exactly do we do that in the case of y.splice? In this very scenario we can use dataflow analysis and inline it, but what if y were a var, and what if it were calculated randomly at runtime?

    This question has a genuinely simple answer. Sure, we cannot resolve such splices statically (i.e. during macro expansion of `reify`), but now we have runtime toolboxes, so noone stops us from picking up that reified tree and evaluating it at runtime (in fact, this is something that `Expr.splice` does transparently).

    This is akin to early vs late binding dilemma. The prior is faster, plus, the latter (implemented with reflection) might not work because of visibility issues or might be not available on all platforms. But the latter still has its uses, so I'm allowing metalevel breaches, but introducing the -Xlog-runtime-evals to log them.

    upd. We no longer do that. In case of a runaway `splice` inside a `reify`, one will get a static error. Why? Unfortunately, the cute idea of transparently converting between static and dynamic splices has failed. 1) Runtime eval that services dynamic splices requires scala-compiler.jar, which might not be on library classpath 2) Runtime eval incurs a severe performance penalty, so it'd better to be explicit about it

    As we can see, the only problem is the fact that lhs'es of `splice` can be code blocks that can capture variables from the outside. Code inside the lhs of an `splice` is not reified, while the code from the enclosing reify is.

    Hence some bindings become cross-stage, which is not bad per se (in fact, some cross-stage bindings have sane semantics, as in the example above). However this affects freevars, since they are delicate inter-dimensional beings that refer to both current and next planes of existence. When splicing tears the fabric of the reality apart, some freevars have to go single-dimensional to retain their sanity.

    Example 2. Consider the following snippet:

    reify { val x = 2 reify{x}.splice }

    Since the result of the inner reify is wrapped in a splice, it won't be reified together with the other parts of the outer reify, but will be inserted into that result verbatim.

    The inner reify produces an Expr[Int] that wraps Ident(freeVar("x", IntTpe, x)). However the freevar the reification points to will vanish when the compiler processes the outer reify. That's why we need to replace that freevar with a regular symbol that will point to reified x.

    Example 3. Consider the following fragment:

    reify { val x = 2 val y = reify{x} y.splice }

    In this case the inner reify doesn't appear next to splice, so it will be reified together with x. This means that no special processing is needed here.

    Example 4. Consider the following fragment:

    reify { val x = 2 { val y = 2 val z = reify{reify{x + y}} z.splice }.splice }

    The reasoning from Example 2 still holds here - we do need to inline the freevar that refers to x. However, we must not touch anything inside the splice'd block, because it's not getting reified.

    Definition Classes
      Metalevels
39.  def mirrorBuildCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
40.  def mirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
41.  def mirrorFactoryCall(prefix: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
42.  def mirrorFactoryCall(value: Product, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
43.  def mirrorMirrorCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
44.  def mirrorMirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
45.  def mirrorSelect(name: tools.nsc.Global.TermName): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
46.  def mirrorSelect(name: String): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
47.  def mkList(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
48.  def mkListMap(args: List[tools.nsc.Global.Tree]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
49.  lazy val mkReificationPipeline: (tools.nsc.Global.Tree) ⇒ tools.nsc.Global.Tree
    Definition Classes
      Phases
50.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
51.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
52.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
53.  def origin(sym: tools.nsc.Global.Symbol): String
    Definition Classes
      GenUtils
54.  def path(fullname: String, mkName: (String) ⇒ tools.nsc.Global.Name): tools.nsc.Global.Tree

    An (unreified) path that refers to definition with given fully qualified name

    An (unreified) path that refers to definition with given fully qualified name

    mkName

      Creator for last portion of name (either TermName or TypeName)

    Definition Classes
      GenUtils
55.  lazy val reification: tools.nsc.Global.Tree

    For `reifee` and other reification parameters, generate a tree of the form

    For `reifee` and other reification parameters, generate a tree of the form

        {
          val $u: universe.type = <[ universe ]>
          val $m: $u.Mirror = <[ mirror ]>
          $u.Expr[T](rtree)       // if data is a Tree
          $u.TypeTag[T](rtree)    // if data is a Type
        }

    where

    - `universe` is the tree that represents the universe the result will be bound to.
    - `mirror` is the tree that represents the mirror the result will be initially bound to.
    - `rtree` is code that generates `reifee` at runtime.
    - `T` is the type that corresponds to `data`.

    This is not a method, but a value to indicate the fact that Reifier instances are a one-off.

56.  def reificationIsConcrete: Boolean

    Keeps track of whether this reification contains abstract type parameters

    Keeps track of whether this reification contains abstract type parameters

    Definition Classes
      GenTypes
57.  lazy val reifier: Reifier { val global: Reifier.this.global.type }
    Definition Classes
      Utils
58.  def reify(reifee: Any): tools.nsc.Global.Tree

    Reifies any supported value.

    Reifies any supported value. For internal use only, use `reified` instead.

    Definition Classes
      Reify
59.  def reifyAnnotationInfo(ann: tools.nsc.Global.AnnotationInfo): tools.nsc.Global.Tree
    Definition Classes
      GenAnnotationInfos
60.  def reifyBinding(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      StdAttachments
61.  def reifyBuildCall(name: tools.nsc.Global.TermName, args: Any*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
62.  val reifyCopypaste: Boolean
    Definition Classes
      Utils
63.  val reifyDebug: Boolean
    Definition Classes
      Utils
64.  def reifyFlags(flags: tools.nsc.Global.FlagSet): tools.nsc.Global.Tree
    Definition Classes
      GenTrees
65.  def reifyFreeTerm(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
66.  def reifyFreeType(binding: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
67.  def reifyList(xs: List[Any]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
68.  def reifyMirrorObject(x: Product): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
69.  def reifyMirrorObject(name: String): tools.nsc.Global.Tree

    Reify a case object defined in Mirror

    Reify a case object defined in Mirror

    Definition Classes
      GenUtils
70.  def reifyModifiers(m: tools.nsc.Global.Modifiers): tools.nsc.Global.Tree
    Definition Classes
      GenTrees
71.  def reifyName(name: tools.nsc.Global.Name): tools.nsc.Global.Tree
    Definition Classes
      GenNames
72.  def reifyPosition(pos: tools.nsc.Global.Position): tools.nsc.Global.Tree
    Definition Classes
      GenPositions
73.  def reifyProduct(prefix: String, elements: List[Any]): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
74.  def reifyProduct(x: Product): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
75.  def reifySymDef(sym: tools.nsc.Global.Symbol): tools.nsc.Global.Tree
    Definition Classes
      GenSymbols
76.  def reifySymRef(sym: tools.nsc.Global.Symbol): tools.nsc.Global.Tree

    Reify a reference to a symbol

    Reify a reference to a symbol

    Definition Classes
      GenSymbols
77.  val reifyTrace: SimpleTracer
    Definition Classes
      Utils
78.  def reifyTree(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree

    Reify a tree.

    Reify a tree. For internal use only, use `reified` instead.

    Definition Classes
      GenTrees
79.  def reifyTreeSymbols: Boolean
    Definition Classes
      GenTrees
80.  def reifyTreeSyntactically(tree: tools.nsc.Global.Tree): tools.nsc.Global.Tree
    Definition Classes
      GenTrees
81.  def reifyTreeTypes: Boolean
    Definition Classes
      GenTrees
82.  def reifyType(tpe: tools.nsc.Global.Type): tools.nsc.Global.Tree

    Reify a type.

    Reify a type. For internal use only, use `reified` instead.

    Definition Classes
      GenTypes
83.  val reshape: tools.nsc.Global.Transformer { ... /* 2 definitions in type refinement */ }

    Rolls back certain changes that were introduced during typechecking of the reifee.

    Rolls back certain changes that were introduced during typechecking of the reifee.

    These include: * Undoing macro expansions * Replacing type trees with TypeTree(tpe) * Reassembling CompoundTypeTrees into reifiable form * Transforming Modifiers.annotations into Symbol.annotations * Transforming Annotated annotations into AnnotatedType annotations * Transforming Annotated(annot, expr) into Typed(expr, TypeTree(Annotated(annot, _)) * Non-idempotencies of the typechecker: https://github.com/scala/bug/issues/5464

    Definition Classes
      Reshape
84.  def scalaFactoryCall(name: String, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
85.  def scalaFactoryCall(name: tools.nsc.Global.TermName, args: tools.nsc.Global.Tree*): tools.nsc.Global.Tree
    Definition Classes
      GenUtils
86.  def spliceType(tpe: tools.nsc.Global.Type): tools.nsc.Global.Tree
    Definition Classes
      GenTypes
87.  val state: State

    Encapsulates reifier state

    Encapsulates reifier state

    When untangling reifier symbol tables from the reifier itself, I discovered that encoding of a symbol table (e.g. producing corresponding reificode) might cause subsequent reification (e.g. when filling in signatures and annotations for syms).

    This is a mess in the face of nested reifications, splices and inlining of thereof, so I made `SymbolTable` immutable, which brought a significant amount of sanity.

    However that wasn't enough. Sure, symbol table became immutable, but the reifier still needed to mutate its `symtab` field during reification. This caused nasty desyncs between the table being encoded and the table of the underlying reifier, so I decided to encapsulate the entire state here, so that encoding can backup the state before it starts and restore it after it completes.

    Definition Classes
      States
88.  def symtab: SymbolTable

    Symbol table of the reifee.

    Symbol table of the reifee.

    Keeps track of auxiliary symbols that are necessary for this reification session. These include: 1) Free vars (terms, types and existentials), 2) Non-locatable symbols (sometimes, e.g. for RefinedTypes, we need to reify these; to do that we create their copies in the reificode) 3) Non-locatable symbols that are referred by #1, #2 and #3

    Exposes three main methods: 1) `syms` that lists symbols belonging to the table, 2) `symXXX` family of methods that provide information about the symbols in the table, 3) `encode` that renders the table into a list of trees (recursively populating #3 and setting up initialization code for #1, #2 and #3)

    Definition Classes
      GenSymbols
89.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
90.  def termPath(fullname: String): tools.nsc.Global.Tree

    An (unreified) path that refers to term definition with given fully qualified name

    An (unreified) path that refers to term definition with given fully qualified name

    Definition Classes
      GenUtils
91.  def toString(): String
    Definition Classes
      AnyRef → Any
92.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
93.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
94.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
95.  def →[B](y: B): (Reifier, B)
    Implicit
      This member is added by an implicit conversion from Reifier to ArrowAssoc[Reifier] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc
96.  object TypedOrAnnotated
    Definition Classes
      GenUtils
97.  object ApplyCall
    Definition Classes
      Extractors
98.  object BoundTerm
    Definition Classes
      Extractors
99.  object BoundType
    Definition Classes
      Extractors
100.  object FreeDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
101.  object FreeRef
     Definition Classes
       Extractors
102.  object FreeTermDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
103.  object FreeTypeDef extends Utils.FreeDefExtractor
     Definition Classes
       Extractors
104.  object ReifiedTree
     Definition Classes
       Extractors
105.  object ReifiedType
     Definition Classes
       Extractors
106.  object SymDef
     Definition Classes
       Extractors
107.  object TreeSplice
     Definition Classes
       Extractors
108.  object TypeRefToFreeType
     Definition Classes
       Extractors
109.  object reifiedNodeToString extends (tools.nsc.Global.Tree) ⇒ String
     Definition Classes
       NodePrinters
110.  object SymbolTable
     Definition Classes
       SymbolTables

### Deprecated Value Members

1.  def formatted(fmtstr: String): String
   Implicit
     This member is added by an implicit conversion from Reifier to StringFormat[Reifier] performed by method StringFormat in scala.Predef.
   Definition Classes
     StringFormat
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

### Inherited from Utils

### Inherited from StdAttachments

### Inherited from SymbolTables

### Inherited from Extractors

### Inherited from NodePrinters

### Inherited from Errors

### Inherited from Phases

### Inherited from Reify

### Inherited from GenUtils

### Inherited from GenPositions

### Inherited from GenAnnotationInfos

### Inherited from GenTrees

### Inherited from GenNames

### Inherited from GenTypes

### Inherited from GenSymbols

### Inherited from Metalevels

### Inherited from Calculate

### Inherited from Reshape

### Inherited from States

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from Reifier to any2stringadd[Reifier]

### Inherited by implicit conversion StringFormat from Reifier to StringFormat[Reifier]

### Inherited by implicit conversion Ensuring from Reifier to Ensuring[Reifier]

### Inherited by implicit conversion ArrowAssoc from Reifier to ArrowAssoc[Reifier]

### Ungrouped