Type Members

1.  abstract class Base extends AnyRef

   The Base trait houses common AST nodes.

   The Base trait houses common AST nodes. It also manages a list of encountered definitions which allows for common sub-expression elimination (CSE).

2.  trait DefRewriting extends AnyRef
3.  class DelayInvokeException extends Exception

   Can be thrown in staged method body to prevent body unfolding.

   Can be thrown in staged method body to prevent body unfolding. When this exception is thrown, the caller can catch it and reify this invocation as MethodCall graph node.

4.  trait Entities extends TypeDescs

   A slice in the Scalan cake with base classes for various descriptors.

5.  trait Library extends Scalan with WrappersModule with CollsModule
6.  trait MethodCalls extends Base
7.  case class ModuleInfo(packageName: String, moduleName: String, extension: String = ".scalan") extends Product with Serializable

   Information about generated Special library module.

   Information about generated Special library module. Instances are created in generated code.

   See also

   *Impl.scala files

8.  trait Modules extends Base
9.  final class MutableLazy[A] extends AnyRef

   Non-thread safe (but efficient on single thread) immutable lazy value with reset.

   Non-thread safe (but efficient on single thread) immutable lazy value with reset. The block may execute potentially many times, but only once before each reset.

10.  class Scalan extends TypeDescs with MethodCalls with Tuples with NumericOps with UnBinOps with LogicalOps with OrderingOps with Equal with UniversalOps with Functions with IfThenElse with Transforming with Thunks with Entities with Modules with DefRewriting

    Aggregate cake with all inter-dependent modules assembled together.

    Aggregate cake with all inter-dependent modules assembled together. Each instance of this class contains independent IR context, thus many instances can be created simultaneously. However, the inner types declared in the traits are path-dependant. This in particular means that ctx1.Ref[_] and ctx2.Ref[_] are different types. The typical usage is to create val ctx = new Scalan and then import inner declarations using import ctx._. This way the declaration will be directly available as if they were global declarations. At the same time cake design pattern allow to override many methods and values in classed derived from Scalan, this is significant benefit over *everything is global* design.

11.  abstract class TypeDescs extends Base