Packages

•  package root

  Definition Classes

  root

•  package de

  Definition Classes

  root

•  package uni_luebeck

  Definition Classes

  de

•  package isp

  Definition Classes

  uni_luebeck

•  package example_gen

  Definition Classes

  isp

•  object Type

  The base class of all types is

  The base class of all types is

  Type

  .

  Two basic types beside the base class of the type hierarchy are ComposedType and ObjectType.

  Type.ComposedType

  is a built-in type with a name and a list of type arguments. For example Int is

  ComposedType("Int", Seq())

  and ListType[T] is

  ComposedType("List", Seq(T))

  .

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("List", Seq(T)) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("Int", Seq()) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Type.ComposedType }}} Int is

  ComposedType("Int", Seq())

  and ListType[T] is

  ComposedType("List", Seq(T))

  .

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("List", Seq(T)) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("Int", Seq()) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Type }}}

  Two basic types beside the base class of the type hierarchy are ComposedType and ObjectType.

  Type.ComposedType

  is a built-in type with a name and a list of type arguments. For example Int is

  ComposedType("Int", Seq())

  and ListType[T] is

  ComposedType("List", Seq(T))

  .

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("List", Seq(T)) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("Int", Seq()) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Type.ComposedType }}} Int is

  ComposedType("Int", Seq())

  and ListType[T] is

  ComposedType("List", Seq(T))

  .

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("List", Seq(T)) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  ComposedType("Int", Seq()) }}}

  Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.

  A Map is translated into a list of objects with members #k and #v.

  Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.

  This occurrence is represented with LazyError.

  TeSSLa's Option[T] translates to

  Option[LazyError[T]]

  . TeSSLa's Stream[T] translates to

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option[LazyError[T]] }}}

  LazyError[Option[LazyError[T]]]

  .

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyError[Option[LazyError[T]]] }}}

  Every expression of type T in a lifted functions is translated into LazyError[T].

  This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full

  ComposedType("Int", Seq())

  and following,

  Option(inner)

  and

  LazyErr(inner)

  instead of manually matching the objects members,

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  LazyErr(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(inner) }}}

  Map(key, value)

  , and also LazyOpt (for

  Option(LazyErr(inner))

  ) and also Stream(inner).

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Option(LazyErr(inner)) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Map(key, value) }}}

  The method

  Type.fromTessla

  for automatically translating TeSSLa types to ExampleGen ones.

  Type.fromTessla }}}

  Definition Classes

  example_gen

• AccessUnknown
• Composed1
• ComposedType
• Function
• InferenceFailed
• LazyErr
• LazyOpt
• MapType
• Object
• OptionType
• Stream
• TypeMatcher
• Unknown

de.uni_luebeck.isp.example_gen.Type

Composed1 