example_gen

package example_gen

Ordering

Alphabetic

Visibility

Public
All

Type Members

abstract class CompilationError extends Exception
An exception for signalling compilation errors, caused by errors or unsupported features in the TeSSLa specification, but not for exception raised by a wrongly used API.
An exception for signalling compilation errors, caused by errors or unsupported features in the TeSSLa specification, but not for exception raised by a wrongly used API.
In other words: If you catch an exception of this type, you did not do a mistake in your scala code. The user did one in their TeSSLa specification.
class DatastructureSize extends AnyRef
Infer the size of datastructures.
Infer the size of datastructures. The input is bounded. In most cases there are no datastructures as input, but the datastructures are only used internally.
This inference starts at the inputs and propagates the bounds through the whole specification. That is totally different from the RangeInference, because for RangeInference we start at the comparison operators and compute the ranges for the inputs.
case class Event(index: Int, stream: StreamId, value: Value) extends Product with Serializable
A single event.
A single event.
The index is the index of the time stamp
sealed class Example extends AnyRef
case class FunctionId(id: Int) extends Product with Serializable
class FunctionsAsValue extends CompilationError
final class GenZ3 extends AnyRef
class HardStrategy extends Strategy
trait Id extends Any
case class InputTrace(timeStamps: Seq[BigInt], events: Seq[Event]) extends Product with Serializable
Trace consists of a sequence of time stamps (the same for each) and a sequence of events.
class LazyArray[+A] extends LazySeq[A]
A lazy array computes a function from an index to an optional value, but stores the value once it has been evaluated.
A lazy array computes a function from an index to an optional value, but stores the value once it has been evaluated.
The array ends when fn returns None the first time.
trait LazySeq[+A] extends Iterable[A]
Lazy sequences are lazily evaluated collections.
Lazy sequences are lazily evaluated collections. They are similar to Views, but also contain collections, that store the result after evaluating it once.
class LazyView[+A] extends LazySeq[A]
Recompute the value on every access.
class MinExample extends Strategy
Generate an example with AT LEAST the given input.
class NonObject extends Exception
class Optimizer extends SolverInterface
class RangeInference extends AnyRef
class SimpleStrategy extends Strategy
class SoftStrategy extends Strategy
class Solver extends SolverInterface
sealed abstract class SolverInterface extends AnyRef
The implementation can switch between the incremental solver of Z3 and the optimizer.
The implementation can switch between the incremental solver of Z3 and the optimizer.
The optimizer supports soft assertions, that should be, but don't need to be satisfied. This is good for coverage, but also slow and with limited features.
SolverInterface is a shared interface for these two.
final class Statistics extends AnyRef
sealed abstract class Strategy extends AnyRef
case class StreamId(id: String) extends Id with Product with Serializable
case class TestError(time: Int, stream: String, error: String) extends Ordered[TestError] with Product with Serializable
case class TestEvent(time: Int, stream: String, value: String) extends Ordered[TestEvent] with Product with Serializable
An event at a given timestamp.
sealed class TyArray[+T <: Expr] extends AnyRef
TyArray is the basic class for storing sequences of values, like streams.
TyArray is the basic class for storing sequences of values, like streams.
They contain a LazyArray rawEvents which creates a new variable on access. Additionally they contain a type and a reference to the context, they where created in.
They allow access to a single value of type TyExpr by apply operator.
Both TyArray and TyExpr have a Type as Parameter, so that they can easily and safely be used with subtypes, for example as TyArray[BoolExpr] for boolean sequences, without requiring explicit and potentially wrong casts.
final case class TyExpr[+E <: Expr](expr: E, ty: Type) extends Product with Serializable
Z3 Expression coupled with a custom type.
Z3 Expression coupled with a custom type. Contains helper operations.
class TyExprGen extends AnyRef
abstract class Type extends Equals
class UnimplementedCustomOperator extends CompilationError
class UnimplementedOperator extends CompilationError
final class UnimplementedPrimOperator extends Exception
final class UnknownType extends Exception
final class UnknownValue extends Exception
class Unsupported extends Exception
case class ValueId(id: String) extends Id with Product with Serializable
class WrongOperator extends CompilationError
final class Z3LazyErr extends AnyVal
final class Z3List extends AnyVal
final class Z3Object extends AnyVal
Helper object is a wrapper around DatatypeSort for easier access to operations.
final class Z3Option extends AnyVal

Value Members

object Api
object AssertType extends Enumeration
A desugared assertion can enforce that SOME event must exist or that NO event must exist.
object DatastructureSize
object EvalError extends Exception
object GenZ3
object IterativeStrategy
object LazySeq
Provides the Iterator over LazySeq.
object Main extends SexyOpt
object PlainTessla
object RangeInference
object Side extends Enumeration
Used for determining the choice within an IfThenElse-Expression.
object Statistics
object Strategy extends Enumeration
There are different strategies for generating a set of examples with maximal possible coverage.
There are different strategies for generating a set of examples with maximal possible coverage.
The strategies are grouped into simple, hard, soft, iterative.
Hard: Use hard constraints or fail: Fails to generate all combinations if input space is too small, or if combinations are impossible (e.g. merge(x,x) or filter(x, true)).
Soft: Use the optimizer to find only few examples: Packs multiple interesting cases to see into one example, which is not always good.
Iterative strategy: Set one coverage constraint in each step. Either ignore that case or continue with the next.
object StreamId extends Serializable
object TraceConverter
object TyExpr extends Serializable
object Type
The base class of all types is
The base class of all types is
```
Type
```
.
Two basic types beside the base class of the type hierarchy are ComposedType and ObjectType.
```
Type.ComposedType
```
is a built-in type with a name and a list of type arguments. For example Int is
```
ComposedType("Int", Seq())
```
and ListType[T] is
```
ComposedType("List", Seq(T))
```
.
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("List", Seq(T)) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("Int", Seq()) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Type.ComposedType }}} Int is
```
ComposedType("Int", Seq())
```
and ListType[T] is
```
ComposedType("List", Seq(T))
```
.
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("List", Seq(T)) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("Int", Seq()) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Type }}}
Two basic types beside the base class of the type hierarchy are ComposedType and ObjectType.
```
Type.ComposedType
```
is a built-in type with a name and a list of type arguments. For example Int is
```
ComposedType("Int", Seq())
```
and ListType[T] is
```
ComposedType("List", Seq(T))
```
.
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("List", Seq(T)) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("Int", Seq()) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Type.ComposedType }}} Int is
```
ComposedType("Int", Seq())
```
and ListType[T] is
```
ComposedType("List", Seq(T))
```
.
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("List", Seq(T)) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
ComposedType("Int", Seq()) }}}
Not all types are represented as a ComposedType. TeSSLa's Option is represented by an object with members #isSome and #getSome.
A Map is translated into a list of objects with members #k and #v.
Another special type is called LazyError and like an option is represented by an object with members #isError and #get. It either indicates an error or represents a value. In Tessla Options can contain an error value, a lifted expression may evalute to an error and a stream may contain both events with value errror or places where the stream itself contains an error, so that it is indeterminate whether the stream has an event or not.
This occurrence is represented with LazyError.
TeSSLa's Option[T] translates to
```
Option[LazyError[T]]
```
. TeSSLa's Stream[T] translates to
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option[LazyError[T]] }}}
```
LazyError[Option[LazyError[T]]]
```
.
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyError[Option[LazyError[T]]] }}}
Every expression of type T in a lifted functions is translated into LazyError[T].
This module provides simple accessors for special types, which can be used for matching. These accessors may be Int, Float, String, Bool, instead of the full
```
ComposedType("Int", Seq())
```
and following,
```
Option(inner)
```
and
```
LazyErr(inner)
```
instead of manually matching the objects members,
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
LazyErr(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(inner) }}}
```
Map(key, value)
```
, and also LazyOpt (for
```
Option(LazyErr(inner))
```
) and also Stream(inner).
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Option(LazyErr(inner)) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
Map(key, value) }}}
The method
```
Type.fromTessla
```
for automatically translating TeSSLa types to ExampleGen ones.
Type.fromTessla }}}
object TypeInference
There once was full (but primitive) type inference for the whole module.
There once was full (but primitive) type inference for the whole module. Since TeSSLa's type annotations exist and are mostly good, the whole complexity is way to much, although for some cases of generated code or generic constants, type inference is still used.
It uses HM-type inference (just was simpler this way).
You only need to call apply and the PlainTessla spec is filled with type info.
object Unimplemented extends CompilationError
object Unsat extends Strategy
Strategy Unsat never generates a test case and always prints unsat.
object Util
object ValueId extends Serializable
object Z3Helper
object Z3Object
object ZEncoding
Support zEncoding.
Support zEncoding. While the datastructures of z3 support invalid encodings, deserializing it and then serializing it again does not work or is at least really weird.
This module supports zEncoding to help. Note: The Z-Encoding is not equivalent to ghc's ones. It is not as general, but also has new operators for storing braces, which are needed for serializing object types.

Packages

example_gen

package example_gen

Type Members

Value Members

Ungrouped

Packages

example_gen 

package example_gen

Type Members

Value Members

Ungrouped

example_gen