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 }}}