Patterns and bindings

[Web site restructuring. Every document driving the web sit is now in the web/ subdirectory, old directories doc and logos have ben deleted and the example program descriptions have been moved to the new location. nordland@csee.ltu.se**20081111135042] { hunk ./doc/summary/bindings.html 1 - - -Patterns and bindings - - - - -

Patterns and bindings

- -

Patterns and pattern matching

-Patterns occur in several syntactic contexts in Timber (e.g. in the left hand sides of bindings, lambda expressions -and case alternatives). Syntactically, patterns form a subset of expressions; a pattern is one of the following: -

A variable. -
A literal. -
A constructor, possibly applied to a sequence of patterns. The sugered forms for lists and tuples are allowed. -
A fully or incompletely defined struct expression (but not a layout-sensitive struct expression), where - the right hand sides of all fields are patterns. -
A pattern in parentheses. -

-At run-time, patterns are matched against values. Pattern-matching may succeed or fail; in the former case the result -is a binding of the variables in the pattern to values. The rules are as follows: -

Matching a variable x against a value v always succeeds, binding x to v. -
Binding a literal l against a value v succeeds only if the v is the value - denoted by l; no variable is bound. -
Matching a constructor pattern C p1 ... pn against a value v succeeds only if - v = C v1 ... vn and matching pi against vi succeeds for all i; the resulting - binding is the union of the bindings resulting from each of these matchings. -
Matching a struct pattern against a value v starts by stuffing the record; it then has the form - S {sel1 = p1, ... seln = pn}. Matching against a value v succeeds if v = S {sel1 = v1, seln = vn} - and matching pi against vi succeeds for all i; the resulting - binding is the union of the bindings resulting from each of these matchings.
Mathing (p) against a value is the same as matching p against the same value. -

-The special "wildcard" variable _ may be used in patterns; in contrast to other variables, it is not bound - by pattern-matching. -

- A consequence of the way pattern-matching is done is that patterns must be linear; no variable may occur more than once in - a pattern. - -

Bindings

-Syntactically, bindings are divided into type signatures and equations. Equations are either function bindings, pattern bindings - or instance bindings for implicit struct types. - -

Type signatures.
- var (, var ) * :: qtype -
Here a qtype is a (possibly qualified) type. - - - - - - -
Examples -
x, y, z :: Int
map :: (a -> b) -> [a] -> [b]
elem :: a -> [a] -> Bool \\ Eq a
-
Function bindings. -
We present first the simplest form of function definition, a sequence of equations, and then how these may -be extended with where-clauses and with guards; these extensions may be combined. -
- Simple function bindings. A simple function binding is a sequence of equations in layout-sensitive syntax, where -each equation has the form
  -var pat * = expr -
  -The variable (the name of the function) and the number of patterns must be the same in all equations. -The order of equations is significant; when applying the function, pattern-matching is tried starting wih the first equation -until it succeeds; the function value is computed from right hand side of that equation, using the variable bindings obtained. -Within one equation, patterns are matched from left to right. - - - - - -
  Example -
  zip (x:xs) (y:ys) = (x,y) : zip xs ys
  zip _ _ = []
  -
- Bindings with where-clauses.
  -A binding may have attached a where-clause with a list of local bindings in layout-sensitive syntax
  -var pat * = expr
  - where bind + - - - - - -
  Example -
  formatLine n xs = concatMap f xs
  where f x = rJust n (show x)
  -
- Guarded equations. In addition to patterns, the left hand side may include one or more guards
  -var pat *
  - ( | (qual) + - = expr ) + -
  -In the most common case, a qual is a Boolean expression. After pattern-matching has succeeded, the guards are -evaluated in turn; the right hand side corresponding to the first true guard (if any) is used. - - - - - - - -
  Example -
  lookup x [] = Nothing
  lookup x ((a,b) : xs)
  | x == a = Just b
  | True = lookup x xs
  -
  -More complicated guards that bind variables are possible, but omitted here. -
-
Pattern bindings.
-pat = expr -
-where pat is not a variable (in which case the binding is, perhaps counter-intuitively, a function binding). -
-Pattern bindings bind the variables in pat by pattern-matching against the value of expr. -A pattern binding may not occur as a top-level declaration, but only as a local binding. - - - - - -
Example -
lookup' x ps = y
where Just y = lookup x ps
-
The pattern-binding in the where-clause will fail (and the function application give a run-time error), if -the result of calling lookup is Nothing. -
Instance bindings for implicit struct types. -
-implicit var :: type
-funBind -
-The type signature of an instance of an implicit type is prepended by the keyword implicit. For instances, -a type signature is compulsory; only the function binding defining the instance is not sufficient, -

Examples -
`x, y, z :: Int`
`map :: (a -> b) -> [a] -> [b]`
`elem :: a -> [a] -> Bool \\ Eq a`

Example -
`zip (x:xs) (y:ys) = (x,y) : zip xs ys`
`zip _ _ = []`

Example -
`formatLine n xs = concatMap f xs`
`where f x = rJust n (show x)`

Example -
`lookup x [] = Nothing`
`lookup x ((a,b) : xs)`
`\| x == a = Just b`
`\| True = lookup x xs`

Example -
`lookup' x ps = y`
`where Just y = lookup x ps`

-The order between bindings in a sequence of bindings is not significant, with the following exceptions: -

All the equations that make up a function binding must be adjacent to each other with no other binding intervening. -
A type signature must precede the binding equations for the variables that are typed by the signature. -

-Function bindings are recursive. For pattern bindings certain limited forms of recursion are possible, in order -to build finite, cyclic data structures. To be described more... - rmfile ./doc/summary/bindings.html hunk ./doc/summary/default.html 1 - - -Default declarations - - - - -

Default declarations

-Default declarations come in two distinct forms. They share the keyword default and they both -affect instances for implicit struct types, but otherwise they serve quite different purposes. -

Ordering between instances.
- For a given implicit struct type T, several instances are typically defined. It is permitted to define - instances at overlapping types, such as e.g. T [a] and T [Int], where the latter type - is more specific than the former. -
- During type-checking, the compiler - needs to insert instances as implicit arguments to functions that use of the selectors of T. The compiler infers - which instance type T t that is needed and chooses the most specific instance. However, it may happen that there - is no most specific type. The prelude defines intInt :: IntLiteral Int and intFloat :: IntLiteral Float and similarly for - Show. Neither of - this is more specific than the other. Thus a top-level definition such as -
```
s = show 1
-
```
- leads to problems; should - implicit arguments for Int or Float be inserted? There is no reason to prefer one to the other so s is - considered ill-typed. But the matter can be decided by inserting a default declaration; the prelude declares -
```
-default intInt < intFloat
-
```
-which means that the instance intInt is to be preferred to intFloat. Thus the Int instances -are chosen and s is "1" rather than "1.0". -

Generation of instances.

-A declaration -

-default tD :: T D
-

-where T is an implicit struct type and D is a data type produces automatically an instance following -the ideas of Hinze's and Peyton Jones' derivable type classes. The mechanism applies only in some, rather restrictive, situations, -but these include common cases like the Prelude's Eq and Ord, for which it is easy but tedious -to define instances for a new data type. -

-The method applies only to one-parameter implicit -types, for which the types of all selectors are simple, according to the following inductive definition: -

monomorphic types are simple. -
the type parameter of the implicit struct type is simple. -
if t1...tn are simple, then (t1,...,tn) is simple. -
if t1 and t2 are simple, then t1 -> t2 is simple. -

-The mechanism also requires that instances are defined for the unit type (), the type (a,b) of pairs and -the primitive type Either a b. The default instance builds an auxiliary type A using only these three -type constructors and defines functions in both directions between between D and A. The default instance -for D makes use of the instance -for A (which is well-defined, since instances exist for (), pairs and Either). -

-In addition to the above mechanism, default instances can be defined for implicit types Show and Parse (defined in the Prelude), but as yet only for enumeration types (pending decisions on proper definitions of predefined implicit types for -conversion between values of data types and strings). - - - rmfile ./doc/summary/default.html hunk ./doc/summary/expr.html 1 - - -Expressions and patterns - - - - -

Expressions

-Timber has a rich expression language and we divide -the description in three parts: -

Basic forms of expressions. -
Here we describe the Timber form of expression forms that have counterparts in most functional languages. -
Classes, actions and requests. -
These forms are special to Timber and provide the building blocks for - object-oriented programming. -
Further forms of expression. -
Every Timber program will include expressions from the previous two groups. In this - third group we describe more esoteric forms that may be ignored by the beginning Timber programmer. -

- -

Layout-sensitive syntax

-Layout of program code is significant in Timber. In many cases, sequences of syntactic elements can be written in -tabular form, where each new item starts on a new line and in the same column as the beginning of the previous item. Multi-line -items are possible by intending subsequent lines; the end of the sequence is signalled by "outdenting", i.e. indenting -less, as in the example -

-   showSeq xs = concat (map showLine xss)
-     where prec = 100
-           showLine x = map (showItem 10)
-                            (comp prec xx)
-
-   showItem n x = format n ('_' : g x)
-

-The definition of showSeq has a where-clause with a list of two local definitions (defining prec and -showLine). The definition of showLine spans two lines, indicated by indentation. The last definition, -of showItem, has another indentation level, thus is not part of the where-clause and is hence not -local to showSeq. Instead showSeq and showItem form another list of bindings. -

-It is possible to avoid layout-sensitive syntax by enclosing such sequences in braces and using semi-colon as -separator: let {x=1; y=f x 3} in g x y; this is generally not recommended. - -

Basic forms of expressions

- -

Variables. A variable is an identifier (which may be qualified and which may be an operator enclosed in parentheses). -
- - - - -
Examples -
x, counter, Dictionary.d, (+)
- -
Literals. Timber literals include integer literals, floating point literals, character literals and string literals. There - are no surprises here and we give just a few examples. -
- - - - - - - - -
Type of literal - Examples -
Int 37, 0, -123
Float 1.23, 3E12, 0.4567E-6
Char 'a', '3', '\n', '\t', '\\'
String "Hi", "Error\n"
-
-Every occurrence of an integer literal except in patterns is during desugaring replaced by application of the function -fromInt to the literal. The Prelude defines -
```
-implicit struct IntLiteral a where
- fromInt :: Int -> a
-
```
-and instances for Int (the identity function) and Float (conversion). -
-This device will make many functions that mention integer literals usable for both Int and Float arguments; -a simple example is -
```
-sum :: [a] -> a \\ Num a, IntLiteral a
-sum [] = 0
-sum (x : xs) = x + sum xs
-
```
-
Function (and constructor) application. Application is denoted by juxtaposition, binds tighter than all operators and is left associative. - - - - - - - - -
Examples - Comments
f 3 Parentheses not needed
g (x+2) Parentheses necessary
Just (f x) Constructor Just applied to f x
map f (g xs) map f applied to g xs
hMirror (x,y) One argument, which is a pair
-
Operator application. An operator may be used in infix form between two operands. This is just syntactic -sugar for application. -
- - - - - - -
Examples - Desugared forms
x+3 (+) x 3
f x+3*x (+) (f x) ((*) 3 x)
3 `elem` xs elem 3 xs
-
-Precedence and associativity of operators is determined syntactically; see the name page for details.
Constructors. A constructor is defined in a data type definition or is one of the primitive constructors : and [] -for lists, False and True for Bool and () for ().
Lambda expressions.
-\ pat + -> expr -
-denoting anonymous functions. The sequence of patterns must be linear, i.e. may not include more than one occurrence -of any variable. - - - - - -
Example -
\x -> x+3
\ (Just x) d -> insert x 0 d
-
Tuples. -
-Pairs, triples etc are expressed using parenheses as delimiters and comma as separator. These are also desugered to -application: -
- - - - - -
Examples - Desugared forms
(a,b) (,) a b
(f x,3+5,True) (,,) (f x) ((+) 3 5) True
-
-Here (,), (,,) etc are primitive constructors for the types of pairs, triples etc. -
List expressions. -
List expressions are sequences delimited by square brackets and with comma as separators;[1,3,7] -is a list with three elements. This form is desugared to the primitive form of lists, which has as constructors -[] (the empty list) and : ("cons", which builds -a list with its first argument as first element ("head") and second argument as remainder ("tail")). -
- - - - - -
Examples - Desugared forms
[1,3,7] (:) 1 ((:) 3 ((:) 7 []))
[f x, p 3] (:) (f x) ((:) (p 3) [])
-
- -
-Let expressions. -
-let bind + in expr -
where the list of bindings is layout-sensitive. The bindings are recursive, i.e all the -names defined in the bind list are in scope in the right hand sides of these bindings (and, of course, -in the main expression). -
- - - - - - - -
Example - Comments
let size = f 100 f, defined below, is in scope
f 0 = 0 Pattern-matching allowed
f x = g x (x+2)
in concat (map f xs)
-
-
Struct expressions. Expressions denoting values of a struct type come in several forms: -
- Fully defined struct expression.
  -[ type_constructor ] { field (, field )+ }
  where field - has the form selector = expr .
  - The type_constructor is the name of a struct type. Since the struct type is uniquely determined -by its fields, the type name is optional. - - - - - - -
  Examples -
  Point {x=3, y=1}
  {x=3, y=1}
  Counter {inc = inc, read = read}
  -
  The examples presupposes type definitions -
```
-struct Point where
-  x, y :: Int
-
-struct Counter where
-  inc  :: Action
-  read :: Request Int
-
```
  -
  -The last example is to emphasise that selectors (the inc and read in the left hand -sides of the fields) are in a separate namespace from variables (the right hand sides). Thus the equations -are not recursive; the example requires -that definitions of these variables are in scope. -
- Incomplete struct expressions.
  -type_constructor { [ field (, field )+] ..}
  -The trailing .. indicates that the struct value should be stuffed, by adding fields -of the form x = x for each selector x that is not explicitly given a value in a field. -
  - - - - - - - -
  Example - expands to -
  Counter {..} Counter {inc = inc, read = read}
  Counter {read = readreq ..} Counter {read = readreq, inc = inc}
  Point {x=0..} Point {x=0, y=y}
  -
  -Obviously, because of subtyping, the type name cannot be omitted here. -
- -Layout-sensitive struct values.
  -struct bind +
  -where the bindings have layout-sensitive syntax. -
  - - - - - - - -
  Example -
  implicit showList :: Show [a] \\ Show a
  showList = struct
  show [] = "[]"
  show (x : xs) = '[':show x ++ preC (map show xs)++"]"
  -
  -The list of bindings in this form of expression differs from all other occurrences of -lists of bindings in that they are not recursive. We are defining the selectors in a struct -but allow pattern matching equations in layout-sensitive form; occurrence of the same name as a -variable in the right hand side must refer to some other definition in scope. This is particularly -common for structs defined to be type classes, as here. See the section on type classes for -more explanatation. -
-
Case expressions.
-case expr of alt + -
-where the sequence of alternatives is layout-sensitive. The simplest form of an alternative is -
-pat -> expr - - - - - - -
Example -
case f a b of
[] -> 0
x : xs -> g x + h 3 xs
-
-

Examples -
`x, counter, Dictionary.d, (+)`

Type of literal -	Examples -
`Int`	`37, 0, -123`
`Float`	`1.23, 3E12, 0.4567E-6`
`Char`	`'a', '3', '\n', '\t', '\\'`
`String`	`"Hi", "Error\n"`

Examples -	Comments
`f 3`	Parentheses not needed
`g (x+2)`	Parentheses necessary
`Just (f x)`	Constructor `Just` applied to `f x`
`map f (g xs)`	`map f` applied to `g xs`
`hMirror (x,y)`	One argument, which is a pair

Examples -	Desugared forms
`x+3`	`(+) x 3`
`f x+3*x`	`(+) (f x) ((*) 3 x)`
3 `elem` xs	`elem 3 xs`

Example -
`\x -> x+3`
`\ (Just x) d -> insert x 0 d`

Examples -	Desugared forms
`(a,b)`	`(,) a b`
`(f x,3+5,True)`	`(,,) (f x) ((+) 3 5) True`

Examples -	Desugared forms
`[1,3,7]`	`(:) 1 ((:) 3 ((:) 7 []))`
`[f x, p 3]`	`(:) (f x) ((:) (p 3) [])`

Example -	Comments
`let size = f 100`	`f`, defined below, is in scope
`f 0 = 0`	Pattern-matching allowed
`f x = g x (x+2)`
`in concat (map f xs)`

Examples -
`Point {x=3, y=1}`
`{x=3, y=1}`
`Counter {inc = inc, read = read}`

Example -	expands to -
`Counter {..}`	`Counter {inc = inc, read = read}`
`Counter {read = readreq ..}`	`Counter {read = readreq, inc = inc}`
`Point {x=0..}`	`Point {x=0, y=y}`

Example -
`implicit showList :: Show [a] \\ Show a`
`showList = struct`
`show [] = "[]"`
`show (x : xs) = '[':show x ++ preC (map show xs)++"]"`

Example -
`case f a b of`
`[] -> 0`
`x : xs -> g x + h 3 xs`

Classes, actions and requests.

-Classes in Timber should be thought of as in object-oriented programming: a class is a template, from which -we may create several objects. An object encapsulates its own copy of the state variables defined in the class. -

Actions and requests are methods that a class may expose to the outside; they may manipulate the local -state of objects. -

-Procedures are subroutines that may be called by actions and requests; they are typically not exposed -in interfaces. In contrast to actions and requests, a procedure always reads and writes the local state -of its caller, irrespective of the scope in which it was defined. -

-The syntax of these constructs are similar; they are all built from sequences of statements: -

A class expression is the keyword class followed by a sequence of statements. -
An action expression is the keyword action followed by a sequence of statements. -
A request expression is the keyword request followed by a sequence of statements. -
A procedure expression is the keyword do followed by a sequence of statements. -

-In all cases, statement sequences have layout-sensitive syntax. See the statements page -for further descriptions. -

Further forms of expressions

-To be written. - rmfile ./doc/summary/expr.html hunk ./doc/summary/haskell.html 1 - - -Timber for Haskell programmers - - - - -

Timber for Haskell programmers

-Much of Timber syntax is taken from Haskell, so the Haskell programmer glancing -through Timber code will feel at home. This page summarizes instead the most important -differences between Timber and Haskell. -

Timber has strict semantics, not lazy as Haskell. This has a major impact on the - programming styles of the two languages. -
Timber has Haskell-like type classes, but with slightly - different syntax for both type class and instance declarations. The reserved word starting a - type class declaration is typeclass. - The main reason for this change is that the word class - in Timber is used to denote the well-known concept from object-oriented programming. - Instances of such types are - named values of the type, tagged by instance. The following excerpt from - the Prelude illustrates the concept. -
```
-typeclass Eq a where 
-  (==),(/=) :: a -> a -> Bool
-
-
-instance eqUnit :: Eq () 
-eqUnit = struct
-  _ == _ = True
-  _ /= _ = False
-
```
-
-One cannot attach a deriving-clause to a data type definition. Instead, one can separately -request default instances of some implicit types. -
In addition to data types, Timber has a dual notion of struct types. For both data and struct types there is a notion - of subtyping with inclusion polymorphism. -
Qualified types have another syntax in Timber. To illustrate, here is the definition of the function elem - from the Prelude: -
```
-elem :: a -> [a] -> Bool \\ Eq a
-elem x []           = False
-elem x (y : ys)     = x == y || elem x ys
-
```
-
- Note: A call to elem will evaluate both arguments - completely (because the language is strict), but will not traverse its second argument - further when an equality becomes True (because the disjunction "operator" || is non-strict - in its right operand). -
In Timber one can express monadic computations using do-notation, but this is reserved for a particular primitive - monad Cmd s of commands operating on a state s. It is possible to define the concept of a general - monad as in Haskell (it is in fact defined in the prelude), but the do-notation is not available for general monads. -
The Cmd monad provides powerful constructs for object-oriented programming, with objects encapsulating a local -state and methods manipulating this state. This is achieved while retaining the pure nature of the language; a computation with -side-effects is clearly indicated by a monadic type (and can hence not be used in a non-monadic context). -
-Further, methods execute concurrently, but with exclusive access to the state of the object; thus Timber is also a concurrent -language with some real-time constructs. -
The main program of a Timber program is not of type IO () (this type does not exist in Timber), but there must -be a designated root module with a root definition; the type of this depends on the target environment. In the present -distribution, only a rudimentary POSIX environment is provided. -

The type system of Timber implements many of the non-standard features that are implemented as extensions in GHC. See -more details on the page that discusses advanced features of the type system. - rmfile ./doc/summary/haskell.html hunk ./doc/summary/index.html 1 - - - -A summary of Timber - - - - - - - - - - -<body> -Please use a browser with support for frames. -</body> - - - - rmfile ./doc/summary/index.html hunk ./doc/summary/intro.html 1 - - -Introduction - - - - -

Introduction

-This document aims to provide a summary of the language constructs of Timber, including -syntax descriptions but with very little of motivation, explanation and examples. -

-It is intended to be useful for a reader who is exploring Timber and wants a reasonably -concise summary of the language. A Timber tutorial, with extensive motivation and examples, -will be a separate document. -

-Some syntactic constructions are described in simple BNF syntax, but this document does not give -complete formal syntax for Timber. In BNF descriptions, terminals are in -typewriter font, nonterminals in italics and meta symbols in red. - rmfile ./doc/summary/intro.html hunk ./doc/summary/java.html 1 - - -Timber for Java programmers - - - - -

Timber for Java programmers

-Timber can be seen as an object-oriented programming language with -many familiar features, but also some less familiar. This page summarizes -both similarities and differences. -

-The Timber compilation unit is a module. Within such a module one -defines e.g. types, functions and classes. So there are many other -entities in Timber than classes and objects. -
The correspondence to a Java interface is a Timber - struct type. Here is an interface suitable for a simple counter object: -
```
-struct Counter where
-  incr  :: Action
-  reset :: Action
-  read  :: Request Int
-
```
-
-A class that implements this interface provides two actions - (asynchronous methods, that do not return results): incr - to increment the local integer state by one, and reset to - reset the state to zero. To query the state, we use the request - (synchronous, value-returning method) read, which simply returns - the value of the state. -
- A Timber class consists of -
- Declaration and initialization of local state variables; -
- Declarations of methods, i.e. actions and requests, that - access and update the state. -
- Possibly local, auxiliary, definitions. -
- Specification of a result, which typically is one or more - interfaces that the class implements. -
-Here is a counter class: -
```
-counter initVal = class
-                    val := initVal
-
-                    incr = action
-                             val := val + 1
-
-                    reset = action
-                             val := 0
-
-                    read = request
-                             result val
-
-                    result Counter {..}
-
```
-
- The class itself starts with the keyword class. We see - the initialization of the state variable val to initVal, - the three method declaration and finally the result specification; - here Counter {..} means: assemble a value of type Counter - from definitions in scope. -
- Note that there is no constructor method within the class. Within - the methods of another class we may write -
```
-  c1 = new counter 0
-  c2 = new counter 10
-  
```
- to create two counter objects, with initial value 0 and 10, respectively. -
Timber has parametric polymorphism, so the kind of generics - introduced in Java 1.5 is naturally supported. -
Timber provides powerful ways to define new - value-oriented data types and functions on these, without attempts to - force this into an (often ill-suited) object paradigm. A consequence is - that Timber classes have no static variables or methods; such entities - are naturally defined as values and functions outside classes. -
- All types in Timber are first-class, which makes it possible to use classes - and methods as parameters to functions, as function values, as elements in - data structures etc leading to new programming patterns. counter above - is a simple example of this: it has type -
```
-counter :: Int -> Class Counter
-
```
- i.e., it is a function that when applied to a integer (the start value) returns a - class, from which we later can create objects. -
Timber has subtyping between struct types and inclusion polymorphism - but does not support inheritance. Since classes and methods are first-class types - in Timber it is often possible to find other ways to express most useful occurrences of - inheritance. -
- Methods always execute with exclusive access to the state of objects; thus - they can execute concurrently, leading to a very simple concurrency model for - Timber. - -

- rmfile ./doc/summary/java.html hunk ./doc/summary/lex.html 1 - -Lexical structure - - - -

Lexical structure

Comments

-A Timber program may contain two kinds of comments: -

A line comment starts with the lexeme -- and extends to the next newline. -
A general comment starts with {- and extends to the first matching --}. This allows for nested general comments; a closing -} matches only -one opening {-.

Names

-A Timber program consists mainly of definitions that give meaning to names. There are six -separate namespaces in Timber: -

variables, selectors and constructors, which all denote - different kinds of values. -
type constructors and type variables, which denote types.
module names, which refer to modules. -

-Names are simple or qualified; the latter are used to disambiguate names defined in different modules. -

Simple names

-Simple names come in two lexically distinct forms, identifiers and operators. -

-An identifier consists of a letter followed by zero or more letters, digits, single quotes and underscores. -The initial letter must be upper case for constructors, type constructors and -module names, and must be lower case for variables, selectors and type variables. The following lexically correct -identifiers are keywords of the language and may not be used as names: -

-action    after     before    case      class     data
-do        default   else      elsif     forall    if
-import    in        instance  let       module    new
-of        private   request   result    struct    then
-type      typeclass use       where     while  
-

An operator is a sequence of one or more symbol characters. -The symbol characters are defined by enumeration: :!#$%&*+\<=>?@\^|-~. -An operator starting with : is a constructor; otherwise it is a variable. Only -variables and constructors have operator forms; the other four namespaces contain only -identifiers. The following lexically correct operators are keywords and may not be used -as names: -

-.    ..   ::   :=   =    \    \\   |    <-   ->   --
-

-An identifier may be used as an operator by enclosing it in backquotes; `elem` is an operator. -Conversely, an operator may be used as an identifier by enclosing it in parentheses; (+) is an identifier. - -

Examples: - - - - - - - - - -
Names - Possible namespaces -
Color, T3, T_3, T_3' constructors, type constructors, module names
x, env, myTable, a', x_1 variables, selectors, type variables
+, #=#, @@ variables
:, :++: constructors
#3 ILLEGAL; mixture of operator and identifier symbols.
-

Names -	Possible namespaces -
`Color, T3, T_3, T_3'`	constructors, type constructors, module names
`x, env, myTable, a', x_1`	variables, selectors, type variables
`+, #=#, @@`	variables
`:, :++:`	constructors
`#3`	ILLEGAL; mixture of operator and identifier symbols.

Precedence and associativity

-The precedence and associativity of operators are determined by their syntax. The operators in the following table -are listed in decreasing precedence, i.e. an operator that appears in a later row binds less tightly. Function application, -denoted by juxtaposition, binds tighter than all operators. - - - - - - - - - - - - - - - -
Operators - Associativity -
@ Right
^ Right
* / `div` `mod` Left
+ - Left
: ++ Right
== /= < > <= >= None
&& Right
|| Right
>> >>= Left
$ Right
-For an operator that is not listed in the above table, the precedence is determined by -first deleting all characters except +-*/<>. If what remains is -

Operators -	Associativity -
`@`	Right
`^`	Right
* / `div` `mod`	Left
`+ -`	Left
`: ++`	Right
`== /= < > <= >=`	None
`&&`	Right
`\|\|`	Right
`>> >>=`	Left
`$`	Right

a non-empty -sequence of + and - characters, the associativity and precedence of the operator are the same as -those of + and -.
a non-empty sequence of * and / characters, the associativity and precedence of the operator are the same as -those of * and /.
a non-empty sequence < and > characters, the associativity and precedence of the operator are the same as -those of < and >.
something else, the associativity and precedence of the operator are the same as those of @.

-The operators in the table above are defined in the Prelude, but can be redefined in user modules, except for the following -three exceptions: -

: is the list construction operator and is supported by special syntax; -the notation [a, b, c] is syntactic sugar for the list a : b : c : []. -
- In harmony with this, the empty list has the (lexically illegal) name []. -
The operators && and ||, denoting logical and and or, respectively, are predefined in the language -and are non-strict in their right operand. -
- This means that, if evaluation of a in -a && b gives False as result, the result of the complete expression is False and -b is -not evaluated (and, in particular, a runtime error or non-termination that would occur during evaluation of b is avoided). -
-Similarly, if the left operand to || evaluates to True, the result of the complete expression is -True without evaluating the right operand. -
-Thus, semantically speaking, && and || are not operators at all but special expression-forming constructs.

Qualified names

-Timber modules are used to manage namespaces. In this mechanism, simple names are extended to qualified forms, where the -simple name is prefixed by the name of the module where it is defined. To allow several modules with the same name in a system, -module names themselves may be qualified. -

A qualified module name is a sequence of simple module names interspersed with periods, such as -Data.Functional.List. The module name (given in the module header) is here just List, but the full name must be used by -importing clients and is also used by the Timber installation to store and retrieve modules in the file system. Exactly how this is done is -installation-dependent. -

-Imagine a module Dictionary, which defines among others the names insert and |->. An importing module may -refer to these names using the qualified forms Dictionary.insert and Dictionary.|-> in order to avoid possible name conflicts. See the modules page for more information on import and use of other modules.The simple name that is the suffix of a qualified name decides if the -name is an operator or an identifier and if it is a constructor or not. -

-A qualified name may not be used at a defining occurrence, only when a name is used. (The module prefix is uniquely determined by -the module name, hence superfluous in the definition.) - rmfile ./doc/summary/lex.html binary ./doc/summary/logo.gif oldhex *4749463839615a019c00f700003636363838383e3e414343434c4c4c4d4f5b52535b5353535758 *5b5b5b5b616161686c866b6b6b6e59366f7286735c39735e4073624a7460457474747566557760 *3f78726a797b877a664b7a76707b623d7b63427b6c667b6d597c7c7c7d694b7d6a507f79747f80 *87806640806c508075798080808084a182838a8374698389b484725584735c848693856a42857e *8e85889c867d81868aa2877d7c878889888293898ca3898dab8a6e448a87a38a8a8a8a8fb18b8c *928b8d9b8b90ab8b91b38c7c668d71468d80768d92bb8e90a38f72488f95c48f96c8908e8a9091 *b89198cc92826c92867a928b93928ea79292929294a3929ad49375499385759393999397b3949d *db959fe196784b9698a3969abb96a0e597897697a1ea989cc398a3ec997a4c9990939aa3e29aa5 *f39b8d7a9b9ca29b9cac9ba1d09ba3dc9ba6f99d9d9d9e9eb29e9ebd9ea2c29ea8ee9eaafe9f7f *509f804f9fa0a39fa2bc9fa8e2a07f4fa07f50a09aa5a19484a1a9e8a1abf2a1adfea29b93a2a2 *a3a38251a3a4b3a3a7d5a3abe1a4a8c5a4aadba5b1fea69b8ca6a4aba6b0f5a7a8afa7a8b3a886 *53a9acd5aab1e1aab5feababababadc9abb1daabb2ecabb4f2ac8955acacb4acacbcada498aeb0 *d6aeb8feaf8c58b08c57b0b5dbb28e58b2acacb2b2b2b2bcfeb3b4bab3b4c7b3b5d6b3b8e4b4aa *9eb4bbf2b6915ab6c0ffb7bbdbb9945cb9bcccbab2a6bab3acbabde3bbbbbbbbbcd5bbc3febcc2 *eebcc2f3be985ebeb8b1bec2ddbfbdc0c0c7fec1bcc1c2c2d6c2c6e6c2c8f3c39c61c3c5dbc3ca *fec4bdb5c6c6c6c6c6c9c89f63c8c6d4c8cefec9cbe4caccdacacef1cbcbcbcca366ccc5bccccb *d5ccd2fecec9c4ced1eed0a667d0ced6d0d6fed1d3e6d1d5f1d2cdc9d3d3d3d3d3dad4a969d4d9 *fed5d9f3d7d8e0d8ac6cd8d5d4d9d6dcd9ddfedbdbdbdbdceddcdce2ddb06edddff2dde1fedee0 *f3e0dcd7e1e5fee2b571e2e2e2e2e4f3e4e1dde5e5e9e5e9fee6b872e7e8e8e8e6e4eaecfeebeb *ebececf3edbd76eef0fef0c077f0eff0f3f4fef5c379f5f5f6f6f8fef8c67bfcca7efecb80fefe *fe21f90404000000002c000000005a019c000008ff009ff41948b0a0c183039f9858684207c287 *1009aa6168424dc48b0775501488b1a3c78f7dca3cd14871a18e271641aa5cd9474e4b39306196 *9949b3a6cd9b3873eacc99a5a7cf9e50820a1d4ab4685022489326b5c1b4a9d3a6302822fb47b5 *2ad53e56b36add4a351d49134fe4711dcb351dc57464d35a95a7d0245ab570e3c2d557cd535b86 *3a1c21132bb76fd57dfff609c647b8b0e1c3880dd75bccb85ebcc79023476e47b9f2b9cb983393 *dbccd99b67cfd8428b161d2d1ab3d3a85113f3c5ba356b58b063c33ef5a9b6ed4f983035dabd9b *10a13dc0dfbcb9c1f00957ac7eb7ea9bc8b05a72ad6619be7d5eb51a4535faa86b27fbcd15738a *7d804dffdf1e57f03ec28313ab57dfd8b163c9f0e355b69cb93ee7fbe43e831e4dda34ea2aaab9 *26a06cb2dd565b6ebcf5f61b707b08670545df6c851c7954b9429127e445b7d078cf7942912b14 *86988e2ddf31548678215267de79ebb598587bf1c5371f7df59d835f679ff1d75f69a80160c026 *cc10b39a80af11389b81b8e9c69b6f0b36285c0b0c4d689594145ac71076da696802877d2d4791 *73293e970e307d9454912b1186b9dd8ae9b9d8627b8cc528d98c94d568e38df9e9e78d8ed894e6 *1f33010c108003bb0c49a42f461e69a0924b36199c11146597159514b285579ac969c9655cdf7c *15969a72c9834c99253d812660a086785e9b6ebe09a79c90d1ff69276678eac767683c9e160001 *040c204015860e9828924926c824830d8e4111305a511aa223cb8a79d673c050e448aa6989eac8 *570b3de1493592624b219bacb68ad8abb04e26ebac37ea79ab9fa6ed9ac001821a00c9a188264a *dba28c36722c836fd8505cb3e222035ea6d37649ea4253899b155d9e70db9023e03a9ca2608105 *669eb9ebc1f95ebaf2cd38eb65edbaaba39fba12a0800209f43aa82c44260a0b92081aeb1bc06f *4441115f55399ba257c5f10c97a67db173970e9baa09f15d26e925b4c56a92cb22c72f7a0c329d *edb05bb2ad7cf2b8ab021330306faf02fc20ac91fbde56b382c8261bad553a609aaa3e0b9b00e6 *d009c365e5427d84ff9b6a7725f21dcc3b50174ed58a54770c63ba5867ad357e5c771dafca1378 *3001cbf40660af6bfaa66d5bbffede1c5cc0576675259ad85ac81086784b1797870c81f8b77766 *8697b4e1d80236d8d48917862ec8218b5c63ad26f307efd7132c1436cb2e3b0073be049ee2f981 *fdfeebe41191c25d3b8a61ee5d91df65e53d9697cda93966dd0ba9813aeeec6b4c6eefe73616cf *c772caeab87d5bef2739f227e960b9d80720db0f6e21b3e9e5a67aa273d217be34a57f006e7b4f *a38ea54c22b7ad108d3b9e8ae073e4412633a9af82ed0ba1c6e05735f95d6d5d76cadf9e24170d *fea9410d0ab11ce604558041e88b58a04ba070d28082d535b02a4b2b495efff6421e6831845963 *b92057aac5906b6d475b12f356c5444845f7bd8f84f88011fdea273cfc112f47272b8d0b1dd107 *356864792d1394034a81369a21b049c2214eb77ea81588492c2f534c8ec1a204beaa28f161756b *5872e8b2ad527dab8f554ce4c6b0e8bbc531ae8b295461185b48391da8c1139e70040cfd17b6b1 *f96a07d1a359824207c737408a21741c0b140d99c7b800ad5b1afca31f8f763bae04912243d460 *2215b9b17225ee778f84a46624b9bf4a5e1218aef044196378b979d1d086b0981ef56c56ca07b9 *ee2a7dd156031ec0cd6e7af39be00ca738c749ce729ab3010148a73ad7c9ce76baf39df08ca73c *e749cf7adaf39ef8cca73e5de8ff0960200318992ce31919c03c412d808dd15cd428ad271c6531 *44903e4bcb03e0e0878a5af4a218cda84637cad18e7ab4a3707800af464ad2929af4a4284da94a *57cad296baf4a5308da94c673a52b059b29fdfa8063292a9c991fccf930250c1ccdc68339cbda1 *870b61dd3f224a9607f821159388aa54a74ad5aa5af5aa58cdaa56af9a0a3f3c6065600dab58c7 *4ad6b29af5ac684dab5ad7cad6b6baf5ad700deb046e0a8c6fa4e31bff4ce6324d20436706a000 *6810253591f586a8f0ad67cf71ea24c0f0d1c63af6b190ad281826e1d50958f6b298cdac6637cb *d9ce7af6b3a00dad68474bdad29af6b498a5eb37e4a18f74e814a06434a309d0e8b205ff48426d *6fc4991c2b82d8e428f6a9a908ae70874bdce21af7b8c84dae7289eb07ca3e4007d08dae74a74b *ddea5af7bad8cdae76b7cbddee7af7bbe00def748ff90d49c923a73bcde4267f1a405fa9e073b9 *1ddd10f0d25bbffc3615c978867ef7cbdffefaf7bf000eb08007acdf6474d5b92f4cb08217cce0 *063bf8c1108eb084274ce10a5bf8c218ce3083fb80d370b516afc854260cf9dacccc01f6808305 *d8291752dfbedcf719e888b18c674ce31adbf8c638ceb18e63fc8c037b1593400eb290874ce422 *1bf9c8484eb29297cce4263bf9c9502e725dc1d7dad70654b6b435a82416aac33728217b4b4d6c *739f0a637a98f9cc684eb39ad7cce636bbf9ffcde8e8f1981f008c3adbf9ce78ceb39ef7cce73e *fbf9cf800eb4a0074de8421b5acfc828ef56ceab539eaeb793ed0d2a9771a63386488aa9637931 *3ae8910f7e78fad3a00eb5a8474dea529b7ad4f9a0479c7dfc806fb8fad5b08eb5ac674deb5adb *fad6b8ceb5ae77cdeb5efbfad7b546e43f3e9c57113373867fb582824a59e985f0c54cd086b6a6 *e9c18f7e58fbdad8ceb6b6b7cded6e7b7bdbfc50b59c9dab8f729bfbdce84eb7bad7cdee76bbfb *ddf08eb7bce74def7adb9bddd972ed3faf3cd08206e0001e887649de22f0829b60dad5feb6c2b5 *ed0f7f2cfce1d70ef7aae77cef8a5bfce218cfb8c637eeee7c5b39b6fd4ee3bf036ef02d61d3b7 *63ff4e45993b7dea968bdada2e8ff9a7533d71e702fbe638cfb9ce77cef39edf5ad8c40ef15efb *6a62655bcf49cd36015f30cd9569bff9e96aee34cc530df5aa9bb9e65e3db4d6b7cef5ae7bfdeb *60e773a211c9e8f4f6949300249b0a528c7430337d2b9adeb1dc694c6d98ab7aee78c7fa03a2cc *f7befbfdef800fbce08d3ce587e91bb6029d2d41456edbf83ae9cb963eb97d539e5f025b7ebfd7 *d874c2257e8dcb7bdec073d6b0e8474ffad29bfef4a86f30870b4f95a0eb75c444a7211ad6b66c *9cadd8042d96cb7d97cbfbe1cea2cc9b17f72c7a4f7c568bf7f8c84fbef297cffce65797bce645 *afa37d0a69b57f8ecba59caf49721f17c53236b21f55b9ffe6ed3e71f07b74b29545adfad7cffe *f6bbfffdf0cfac6a597b787e2bdedfb685afe3e3583ac9bbf8a95b158053c558e25777fd207172 *36590228805df55571f58010188112388114588172a55a77556c435762b247548d524a86650213 *f2765a3151e6d751514566e37780e276609475821b1552343583345883367883389883246553e4 *d568ea457d69e75e43a5504585334865024a458254a14de6d484dea40129077ce4376e7ea0014e *7885e8b44f5ab8855cd8855ef88560984ec6d44ffb0672f7c778086540fbf7060ec530dc5747d5 *5048b874487ef14a60910e083785ac960eb4e417fa800c72881774b84b846815bdc448f5904526 *144cc2344c90ff1339a32146632874b0c7817f054dd2447ba48433d6b4216f386c75c134134344 *cfb1477c931d79c8827a376c81244180184583588821842a88c3488a18278b013c8de888380289 *b822893c884967c75e64034ab29189d84758b7974afbd01da2e810a4a81d46b41048f40fa98880 *ac56154cb4104e9425a3e241eb238becb348b648188ec48834c28bf7513cc643493c6886591600 *07d546fcc276fc374788f54025613b2132410d2137d7d8827366159d123422d24125a13eb5248e *aab248bc4342e7082bbb48325fb44293e44295886c3554401eb889a373543e54151273260be917 *df701de01390ab68155ed2001af09230199331d9005ce19232299314ff001edc03178570933249 *935b61933e399431b9012b4006bf206c5c81316440944ef99432f900d0101f24009544b9011f00 *047d500cbef88bee38574008546623333884406df3065dc04055713a201422aa93547017852b88 *8d03a9159ea00193b05c93a0015c8197c8350923c007a22882d1b815cd300279795c7bd9978959 *7ca9600aa6b05845a0014bc00d7db10f5c00068e597c9ce00253091f24a0089b195c91e9075230 *02206008b7d227930336cab378cdf33c9d23581f8833d8137922a968d842376a598272698074e9 *5c7d990a520006c6799cc82905a9c0975ba101c4899cc789057ea0081bc05aa128444e9315f2b0 *018ae00758009dc6a99cccffa915ce599ce0799ed0f99d7e009960e00240000f7001185c2059e8 *599ff6799c52600a9e49958b759ff6e9079a900a8a10041b500993f495b1a739f7d21ab3598fb5 *393a02933e93e23076f804b7a39254f800c309069c705c9ca099e39915cec9a1c5f5a11fba022c *19877744872bc0a1244a5c1fba9c1bdaa1c507999ca00860800593600a60b001bf9016e6319fcd *359ac9c5a3faf9999241028b15a08e690a9c405960500702ea0229e00c91e83594138465e31a04 *744344f8a04e92066ff38914628a22a894d6f89bc1b792e4990a9a990cd710a7726a6020baa1f8 *25a771ca0b9c8005c489078bf68a25d101ca89059cc00b787a0d742aa3cde9a677ff7aa88e7aa8 *cf900cbc900a9ce09d4fea02854016415a519300a78ffaa9a01aa7cf300b6070a4fcc9a19e1aaa *909a0cc2c00b91c9583cba01bdd01f29b33222e73c31e3a56a334aa143693b33a1a9328d26508d *99a6a67a58976daa9999e70eccea0ee8700d8c1aa25631a2a9b0acccfaacbc80a3faa90c64210f *c1d0073a60012ec0a38a60a8e8d0accf1aad766aadcddaaeee7aade8200e883a0b1fba9e38e0a7 *5ad14b42daa9e2f0aefefaafed8a0edb40aaa60a1f20b0589c900ce70ab0fe1aafdbf00caeea9d *a65007b2ca9afe212f99b339f8428fb865963813a16041306ae28f710317189a8d8baaacee900f *2c9b0fee00ad759ab2d5bab22c2b90d3ffb901f09916f0a001dda9829cc6b22fabae327b0d34db *b2467bb4464b0fce8aa8a6e007a58a03a49015bab3a9cda5b0f680b4589bb52d4b0f035baafb69 *b008abb05aabb557b70dc9300b08eb071ba00bb90228bce22bc0b2b1ba4a3d8ee7364724b229e2 *3d5862b2c6aa8a19baae2b6b6d2e0bb38a9aac339b0f824b0fe2900c3cfaa124a01624e0a2a690 *0ce2c069821bb4316bb8448bb8107780a9e60e66db5560a0091b609987a33b85b1af569b709d8b *6da9d6b5059ba4618b0e9c0b71fc50b3d8faa13c0a02ccf027813228bb1024721b3dc8688fa604 *66a9441e6f8984ff475905b8a67f3bb481db0f832bb49a1bb80ef7bac9b0a7c4490664410683ff *9ab0db60b9d98bb9cb191eec20a28cbab9fde0709d7bbb8a0b7a94f501f88031e4a2bae8600fed *dbbaaecbb504fbb59271b0a84abbfbfbbe34770dbc90099a290561f0273e020941122c9c33b7d3 *04a6c2f10650725878bb1dbc593ecdebb3d08bb2d7cbb9d59bb9eaabb2b57bbb2fcb0b8ba59f3f *ba15bf30ae9365a82bcbba25bc9c78919dd4cabed43bb62dcbbaf0bbb83c9a0a41b00a863835f8 *abbf9eebc3640bbb2eb00c73d20e029cb004bcc43eccbad46b0fd88aa39ca001baf01fa921c1ac *d1a5a1d4916c333a9d68026da98449e429e93b79ce2b857e2bc2277cb8974bb81ab0293b3cbd30 *a7c5d0caa91bb00e5ab10e1bf082d59abf587cc31aff601742b4c724acb4007b665257bedbc0c2 *93b501f59b1e2c92c476c7b00c2bb0ff0bc5ea32c5629bb80c2bc9889bbd2d58079a000642901a *a721c60c4a960eda2884351c032321e461a67d2366713c9702299cd24bc2e6ab0126204855e1c8 *3097b8423cba7540027ea30f1fc0caa54ab9967b80772cb4f300a826a0ccd4fbb2a1ba0d957bb5 *7dbc6a9a8903cd6045a9cba9566b77f2aaaa9f3aaa5e2bcac123c5b3fbc8dba0aae2b069b59b6a *8bbba75d1cbc612ccbd0738c999843a594960f751cdb21acc40ac7207cacc23cc2d90ca2dc58c7 *3cdccf5cbbbd0b3c05563105ca89aae3dbcf155db855e1adde5cbdc8c50bc9b00d889cb895dc9d *75b004e4ff48189ccc82e230a9a369a44f1c2b9541ca55fcba3a6d5cb360a895dbcf415b07a620 *057730d0c3cbb1f065bcbba50363c1c66b71346da97b7d1b9c5e05b8c48cc7064915298dd4083c *0958600a3860c4ffb00a38600a3a4ac3fdfcd5d68bd1d35bc2e8e90785cac3fca0c51ccd0998bc *2a8671d3e196d34eeb9fe7999f3d5dcff63cc0f83c0b850d9e759097d6fcc8393d0976e0072ce0 *d44442c6c75896c6bb4077cbd0c9a1b768cab7bf0c9cc1dcd5c35cd21a50226092d2d7bcd7cfea *d87130091b600ee650c871e007b39079f69070a926d7263cadeb5bd7983bd4c315b6475dd223c0 *0e8921d88acb0b784da49d49cff301d48dad99c655afe2f7db82ff8b0e8c7bd61a400c0172281c *499bb63c3a3f405f559d1ccbab54db71b2c84ad7c22da3b0b3102002dbde4dbdf1eba6f3fb01cd *f5a6cb7d80f670cd8aecd525ed0232e902788dc2304db038400dcfcdcef9ebced26dd656e9930f *00c57482dd0ffeb437999f6050ae239db884eb02ad10cb04dda0b8f5d963aacb72413e0b7137e4 *21df134ddfac4d157a9bd2ccaad1ffac9958c0a7a83ae0df6cdc788ce0df8cc777e10116a001ad *4cc59c1b6e958cd752f00b135eb5158ed3172e05ac608e11192358e3e1fcedc4b9a01fce200441 *e0a6a60063f8cc0b75c00941f008b1fcd49dfda5cb564a206b1c64a18415aa4bbe1cd1733cdfc4 *ede0496ebdfec8e344ffeeb295bc58c135c3dbc0c7fe6ce4733de8765ce8753a0fd7190114aec4 *52bee55d8e18d04dd893c0e5c0543f8a4d1962febaff5be6b6f20138daa955dce954fe074242e7 *b171d075fb06694ce330ae16c1602da062e3aa4dd1966ed2ff60443c7e0d032edbd7e0d8c6c9db *be0ddc8a9bd1c58ce4076e15e950c8609009a5cc8253ce09557ee5b0cee9d1dd5ca4fee5602e2b *a9eebf5ecbea1629049b6e77533eea6b20bce64dc1c562c14fd27f7b0e170e9d2ac2aea1ab5dec *d2fa0fd592ecd19eb8e5578051eec7d47ee403afc82430f113bf019aa999cf50d75cebe6a61004 *cd20eeedace5e6be01145ff2267ff27c70ea97b1ee64ae3fd3a0ed502eefd2ff0dee7f802f057d *eb3493efb5373ab7e7e764ba84588d2d016fedd5ae15df90ec702ded423cb9cb3eb8709de3118f *b9684b5590f9d6255eec2e8004a0600d89b8ce584eee84ad094fba805105065380352b7fcf1fae *9f94900b6eff0aa10002215de9aafeb48f60eb8a52cb1ea9401f02174c45dae232f4510ff1c45e *bd2d7dcd63ce0bbc70f5636e600f3fe9c95cdcc27d9edf3909e6dacfe0edd6a6a001247726da80 *0fa12edddf69d8c84959673f1f99c1f2041b042ed0faad8f03406ef9577fc3288ef70965e7bd0a *300d12827aae1611f5de1623f8855ff4c30fad4c1fdb0effd2fc2dc4744ffc385ee89c10fdd21f *fda6900ae66ae01bff822c403b81ff1aef5a3efde01ffed3dfb3a75f27a9aff6634eaa9c0099ec *0f9938aa08bd5dc5d40bde00bd01b67fd0c9383a90b71059bdc14004106a4c0c3451eddf418409 *152e64c8f0819f497e523d43478f5fbf7efce8a17b960aa29f070d35a40293ea9abb7c18f3b9bb *46329506912e4fa6ecb7b2a5c46b152fd6dc5891a64674374da254c9d2254c86234bce2c7a2dd9 *53a8509f5d13e71323bf7c41499a0a420b1fbe78d640511918c10fc464e8ec5da5272eea5bb851 *7945f433a5dddd7379f582980486535a9af9e86d9be507cc61c460eaf8e1c48b22bdc08379293a *9bc2d765ccbe606de60cebd427d0a141636a54ba3421d47b54bf79d385a0094f0d19f659ff184e *07c127f264efe6bdf061c4893ad972f41831645299446b1a2d8974a1d2a181994fe23573a760c8 *576dce5daadce6d198dd23a3235fde3c3a779053fae3b98dbba60df3becec7376f198bb393d2ae *cdd8f3fcffffdca2cbae76f432902fbf005349b2591a74b0415e784926a7ec54d20a0caefec8ec *b2ce3afc4cb44f3021cd34d408516db5345ac0adb784684b0898d71cc187451a77fb4da2c77602 *aaa38f8e7b2e39e95a6a2ebce89a22c92f5eb6a9b0269adae38593c38a5c4ec89788648ac97cb2 *d4724b2d315ad02d533094a210facae422bffdb4e3724d36374a664003e344f02f7422dbe64e3c *f3bc13bdecd813ccbdbee0db10b30e37fb5034ff114d6ba44413577b6388d774abd1c57ff071e4 *35606ad4b4a11b83b368381e8db3d23be6aa444e3c2331c43019712ae4e7bab69209334c29bf1b *f2d422d9f372575e77c5aa2d1e218aaf4cface444bad7e74ed75595fed41e7cdb3ec8a73afbee8 *8c8c1e6cb3d5165b7bf2d98927b7b692a289410b3514c410472431b513dfb0e235643675519e27 *08d2219c4df355a8d31c412d0ea45183040fd72b6d2d0c47abbc148cb8b3664175ca817f445559 *66fdb15861c1c4e1d1af0dba21763e63f543966266997516dabaa6cd8b9c3915cc884d2ebf5d30 *a88327d940960dcd3d1444754f63770fd6be88315fdaaa794d8d79f455fa207e85eb8f61510926 *954affe71482aee052a154a4ba3a75ccea9ac9fc023255532596122b98b594f9d77021aa63858f *bf0a39cd97d34efb64385566b95a0549ee95e45f839a0b0b53705823b35bccf50cdd7415fd19e8 *375224480d7dfb00e5b5d8965ebae94f9f0e1560a905bed56caca99422152ca853d2cec15339fd *615bcbb67a6c9eb6b55dbd8bfc8c95132c52c10198b8e746b6bfdb8bd7f6d9bc572667f9bd13ac *33d99279459b1e77346e5d8a10caf590f110155df467d6deb0c15e4937bd8d208334dffc234f75 *dce8731f6787bdd4aa13ba7a6a974650d51456d58b7556308c8076b1ab1f42ee271d3d25b02af4 *e896c2583299b3c0ed63c2e38f46c491400ceac929c953defff25af63c2ca5ed2af6688b5352a1 *88de810104382394e27696ae9e7def4490831441bea134dc944f7dfae29cfba0063ad2e16f74f2 *ab15fd1e42194fbdcf2394d9c001c956c08338714abc78d08322948c6d248c1f27a3d508c241ac *7a50902de2a06215cd7846ba744015d33807f398f7c1f100482db0da86304c6118d46120169849 *9c0bd195a87581ef0d4780d7d20622a31d6aae87feea51c09ee8488835c70223d0da2c72423345 *f86504d490220121f91dc324e6307e508429b8660f58810d2258b0047deaf14a31f6878c991465 *2d6d7996080c44078658e31bf906c23fc56575dad14a8ff6d8429dfdd17b8c6a97bb5ee30acd99 *2053895424fbfaffe5b97fc5cf7e03a4df27e9078c0ee00075aa0354ef7060897f74b29ba1239b *29dcf94e4e18863a57b2e09bc0e00716cca71ef880259a8667415e90f29d032568413dd281f311 *84077f78c5077ec93a4e4434a2fc6b5564c0549220908b433a7b61f79629c82d604e7d94a36635 *8173cd1d65d39b545b2978c2110155fd2519500a1310a2c84d962e641feaa4120e5cf0d39f0641 *22096ad5759e650ac26de02baf646a2c010a11300055aa53a5aa0b98400e67a8c20c28780d041e *ba20c224060b38e91a58dfa3815168c68f3cf3def71a05b92e707520945a1a5d4b9aaf4562b391 *ec8ca4ecb639bf9ca6a3026e4b452aea10910ddce3a6808d1842f6b153ff9c1e851b93ad46357e *b1013068c20f96ac1001d5c1d47ac4231e53f06705db12d04948810fcb606d6b5dcbda610c2317 *b3cd8534dc488e6284a20c26f0aaf3ece4b0544c621224519dab9cd591c382a1038a8305e30019 *c866c6952076551a75ef5aa3bca674af41149d5f0d18d9d17143039ab8a761e0c38def32f656fb *38c86321abde97102b1c1b40aa299ee11d7a08c9142e0807685f49da6399968c10914227ee72e0 *02a94c2fb7659e37bc810d0c7cb53d0edbaf04a430abb4742e633335a7190ac5bde7faecad4193 *ab0948ba43eb5e9745d955e2768958bac6feb588393d0829c4890573a233bd333e0a7bddfb587c *f0f4281ffb004d5d26986b50ffd805d678a568450b60910918b5053eb0823bc8600767d91b7004 *ab9243b101ca6cf64a5354441c6c568ace7434c4eb6ae6174a7c6214ab9887d6749a76a3c6dd47 *f2d5930959c2e95c17011ddc70b13c6ece8fdd1b64f0c6b74cf3a02fe1ee1b19fdbaa01b4e7632 *94e9f6d4d41a38c10a667083b5ec602e4f18432e0881095c80d44c60d1556e2209945260a88e36 *2e90237e839b27a78f92a658ce36a273e7ec0cc4170bd1bb8386f110ffa18f0f9ce5011e18c834 *855ce8af00f92bcf56f47cc2c1022940c9249d2dd508d841e92797768c53ee8495178ce54f3f18 *1ba1fe9392336002986a9b22a834eb2408e7022f2c4e998e2b5133b7f0e6ebea7ad7ff9ceab50f *e1d75263efb8d8defd860634d089d71802d1f0d580b4e9436d17385ce3fa1b272f8a6aa167d477 *03e00e7780c7bd4a8da75ce52b77f80372a1656cc49cdd8351f21acc60020df4656b63b6c9c1fc *b0815238b7adfd76d4155e23f0ea0e5c532cfea136152e6c28a633d15064052bfe611bdc505b03 *717b362f0afbf5c26a020b8ab02408b7883c30288204241fadb86519504e805dee73973b275cf0 *7275c77cdd126ef7a84571192a8893a8ab3eaa9862f0c79e11bd5def9aae9c91aef48430fde07a *5e279efb1a7584cc432003d13ad7c16bcb7b7262168f611d540bc1764bfff3b4a1047debc170e1 *bbeb5df6330feb7eff7e191080e1a473acff3786460088d0c4d0ad33648d1244ea78c8d348f22a *a53c8d83dd5dcc23041f97c3f9d43dcf58ba17564214fac9715de28265a0deed00cd7ef9bf3eab *d8cb5ee67ca7b9df31838a0d40a9b83ff9dabf3080095943773540ab61b307fef8e4fb87e57331 *195bb8a8d33a8530b41f339acefb189eba06088c4009dc0671488ff570129dc300b66b3b939325 *09fc4010fcc06750b25750bff5f3ad2e733fcc6882d7a1a8cefa1f8cb2002f08848fa2b537b881 *d7489f5d03c0e41bc03b7bbe3cb3bc3dfb87c76a2f43fb0a76684062e924ea7107277cc227cc16 *6f511818e48a4e00b7bbe0c028630b28ec422fec4274a83d172841f58b06da53b2dbe3100c2025 *ffb29a420ccc2c0d283513b0012fc803c5638d318081d710b4ff4b08f60a40df283846fac10284 *3a847b893ffcb1683b42252c934eb21bb5d99585b989b3c08076a034044bbd0a8244bb69bffd22 *436c8806513443f613c334d48c4518813099bf11228ee49280d7300114f00125f882d5b88212cb *8de4eb03052c42220444cef196c0993c21ac3c20bcbc7d88367cb0b825b43e071c1bbf899e97d9 *08b0e98bfdc205d142b003d344e891c692e9bb4f0cc55164066638c351bb848dda8c19b8b055d1 *89c0011bb1f31d1b38831f28b18140811be83f13e04114ebc51f73ac3f9433ced996a63bc4039c *ba648c9b66a4b8eb93126ff412ac2021ebb137d72103ff27d3c6bbd0449979485e01c7311c4772 *2cc752543274ec905200b38699097ba81eb0b9a31482003d400d3750821bb04782802640ec0362 *51c465f4c7440cc85fdc94a60110627c3e2de9a65e3ca0a3a41a857c46f158ca2173cae8e0442e *c196304c86134a211238078cac324da44a48f4c48f8c8690244738d212b12cc90e618353c38254 *5392a0c04a9d330529d88021781c67ca41403c089d544869f349f732425fc42ef6498667384cc4 *3c4cac244085438f27bc10444c4a99704c2784ccad6b4a479c4c28b4cc86cc892ffc4c77200f71 *700a5eb8a39200830f1887ae34104bab40d07c4d3014c35728cb90fca0cd14c345d09914f08b92 *78866d7886ff27c1233f7081128849e27b8328381a1d0ac0bec4cc9e5c44fa004cc12442436baf *4e31bf6cfa49f7828e09f940ac2cb4bf4c46ee04c1efac36e79cb854e84e092ccfcb7425f454cf *100cc16748062a32854c2a2529608172d04695b1b4f8fc4f001dc1519b4dda14c904014101ddaf *dcdc9e48d8009d9390ac9c044e9082085002417a831f38bebde4cbf3fc98f05cc4f0044cf7fa8d *f23a0b133d517902097f548ab8a33b6dab38a76cd1b97bd10e9db656cb3e1a75a5576251ec9c3b *77e28488182b8f18013ce0ca2a533028eb5125053bf423d0b2240604d184ec43bf053d97d07002 *c18ba828a9830d78813d782bc8f90215419f0d6d911a3dd33261c6ffe87cac87082ee17a533885 *538f788084cc4c2970bdd3694f3bc553f374ce91b8d3d6cb53ff62aa3f75bdd6c382d0bb231c00 *8161a8b24debcfb3305449053dd8735272240628ed0b3c5550ce609cdceb0b2c00521ca0003400 *d3f03102e52c53334553563dcf078003148d5514858307e0bae1c2ce49d0d38bbb55f3cbd533cd *b91ecdd53e98874105d625655253e88bba64015b403073d38b292889639dd654b03b51084962c0 *0c1050841eb5bbdc8cb54f1884f81b2e30d8801c781ca0c9434c51558568ce567dd78f69800798 *577aad577ba5d706889b06603996cbd778e5d795f3d70edd57804db90630011ee8afd0122d822d *5880dd001298024f0007ffbc78d60e620287cdd88c7d806bcdd6cc00018dd58007003ea16b841a *9082e1e4003bb441e3cb217655083980579925960020000598001d50034f00866fd0077df80660 *f00435d081095000020880994d5a991dd4575287dd228860d840a9c5c4aeacd867edb406238774 *cb3b131447b22c50daf4d84141a664423c7589800d4802305d8d2f9081677ad9858859a59dd99a *bdd99cddd99efdd9a01ddaa23ddab9fddbf3645a4a0b2dea1b084a985a92ab5a67b558ac5d9ead *75b0ae8db95124cbaf05db6c15dbb1652e7ddb3745418398b44142c28d7480db852803c085d7ba *c5599de5599f055aa1255aa345dad3555aa6ad5dff023763780d2a0087a9cdc2ffaae54ae0bd5a *ac7d5cae35c1c9ad5cb065064c1ddbcc602e701591c49321e2eb023d248869225d8530ddd965d5 *d4bd5bd6d5dbd7ed5bd9ddde1add277eda27f4b5dd8545dc7800877a19081a3006b653dc4765dc *c6dd5a6c28de3204c9e4555e5fc05ced71a15883de8f9a21c8799454c5ded205ada5325ff2fd98 *ee5dddbc755dbe8ddd072e5ff51d5cf64d5c44788d50b844fa3d52e16d5cadc5dfc8f55a51ecdf *4b5d5ee6552be672aefc13315345ce12d381785160862883416d601ebee008c6dbd6dd5bd8f5db *0bd6d10656df268b8724dee00d5485d7280375f8dde01de1e17ddc13d6bbc95561ff6de13e7a61 *106b2b9f39ce2e705b82f0045cc3e1ff1c4662ff72cfbffde1efa5e0211e5fc055e3da65623bbe *c876908684e2016910618b6d2312765c133ee12cd66200ce5ccd0531e11bbe664a037d5483d145 *e3862803275b583a665a23d627078e1b379e6021165f3465e0f3bde441bde33b56dc7278da8150 *853f3eb7fb1de42b2ee4fec5d443ce19cd7d5e3056bc0356821abe61499ee4a9052dd12265a6c2 *074a0080004866655e6665b659d50562f0ade0a365666a0e0000a0845126664b662a53b6e310ae *b2c2358144a0e22ab6e25896e5e4a5e5164ec7b532db1ab4412b18d381708533fe6560eee64aa6 *e304180002e8677ffe677fb65b090ee2f0355a803e680218800450e3615e5f25c66753fee6ff04 *dbb45e28312ac8863809644ffbb4fcbd62144e612d5e67b2f59053186002e637bc7c832d20e343 *5a4e7b2e5d8826b9255662a632869a4d0005c8699ddee99c7ee637fe649e0e6a054880a3955f9a *5edf998ee9889668ab9d9669208b7bec054026616f28618ef6e85044612ddee275d65ccf30e95c *d6e5a0c1c1c989e497de0d4a566a2616810138809b9d00b88e6bb9f6694f0edfb9be6b05388001 *1001b5ee6bdffde6565e993f780d507865e2c56aafdd6a755ee72e4ea6e75d3346769431c850dc *d0c1b346ebbede6075180085660066d301d00e6dd11ee868166dd3be0d0f60807d1e0075c8ec53 *0661a6aedf3f661e27268832c886db32678f3edeffad2647911ee9ede11e8f7ae7e31c037db4e1 *cba691b4be44d7dec044b8e9093081275003eaaeeeeaee036876dd3eb06eeeae970920ea004884 *e6dec0d85edcc0ce68062b8684d28162205efd8d5c744ee75a0ee076e699e146e91936eed7d081 *eb4deede2803fa1def784080b6166847f004044ff004ff69056f7047a860bd4e0001cfc6f236d2 *f39e168dce0655360155b8eadd8e6ff9fe6d76e62845163e666aa6c9deeffef6efff2e6f0ac767 *9b268004f0ec27c06e60b8711cbf7164986064c8f11cf7843e7882d4066fa346dc2cc4c2f2e6cf *0bc7708d765cabae84d7f803c4fee8de66e1dff6eae6126ed288a17e9be12fa06c5d5a7116ffef *e04df2ffae4c5ce616ad0b28f0e856034770851dff06399ff309a6f339470657787013285abdbe *00aa3d723397e20269ea256f72377adc5ab0e8633867fe55e1c5e6622c2f692d37715d5e8d2d20 *6b5df2e531af913288133f0e74c51d07ce9e710ff0de6a480779f059553f0855f7597948876a10 *e221e76cd504758cd40bd95e72573674abd6ed63806a594485fd05f1e415f111f790cd45bcb04e *69776169e9d6f44de7f456b6da234df23f806ee9c6ee1daf67d9f859640072ef06ef3f48f2bcf0 *635de7345e3f742b7eef501c6c82a884e345de599e6f44765e492ff1653f4ee4acde8150033e8c *f64de9f47357998afddd76300036cfd9374706b3968d74c0f3ff07875dbd368082cf755c1f7874 *9f6a43776f989bf250780d283886dec65663c7f264e79945ae74c8190323b0c73e6878800f7837 *521e8cb7d85eb8691ab7f16a70e98490875807f7213f5aa9aef9f34ef74ee378c89df2e3d5051e *b0975a98772b17e94817eed168044a4757d6e8821d88454fe0f998e77412a679a237903577eb36 *5ff89e6d086fcf7381e0f301b880b1cfe82b33fa12ee75589ef28fa65c72dc852c788d47085be5 *a5775bf66aaa87deab67f628e077e916f3afcf9732a07bb1d7f56c1875cf3675984708589775d5 *e66c8c3ef7e5997bbaaf7ba44f7abc975c620f4941780d33f085c02f7993bf77e7826c46595ba0 *f9822170f97f6ffcffa52903070bfdd037906b97f1e8ae714fd8f685f07670df73717765d0f77d *aa1efd9863f758367d901e795428311e3826a93779aa8f61fc3660c8b10267d70157f07add777c *f7767e434778b3577838bffc87677b891f0003507f5e1ffd2c8bfed2c7e2786f74c506085fc464 *513161d004245f0a172e84e5f021c487a73e4dfc64f1a2454c1a3135eae8911048427b46927cf3 *a6cb1014074da8a9f6ef25cc983267d2ac69f326ce9c3a6596f1e6f327d0a03ec9012567f428d2 *a44a8dd60a402001030f4ffa7802564d5e4c79d58079eaf3c40383040402d45a6af62c51a16ad7 *626bebf62ddcb86da3cd8d66d72eb3bc7af7f2d54b4c2043856b56ceb9d5ff30226258a716636c *fc4963238e1e3b86044972a4c9374a60acd4e109ebced0a247931e9de5adcfb66b57ab353a94e8 *d20b030e2898c0d2912b64dff4bdd4f70d992b476a4c4c507060c005b3458fb26e1e542e74e874 *b1ddc5dbf77a5f627fff060efc68251459891133767c71a3e4c995455ece6ce5c64a137d5c96ae *6fff3ee9d3d1517b53edfcbf4fd30c3000541ee8a04655d5a4f3523a5b79a2860e602530e03400 *02e8df7e19ca555d75d879e89776dc7537a242a3f070100a8c8c375145e6a137d947955db64766 *5ba4b4d213c0f0861f8f3dfa18937e1a0a890d50fe35b7865309d8369527bac923cf6f5d3d419c *5801ac612186436ae9d6741ce2ff65dd87d711c34c88249a19912c50ac2408442d9a97517a30ae *3763665f18d142679e2cf8239f7ddaa7df745b0aba9f01b3d576206ec8a4930e70c2e950dc7106 *0c3aa9745e76c80c986166c79d88660676cb780fb5b152156f9ef7188ceac9d81e8d631cc1d94a *8e7ce327adb58a0685a577513a282a4946c5a4550e7a25e158a8ec3a69ae996a8a9d76647afa6c *a88941a292413c44e2e246a93632677b268d6104ac07cd672bb9e5de04455f5f26cbe1b16ec946 *9b6d6a24dae870900ee040bbd455a76fae7a29bbeca69d3e4b62b4e36124490f2b01026764da6e *6bd98c98bd6167b806f581cc8ee66abcf13fe802ccd7baebd635575bc7084060540756ffc51584 *120e20c03124eb3b32bf21fffbb1a621ea3cf099059367ea2755aca485c3db3e0c319d36e2b9d2 *c51973fc74b91ee33c35a636475345924b5225259563556175d57bdd4cb5873b03c673cf3e4ba4 *18d0186172c64a361ca26a4811d3f886153f502b2ec650fbadb1c763923d387685c28ba8a3f61a *4038e37c09be9d766843ab769b8b95d7f68b8de4b1b4092888b12a9d6f8ca1047c79cefa37eae6 *42c190cead37fef126be4ad5c7b0618db5c9eb00b7ae50e4920f4c796296b70d67b6a91e62c34a *4a846ed21543546cc213aeec993af5e4ae2e79eb8f0bfeba0386c65baf71f7e64e66f665fa2ef9 *2da0c2e20bf0950f7f5ef1dacae8c54a3764ff3631e97b5b8c0c68d5fb6febf5ce67a6de11507b *796916f9b4238b93154807110acbcb76a1b3031a907cac13980033d8be9fb9c954e8e1489ce4c4 *ad91a0616f2d88c20f3867902778e274ff7b2100332843b461ed29b6e95a00aa30c31dfe6e83a1 *12defb3e1842ba81ae2426f982fe0ea20347f00f864eb4de7878c843c3d5467152dca10fa365b9 *0e62ee8345a3ccd1d8b33cbc392f3e2c01c6f49ea8465a41218bebbb228920e12bdb052021701c *911b8107c4f7c10f325f0ca348c45812cc8c210a658c8f1a5ce1c23532925644c8e306cfd73dda *84cf01e78324266161112e7631737f5c0fd2ba7544d2a9d020895c642353e927229c2293ae8c48 *29ff1838210194e295b654cce5f8d8184f7e9110942962e8c6608521c8c08c3ae8031a55a94c72 *11c13c6eaadc2da37502a78ce504d1fc612b71b9c95cea124e8ff1a31f7b094a411a31335730c2 *0d9208bd26f56f99ee7464372f02c42d92278f8c18d0805464cb2d6e319e6fc2441f413844f9fd *1298466c9515d0594a131c1318bb792744c965037f52b431e5e1674516c388090420001360c436 *fb29cf8c72b2a21e14e240c53942bb99e46e5f48e80d16ca12575c25a2362d970d1ad611219ab4 *a7160984090e70001380d4a726156264525ab471d6cd6e77cbcc18ae70841f3ccf20c7a4693b6f *aad55ae5f48f9341a946e067d49f9ac0031e3041208c1affd680662e9c5e4d15539bead4fb89ce *0a5395813aa1e708873a6dab7eb5950d42f2d62f8275a7603d2c40817a90b422f6b08605a75207 *1b5783d249626fd842148cb083aa5ab50fb949e35f438bd3c95666b0a67dab620d1288d3b276a9 *a495ab536964c4316056b330c82bf43caba8be8ab6b7388ded1e5e0b92820eb7b5a94aad09e860 *5cb81297a923a16c6ce94a5bbbfec00632b5aabcac025adf7277633668e9dd801b5be192b73262 *58c9e7040b48d23e1794e2052e5d45b7052b2861083790c175b1bb570575b7bfd433010c6cf083 *2128210a56f8c218e29b99f73298c1e73d88181a2ce1b95af67e637869148e3084eaded68cf141 *546ebe9155fffb9218751e5e090a5a00831b0cd80805b6c21610ac60f0de6fc22379b041226ce3 *192bf8c2f38d82128cb0e11bc0a005b88dcf13e4e50aedf2b6c44eae9e3c1a048ce0f4410d533a *f18953ac6219dc6007031e82118e5060035be10a5b10c317103c8635a7e17e5658c915ee978635 *af39cd62d8c215ac60852800f90842def00eee5b642363f9c449ee036eb43be227331aa2fa48c7 *37aa818c297bc2115ed141a133ade94d739ad33a988a233cb1646454e31be96872a353dd687d44 *f91b919ef4945de1894ad34e0db67e02ae1d88e94e5bd581b84eb2ad69176a512f1918a476753a *e4816a5533bbd9ce7e36b4a32ded6953bbdad6beb6680302003b newhex * rmfile ./doc/summary/logo.gif hunk ./doc/summary/menu.html 1 - - - - - - - -

- - - - -The POSIX environment - - - - -

The POSIX environment

-Timber is intended to be usable in many different -situations, ranging from embedded systems to -standard desktop applications. The interfaces -between the Timber program and the external environment -are very different in these cases. -

-Thus a Timber application must be built for a particular target -environment. This distribution provides only one environment, -the POSIX environment. Also this is incomplete and a more complete -version will be provided in a future release. -

-module POSIX where
-    
-type RootType = Env -> Class Prog
-
-type Prog = Action
-
-struct File where
-    close :: Request ()
-    seek  :: Int -> Request Int
-    
-struct RFile < File where
-    read  :: Request String
-    
-struct WFile < File where
-    write :: String -> Request Int
-   
-struct Env where
-    exit     :: Int -> Request ()
-    argv     :: [String]
-    stdin    :: RFile
-    stdout   :: WFile
-    openR    :: String -> Request (Maybe RFile)
-    openW    :: String -> Request (Maybe WFile)
-    installR :: RFile -> Action -> Request ()
-    installW :: WFile -> Action -> Request ()
-

-The root module of a program targeted for this environment must -import POSIX and contain -a definition root :: RootType. -

-Here the type Env collects the services that the environment -provides to the program: the program can call a function exit -to terminate the program with a status indication, access command line arguments -through argv, the standard input and output streams -as stdin and stdout, open files for reading and -writing and install listeners on files; see below for more on these. -Within a definition -

-root env = ...
-

-these services are accessed using dot notation as env.argv etc. -

-The read and write on files are non-blocking operations: -

read returns a string of the bytes that are available - in the file at the time of the call. If no input is available, the empty string is returned. - Input is line-buffered, so no input is available until the user strikes return. -
write takes a string as argument and tries to write it to the file; - the returned value is the number of characters written; for regular files this should be - expected to be the length of the argument. -

-Because of the non-blocking nature of input and output, programs need a way to be notified -when input is available or output is possible. This is the role of the listeners; a call -

-env.installR env.stdin inpHandler -

-installs the action inpHandler as a listener on stdin; whenever input -is available (i.e. the user strikes return), the runtime system calls the listener. So, in -this case inpHandler will typically start by reading stdin. -

-Execution of a program proceeds as follows. The runtime system is responsible -for initialization: it creates -an environment object with interface env :: Env, applies root to env and -creates an object of the resulting class; this gives an interface to the initial action of the program. -The run-time system executes this action; this may -lead to creation of more objects, scheduling of future actions etc. -

-After this initial computation the program comes to rest and -reacts to events, such as scheduled timer events or IO events on files with installed listeners. -

- rmfile ./doc/summary/posix.html hunk ./doc/summary/programs.html 1 - - -Programs and modules - - - - -

Programs

-A Timber program consists of a collection of modules. One of these is the root module and contains the root -definition. The root definition must have a prescribed root type, that may depend on the target environment. -A Timber installation may support several target environments/platforms. -

-The other modules in the program provide auxiliary definitions, used by the root module and by other auxiliary modules. -The compilation unit in Timber is the module, so modules may be compiled individually (but see below for dependencies). - -

Modules

- -The syntax of a Timber module is -

-module moduleName where

-   importDeclaration*

-   topLevelDeclaration*

-private

-   topLevelDeclaration*

- -

-Here, as in many places of Timber syntax, indentation is significant. The import and top-level declarations must be indented at -least one step and be vertically aligned, i.e., the first character of each declaration must be in the same column. -An exception is the (common) case where there is no private part; then indentation can be omitted (and all declarations start in the -leftmost column). -

Module names

-A module has a simple name, which is an identifier starting with an -upper-case letter. Modules are conventionally stored in files of the same name with suffix .t, i.e. -module Dictionary is stored in Dictionary.t. -

-Projects and Timber sites may use hierarchical module names to allow multiple modules with the same name -or to indicate structure e.g. in a library. Thus, module Dictionary may need to be referred to by -clients as e.g. Data.Object.Dictionary; it is up to the implementation whether this module is -stored in Data.Object.Dictionary.t or in Data/Object/Dictioary.t -relative to some installation-dependent notion of search paths. Module hierarchies in Timber have no other significance -than to support organizing and subsequently finding modules in a file system. -

-The module name is given in the header, as described above. - -

Dependencies

-A module may depend on other modules, i.e. use types or values defined in these modules. In a Timber program -the dependency graph between modules must be acyclic; no recursive dependencies are allowed. This means that -modules can be compiled in dependency order: when a certain module is compiled, all the modules it depends on have already -been compiled. A compiler option can make the compiler decide on recompilation order after a system has been changed. - -

Import and use of other modules

-Following the header is a sequence of import/use declarations, i.e. declaration of the modules that the current module depends on. -There are two forms of such declarations: -

Import declarations, exemplified by
- import Data.Objects.Dictionary
Use declarations, as in
- use Data.Objects.Dictionary

-Both forms of declaration give access to all exported entities from the named module; the difference is that in the latter case -one must use the qualified name of an imported entity, while in the former case the simple (unqualified) name is enough, unless name -clashes occur. -

-Name clashes are handled as follows: -

Within a module, name clashes are forbidden in the sense that one cannot define two top-level - entities within the same namespace and with the same name. Thus the exported names from a module cannot clash.
Fully qualified names are supposed to never clash, i.e., a Timber installation is supposed to be set up so - that fully qualified module names are globally unique. Thus use of a module can never lead to name clashes - and clashes on import can be resolved by resorting to qualified names.
If a module imports two entities with the same simple name from two different modules, this simple name is not in - scope in the importing module; the qualified names must be used. The Timber compiler emits a warning when such situations - occur.
If a module imports an entity with the same simple name as a locally defined top-level entity, the local definition - shadows the import, i.e. the simple name is in scope and refers to the locally defined entity.

Exports

- All the entities (types, defaults and values) defined in the sequence of public top-level declarations are exported, i.e. can - be referred to by importing/using modules. Entities defined in the private part are not exported and hence not visible to importing/using - modules. In particular, this means that the type environment of the public part must be closed, i.e. the type of an exported value - must not mention a type defined in the private part. Imported entities are not re-exported, i.e. the import relation is not transitive. - - rmfile ./doc/summary/programs.html hunk ./doc/summary/simplestyle.css 1 -body { - font-size: 12pt; - font-family: helvetica, "lucida grande", sans-serif; - margin: 0; - padding: 2em; -} - -h1, h2, h3, h4, h5, h6 { - font-family: georgia, times, "times new roman", serif; -} - -p,a,ul,li,em,strong,span,div { - font-size: 1em; -} - -p { - width: 37em; -} - -ul, ol { - width: 35em; - margin: 1em 0; -} - -li + li { - margin-top: 1em; -} - -img { - border: 0; -} - -pre { - width: inherit; - overflow-x: auto; -} - -a:link, a:visited, a:active { - color: #1C5380; - padding: 0.1em 0.2ex 0 0.1em; -} - -a:visited { - color: #584781; -} - -a[href]:hover { - color: #111; -} - -a[href^=http] { - background: transparent url(data:image/gif;base64,R0lGODlhCQAJAJEAAP///wAAAP///wAAACH5BAUUAAIALAAAAAAJAAkAAAIXlI8ZK8sdGpggWhrAyXVGSVUGh42OIxQAOw%3D%3D) no-repeat scroll right center; - padding-right: 13px; -} - -a[href$=pdf]:after { - content: ' (pdf)'; -} - - -div.navbar h3, div.navbar h4 { - margin: 0.5em 0; - text-align: center; -} - -ul.menu { - border-right: 1px solid #ddd; - border-left: 1px solid #ddd; - border-top: 1px solid #f0f0f0; - margin: 3em 0; - padding: 0; - list-style-type: none; - width: 100%; -} - -ul.menu li { - padding: 0; - margin: 0.1em 0; -} - -ul.menu li a { - display: block; - padding: 0.2em 1em 0.1em 0.5em; - text-decoration: none; - background: #fafafa; - color: #222; - border-bottom: 1px solid #ddd; - border-top: 1px solid #fefefe; -} - -ul.menu li a:hover { - color: #000; - background: #FEF7ED; - padding: 0.2em 1em 0.1em 0.55em; -} - -ul.menu li a:active { - font-weight: bold; -} - -table { - border: 1px solid #eee; - font-size: 0.8em; -} - -th, td { - border: 0 !important; -} - -th { - font-weight: bold; - font-size: 1em; - border-top: 1px solid #fefefe; - border-bottom: 1px solid #f0f0f0; - background: #FEF7ED; -} - -tr { - background: #fafafa; - color: #222; -} - -tr:hover { - background: #FEF7ED; -} + rmfile ./doc/summary/simplestyle.css hunk ./doc/summary/stmts.html 1 - - -Statements - - - - -

Statements

-Statements form the bodies of classes. Within the sequence of statements forming a class definition, there may (and indeed, typically -will) also occur definitions of actions and requests, which themselves have statement sequences as their bodies. -

-Statements will typically have side-effects, affecting the state of objects or the external world. This implies that the order of statements within -a sequence is important. Also, for the statement forms that bind variables, the binding affects only the rest of the sequence. -

-The available statement forms are: -

- State variable initialization
- svar := expr -
- Here svar is a state variable. These have the same syntax as ordinary variables and share namespace, but - there are no rules for shadowing, so a state variable must be distinct from all ordinary variables in scope (and from other, - already defined state variables in scope). The variable - being defined may not occur in the right hand side. Initialization implicitly declares this variable as part of the state of objects - instantiated from this class. -
- List of bindings. -
These have the same syntax as bind lists in general; they are recursive and within one binding group - order is insignificant (with the - exceptions detailed at the end of the bindings page), but the bindings are only in scope - in the rest of the statement sequence. -
In addition to local bindings as they are used in general, a particularly important case is definitions of actions - and requests (which can only be defined in the statement sequence of a class). -
- Creation of objects
- var = new expr -
- The expr must evaluate to a class; the effect is that a new object is created, its state initialized and its - interface bound to var -
The result statement. -
result expr
- In the sequence of statements of a class, this must be the last statement. It defines the interface of the class, i.e. how - the variable referring to an object may interact with it. -
Within an action or a request, the result statement indicates termination of the method and the value returned (for - requests; for actions the result is (), the dummy value of type ()). -

- The forms of statements up to now are the only forms that may occur in the statement sequence at the outermost level of a class; - creating an object - may only involve initiating the state, creating other objects and returning the proper interface. The remaining forms - occur only within methods and procedures. -

-State update.
-svar (! expr )*:= expr
-The left hand side is here either a state variable or an array L-value (when the svar is an array). Array indexing -is denoted by the ! operator; several indexing operations may occur for multidimensional arrays. The right hand side may -mention this and other state variables.
-Request/procedure call. -
-pat <- expr
-Here the right hand side must evaluate to a request or procedure; the statement expresses a call of this method and matching -the pattern against the returned value. -
-The alternative form
-expr -
-may also denote a request or procedure call where the binding is omitted or an action call (which does not return a value). -
-
After and before statements. -
-after expr expr
-before expr expr
-Here the first expr must be a time interval and the second an action; the latter is given a new baseline (the after case) -or deadline (the before case). -
-Conditional statement. -
-if expr then
-  stmts
-elsif expr then
-  stmts
-else
-  stmts -
-The elsif may occur zero or more times; the else part zero or one time. -
-Case statement.
-case expr of
-  pat1 -> stmts1
-  pat2 -> stmts2
-  ... -
-The alternatives may use guards and/or where clauses just as in function bindings. -
Forall statement. -
-forall (qual ) + do
- stmts -
-Here the simplest form of qual is var <- expr, where expr evaluates -to a list. The statement sequence in the body will be executed once for each element of the list, with var bound to -that element. -

-We finish with a simple example. -

-struct Counter where
-  inc   :: Action
-  read  :: Request Int
-  reset :: Action
-
-counter = class
-  s := 0
-  inc = action
-    s := s+1
-  read = request
-    result s
-  reset = action
-    s := 0
-  result Counter {..}
-

- rmfile ./doc/summary/stmts.html hunk ./doc/summary/tclass.html 1 - - - -Type classes and qualified types - - - - -

Type classes and qualified types

-In mathematics and in most programming languages, + and - denote addition and subtraction; but what should -their types be? Of course, we want to be able to add both integers and floating-point numbers, but these two functions correspond to -completely different machine operations; we may also want to define arithmetic on new types, such as complex or rational numbers. -

-To better understand the problem, consider a function to add the elements of a list of integers to an accumulator. -Assuming that + only means integer addition we could define -

-add :: Int -> [Int] -> Int
-add acc (x : xs) = add (x + acc) xs
-add acc [] = acc
-

-As long as there are elements in the list, we add them to the accumulator and call the function recursively; when the list is empty the -accumulator holds the result. -

But this function makes perfect sense also for floats (or rationals, or complex numbers, or ...) and we would like to use it at -those types, too. One could imagine an ad hoc solution just for the arithmetic operators, but we prefer a general solution. -

-A first step is to introduce the following struct type: -

-struct Num a where
-  (+), (-), (*) :: a -> a -> a
-

-An object of type Num Int has three fields, defining addition, -subtraction and multiplication, respectively, on integers. (Of course, we can construct an object of this type using any three functions -of the prescribed type, but the intention is to supply the standard arithmetic operators.) Similarly, an object of type Num Float -defines the corresponding operators for floating-point numbers. -

-Assume that we have -properly defined numInt :: Num Int. We can then define -

-add :: Int -> [Int] -> Int
-add acc (x : xs) = add (numInt.(+) x acc) xs
-add acc [] = acc
-

-Unfortunately, the first argument in the recursive call now looks horrible. We cannot accept to write integer addition in this way. But there is -at least something positive; we can generalize the type by giving the Num object as an argument: -

-add :: Num a -> a -> [a] -> a
-add d acc (x : xs) = add d (d.(+) x acc) xs
-add d acc [] = acc
-

-We can now use add for lists of any type of objects for which we can define the arithmetic operators, at the expense of passing an extra -argument to the function. -

-The final step that gives an acceptable solution is to let the compiler handle the Num objects. We do this by declaring -Num to be a type class, loosely following the terminology introduced in Haskell: -

-typeclass Num
-

-For such types, the selectors are used without the -dot notation identifying a struct value from which to select. Whenever a selector of a type class occurs in a function -body, the compiler -does the following: -

adds an extra parameter of the type class to the function;
changes the selector occurrences in the function body to a selection from that parameter.
wherever the function is used, adds an object of the proper type as an extra argument. -
changes the type of the function to be a qualified type; the type class occurs as a constraint after \\. -

-Our running example now becomes -

-add :: a -> [a] -> a \\ Num a
-add acc (x : xs) = add (x + acc) xs
-add acc [] = acc
-

-As a convenience, the declaration of the struct type and the type class declaration can be combined into one single declaration: -

-typeclass Num a where
-  (+), (-), (*) :: a -> a -> a
-

-To use function add to sum a list of integers, we could write e.g. add 0 [1, 7, 4]. The compiler must now insert -the extra argument numInt, a struct value with selectors for the three arithmetic operators at type Int. -However, since there might be several objects of type Num Int defined, we must indicate in instance declarations -the objects that are to be used at different types. The definition of the struct value and its instance declaration can be combined -into one declaration. As an example, here is an instance of Num for rational numbers: -

-data Rational = Rat Int Int
-
-instance numRat :: Num Rational where
-  Rat a b + Rat c d = Rat (a*d + b*c) (b*d)
-  Rat a b + Rat c d = Rat (a*d - b*c) (b*d)
-  Rat a b * Rat c d = Rat (a*c) (b*d)
-

-This definition should be improved by reducing the fractions using Euclid's algorithm, but we omit that. We just note that the arithmetic operators in -the right hand sides are at type Int; thus the compiler will insert the proper operations from the instance numInt, avoiding -the overhead of extra parameters. -

-This solution combines ease of use and flexibility with type security. A possible disadvantage is inefficiency; an extra parameter is passed -around. To address this, the user may add a specific type signature; if the user assigns the type Int -> [Int] -> Int to add, -giving up flexibility, the compiler will not add the extra parameter, instead inserting integer operations directly into the function body. -

-Several type classes, including Num, are defined in the Prelude, together with instances for common cases. -

-The compiler must be able to select the proper object of a type class to use whenever a function with a qualified type is used; this choice -is guided by the context of the function application. In certain cases ambiguites can occur; these are resolved using default declarations. -

-Normally, the combined declaration forms are used both for type classes and instances. Separate typeclass declaration of a struct type can only -be done in the module where the struct type is defined. -

Subtyping constraints

-Also subtyping relations may be used as constraints in qualified types. As a simple example, consider the function -

-twice f x = f (f x)
-

-Obviously, twice has a polymorphic type. At first, it seems that the type should be (a -> a) -> a -> a. However, it can be assigned -the more general type -

-twice :: (a -> b) -> a -> b \\ b < a
-

-Types with subtype constraints will never be assigned by the compiler through type inference, but can be accepted in type-checking. - rmfile ./doc/summary/tclass.html hunk ./doc/summary/timberc.html 1 - - -Timber compiler - - - - -

Timber compiler

-This page describes briefly the command line options to timberc, the Timber compiler. -Installation is not described. -

-timberc expects a number of options and a number of files to compile. The most -common uses are the following: -

timberc -c Mod1.t Mod2.t ... -
The given files are compiled (first to C by the timber - compiler, then to object files by the C compiler). No linking takes place. This usage requires that all - files on which the given modules depend have already been compiled. This is the typical way to compile - new modules during the development of a Timber system. Can be modified to option -C to avoid - C compilation. -
timberc --make Mod -
The compiler expects Mod.t to be the root module of a system for the default environment (i.e. POSIX). - All modules in the system are compiled by timberc and gcc as needed and in dependency - order, followed by linking. The executable is called Mod. This option obviates the need of a makefile - to rebuild the system after changes in any modules. Can be combined with --root=name when the name of - the root definition is name (rather than the default root). -
timberc Mod.ti -
Displays the API of module Mod, i.e. all exported kinds, types, defaults and top-level values with their types, - typically in a browser window (installation-dependent). -

- rmfile ./doc/summary/timberc.html hunk ./doc/summary/time.html 1 - - - -Time constructs - - - -

Time constructs

Absolute time

-Timber allows explicit expression of time constraints on reactions in -a program. As a basis for this, we assume a notion of absolute or real time, -which progresses independently of program executions. With each action -call in a -program is associated two absolute time instants, the -baseline and the deadline. The intuition is that -execution of the action must not start before the baseline and must -be finished by the deadline. The time interval between these two -instants is the time window of the action. -

-Timber programs cannot express or access absolute time, but the runtime system -has access to a realtime clock and can obtain the current -time.The resolution of this clock is platform-dependent. - -

The type `Time`

-There is, instead, a primitive type Time of -durations, or lengths of time intervals, that may occur in -programs. -Time values can also be computed by the runtime system as the -duration of the time interval between two instants. -

-The type is abstract; Time values can be constructed using the -primitive functions -

-sec, millisec, microsec :: Int -> Time
-

-which expect a non-negative argument. Of course, e.g., -sec 1 and millisec 1000 denote -the same time value. -

-There is a predefined instance numTime :: Num Time, -so time durations can be added and subtracted using -arithmetic notation, as in sec 2 + millisec 500. -Subtraction of a larger value from a smaller yields -time 0 and multiplication is undefined (an attempt to multiply -two time values raises an exception). -

-To deconstruct time values, one uses the primitive functions -

-secOf, microsecOf :: Time -> Int
-

-secOf rounds downwards to whole seconds -and microsecOf returns the fraction, -a value between 0 and 999999. - -

Time constraints

-Time windows of reactions are assigned as follows: -

The time window of a reaction to an external event has - as baseline the time instant when the event occurs, and - as deadline an idealised instant infinitely far into the future. - -
In particular, the start action of a program gets as - baseline the time instance when program execution begins. -
-
When a message without time constraints is sent (i.e., an - plain action is called) from a method with current baseline bl and deadline dl, - the reaction to the message inherits both bl and dl.
- The rule in the previous item can be changed by explicit - program constructs: -
- The expression after t act - sets the effective baseline for act to the current baseline plus t. -
- The expression before t act sets - the effective deadline for act to its effective baseline plus t.

act

Action

after

before

Special case: if the baseline denoted by an after construct is an already passed time instant, - the effective baseline of the reaction is rounded off to the actual time of the call. -

- -

The class `timer`

- As mentioned above, programs cannot access absolute time, - but they can measure durations of time intervals. For this, - they make use of the primitive class timer, - where -

-timer :: Class Timer
-
-struct Timer where
-   reset  :: Request ()
-   sample :: Request Time
-

- When a new object of class timer is created, it - stores the baseline of the current reaction. When, later, - sample is called, the duration from the stored time to the - current baseline is returned. Calls to reset updates - the stored time to the current baseline. - -

Scheduling

- Baselines and deadlines provide the basis for scheduling - of Timber programs. The scheduler is preemptive and uses the - EDF strategy (Earliest Deadline First): -

- At each interrupt (from external sources or internal - runtime system timers) or method termination, the reaction to - execute next is chosen as follows: - Messages with future baselines cannot yet execute and are - stored in a list sorted by baseline with a running timer - that expires at the earliest baseline. Eligible messages are - sorted by deadline and the message with the earliest deadline is chosen - for execution. - rmfile ./doc/summary/time.html hunk ./doc/summary/toplevel.html 1 - - -Top-level declarations - - - - -

Top-level declarations

-The body of both the public and private parts of a module is a sequence of -top-level declarations. These declarations comprise -

Kind declarations (declaring the kind of a type (constructor)). -
Type definitions (data and struct types, implicit struct types and type synonyms). -
Type signatures. -
Function bindings. -
Definitions of instances of implicit struct types. -
Default declarations. -

Types and type declarations

Types and type constructors

-Values in Timber are classified into types. The integer value 7 has type Int, a fact that is expressed -in Timber as 7 :: Int, so :: is read "has type". One seldom adds such explicit type information to expressions -in Timber code, but it is allowed to do so. More common is to supply type signatures as documentation to -top-level definitions, but also these can be omitted, leaving to the Timber compiler to infer types. -

-Timber also has type constructors, which can be thought of as functions that take types as arguments and give a type as -result. An example is the primitive type constructor Request, which takes a type a as an argument and constructs -the type Request a of methods (in the object-oriented sense) returning a value of type a. - -

Kinds and kind declarations

-Timber types and type constructors are classified by their kind. All types have kind *, while -type constructors that expect one type argument (such as e.g. Request) have -kind * -> *. In general, a kind is either * or k1 -> k2 where k1 and k2 are -kinds. A type constructor of kind k1 -> k2 expects an argument of kind k1; the result is then a type (constructor) -of kind k2. -

-The programmer may declare the kind of a type constructor in a top-level kind declaration:

-con :: kind -

-This is particularly useful when defining abstract data types; in the public part of a module one declares the kind of -an abstract type and the signatures of the operators; the actual type definition and equations are given in the private part. - - - - - - -
Examples - Comments
Stack :: * -> * Stacks with elements of arbitrary type
Dictionary :: * -> * -> * Dictionaries storing info about keys
- - -

Examples -	Comments
`Stack :: * -> *`	Stacks with elements of arbitrary type
`Dictionary :: * -> * -> *`	Dictionaries storing info about keys

Primitive types

-We first describe the primitive types of Timber. In Timber code it is always clear from the context whether -an expression denotes a type or a value, so some types use the same syntax for type expressions as for -values, without confusion. (A beginner might disagree about the last two words.) - -

Primitive simple types

-As part of the language, the following primitive types are provided: -

The type Int of finite-precision integers.
The type Float of single-precision floating-point numbers.
The type Char of characters.
The type Time of time intervals.
The type Bool, with the two values True and False.
The type () (pronounced "unit"), containing the single value (). -
The type OID of object identities, which support test for identity between objects. -

-Literals of types Int and Float are as in most programming languages; integer constants can be -given in octal or hexadecimal formed if prefixed by 0o and 0x, respectively. -

-Time values are expressed using the primitive functions sec, millisec, microsec and nanosec, -which all take an integer argument and return a Time value. Of course, millisec 1000 and sec 1 denote -the same value. -

-Character literals are written within -single quoutes as in 'a' or '3'; common escaped characters are '\n' and '\t' for newline and tab, respectively. (Many other forms of -character literals omitted.) -

Primitive type constructors

-The following type constructors are also primitive in the language. -

Lists.
The type [a], for any type a, contains finite lists of values of type a. - The list [3, 6, 7, 1] has type [Int] and [[3, 2], [4, -1, 7]] has type [[Int]] - (however, see the overloading page for more general types of these lists). -
Tuples.
-For arbitrary types a1,a2,...an, we can form the tuple type (a1, a2, ..., an). -Values use the same notation so (True,'a') has type (Bool,Char). -
Arrays.
-For any type a, the type Array a consists of a sequence of a values, organized so that one can access all values -by index in constant time. Arrays are particularly useful as state variables in objects, where they may also be -updated in imperative style.
Functions.
For any two types a and b, a -> b is the type of functions from a to b. --> associates to the right, so a -> b -> c parses as a -> (b -> c). -
Either.
-This type could be defined in Timber as -
```
-data Either a b = Left a | Right b
-
```
-
-It is only primitive because of its role in generating default instances.
Classes.
-For any type a, the type Class a contains templates from which one can instantiate objects -with interface of type a. Of particular -interest is the case where a is a struct type with a number of methods manipulating an internal state of the object.
Actions.
-Action is the type of asynhronous methods. An object may offer an Action in its interface; a client who has access to this interface -may send the object an action message with appropriate arguments. The message will, at an unspecified later point in time, execute the action, with -exclusive access to the object's state.
Requests.
-For any type a, Request a is the type of synchronous methods that return a value of type a. An object -may offer a Request in its interface; a client who has access to this interface may then send a request message with appropriate -arguments and wait for the result. Since all methods require exclusive access to the state of the receiving object during execution, cycles of requests lead to deadlock. Deadlock is detected by the runtime system and an exception is raised.
Commands.
For any two types s and a, Cmd s a is the type of procedures that can execute in a -state s and return a value of type a. -
Object references.
-For any type a, Ref a is the type of references to -objects with interface of type a. -
The struct type Timer, which is used as interface to the -primitive timers of the language; see the Time -constructs page for details. -

Polymorphic types

-We can now form complex types such as - - - - - - -
Examples -
Int -> Int -> Bool
[Int] -> Int
(a -> Bool) -> [a] -> [a]
-

Examples -
`Int -> Int -> Bool`
`[Int] -> Int`
`(a -> Bool) -> [a] -> [a]`

-The two first examples are monomorphic; they involve only known types and type constructors. The third is polymorphic; -it involves the type variable a (a type variable since it starts with a lower-case letter), that stands for an -arbitrary type. A function possessing this type can be used at any type obtained by substituting a type for a. -

-The type variable a is implicitly bound in such a type expression; one should think of an implicit "for all a" -quantification prepended to the type expression. -

Data types

-The programmer may introduce new ways of constructing data by defining data types. The simplest case is enumeration types like -

-data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
-

Day

-The constructors may have arguments, as in -

-data Temp = Fahrenheit Int | Celsius Int
-

-Values in type Temp are e.g., Fahrenheit 451 and Celsius 100. There may be one, two or more alternatives -and a constructor may have more than one argument. A data type for a web log entry might be -

-data Entry = Entry IPAddress Date URL Method Int
-

-where a value of type Entry might be -

-Entry "123.456.789.000" (May 29 2007) "http://www.abc.def"  GET 321
-

-given suitable type definitions for the other types involved. Note that the type and the constructor have the same name; this is -OK since types and constructors live in different namespaces. -

-We may also define parameterised data types: -

-data Tree a b = Nil | Branch (Tree a b) a b (Tree a b)
-

-Tree thus has kind * -> * -> * and a value of type Tree String Int is a binary tree with a String and an Int stored in each internal node. -

-Two different data types may not use the same constructor name; with the above definition, no other data type in the same module can -use constructor Nil. For data types in imported modules there is no problem if they use Nil; only that the -qualified name must be used for the imported constructor. - -

Struct types

-Struct, or record, types collect values bound to named selectors. Declarations have the syntax -

-struct con var * where
- sig+ -

- - - - - - - - -
Examples -
struct Point where
  x, y :: Int
struct Dictionary a b where
  insert :: a -> b -> Action
  lookup :: a -> Request (Maybe b)
-

Examples -
`struct Point where`
`x, y :: Int`
`struct Dictionary a b where`
`insert :: a -> b -> Action`
`lookup :: a -> Request (Maybe b)`

-An example value of type Point is Point {x=3, y=7}. The order between the fields is not significant, so -Point {y=7, x=3} is the same value. Similarly as for constructors, two different struct types in the -same module may not use the same selector name. -Thus a struct value is uniquely defined by the collection of selectors and the type name can be omitted from the value; {x=3, y=7} is again the same value. -

-If p :: Point, the selectors are accessed using dot notation, so the two integer coordinates are -p.x and p.y, respectively. -

-A struct type may have any number of selectors and the types of selectors are arbitrary. A struct type may also be parameterised -as shown by Dictionary, a type suitable as an interface to an object that acts as a dictionary, storing information of type b about keys -of type a. (The result type Maybe b for lookup is intended to capture the possibility that the given -key is not stored in the dictionary; the prelude defines data Maybe a = Nothing | Just a.) - -

Type synonyms

-The user may introduce new names for existing types: -

-type Age = Int
-type IPAddress = String
-type List a = [a]
-type Pair a b = (a,b)
-

-Such definitions do not introduce new types; they can only be helpful to improve program readability. They may not be recursive and -can not be partially applied (i.e., Pair Int is not a legal type constructor). The prelude introduces one type synonym: -

-type String = [Char]
-

Subtyping

Subtyping for struct types

-Struct types and data types may be defined in subtype hierarchies. As an example, we can extend Point: -

-struct Point3 < Point where
-  z :: Int
-

-We define Point3 to be a subtype of Point; for struct types this means that Point3 has all the selectors -of Point and possibly some more (in the example, one more: z). So we have {x=0, y=3, z=5} :: Point3. -A function that expects a Point as argument can be given a Point3 without problem, since all the function can do -with its argument is use the selectors x and y, which are present also in a Point3. -

-As another example we might split the dictionary type into two: -

-struct LookupDict a b where
-  lookup :: a -> Request (Maybe b)
-
-struct Dictionary a b < LookupDict a b where
-  insert :: a -> b -> Action
-

-In a program we may build a dictionary dict :: Dictionary a b and then send it to an unprivileged client typed as a -LookupDict; the client can then only lookup information, not insert new key/info pairs. -

-A struct type may have several supertypes; given a struct type -

-struct Object where
-  self :: OID
-

OID

-struct Dictionary a b < LookupDict a b, Object where
-  insert :: a -> b -> Action
-

-to get the same effect as before and, in addition, the possibility to test whether two dictionaries are the same (meaning same object, -not equivalent content). -

Subtyping for data types

-We can also define hierarchies of data types, but these are completely separate from any hierarchy of struct types; a data type -can never be a sub- or supertype of a struct type. For data types we may add new constructors to get a supertype: -

-data CEntry > Entry = Corrupt
-

-Type CEntry adds another constructor to the type Entry defined above; a CEntry is either a proper -entry as above or Corrupt. A function that is defined to take a Entry as argument cannot accept a CEntry; -it may stumble on a Corrupt entry. The converse is OK; newly defined functions on CEntry values can happily -take an Entry; they will not have to use their Corrupt case. - -

Subtyping among primitive types

-The following subtyping relations hold between primitive types:
-Class a < Cmd s a
-Request a < Cmd s a
-Action < Cmd s Msg
-Ref a < OID. - rmfile ./doc/summary/types.html rmdir ./doc/summary rmdir ./doc hunk ./examples/Counter_descr.html 1 - - - -Counter - - - -

Counter

-The Counter example is a minimal example of a class from which one -can instantiate objects with state. Several variations are possible; -here is the one we choose: -

-module Counter where
-
-struct Counter where
-  incr  :: Action
-  decr  :: Action
-  value :: Request Int
-
-counter = class
-
-   n := 0
-
-   incr  = action n := n+1
-
-   decr  = action n := n-1
-   
-   value = request result n
-
-   result Counter{..}

-Comments: -

The first four lines of the module body - define a struct, or record, type, - called Counter. This type has three methods, - and will act as an interface to counter objects. -
The rest of the module defines a class counter. - Instances of this class have an internal state consisting of a - single integer state variable n, initialised to 0 when - the instance is created. The effects on the state when methods - are invoked on this object is described. Finally, the - result statement declares that object creation - returns a Counter interface to the object. - Thus counter has type Class Counter. -
To create an object of this class, one writes (within a method - or another class definition) -
```
-ctr = new counter
-
```
-The variable ctr has type Counter, and the newly - created object can be updated by method calls ctr.incr and - ctr.decr. The state can be read by -
```
-val <- ctr.value
-
```
-
Any method call has exclusive access to the state of the - object; there is no need for the programmer to protect calls - further. -
The two action methods are invoked asynchronously, - while the value-returning request of course requires - synchronous communication. -
The notation Counter{..} means "assemble an - object of type Counter from definitions in scope". - It would be possible, and maybe preferrable in this small example, - to define the methods within the result expression as follows: -
```
-counter = class
-
-   n := 0
-
-   result
-     struct
-       incr  = action n := n+1
-       decr  = action n := n-1
-       value = request result n
-
```
-In more complex situations, the {..} is a useful convenience. -
To see an example of use of counter, see EchoServer2. -

Variation

counter

-counterInit init = class
-  
-   n := init
-
-   ...
-

-ctr = new counterInit 5
-

-Thus, we have the typing counterInit :: Int -> Class Counter. -

-We might still keep the definition of counter, but this would -mean code duplication that should be avoided. Instead, we could write -

-counter = counterInit 0
-

counter

Echo2

-Let us make the Echo program just a little bit more -interesting: We add an initial welcome phrase and a -prompt with a line number. Here is the program: -

-module Echo2 where
-
-import POSIX
-
-root env = class
-
-   count := 1
-
-   prompt = do
-      env.stdout.write (show count++"> ")
-      count := count+1
-
-   echo str = action
-      env.stdout.write str
-      prompt
-
-   result 
-      action 
-         env.stdin.installR echo
-         env.stdout.write "Welcome to Echo2!\n"
-         prompt
-

-The root definition now has two more components: -

The (implicit) declaration and initialisation of the state - variable count, which will maintain line numbers. -
The auxiliary procedure prompt, which writes - a prompt to the user and increases the line count. -

-In addition, the callback and the initial action both call -prompt, and a greeting phrase is added. -

-Some additional details: -

The keyword do signifies the start of a, - typically local, procedure, that may be called from other methods - as above.
show is a function that converts - the integer value count to a string; ++ - denotes string concatenation. Both these are defined in - the Prelude, a library module which is implicitly imported by - all modules.
The user input string given to echo will include - the newline; hence so will the string echoed to stdout. - But to write the welcome phrase on a separate line, it will have - to end with an explicit newline.
The root object maintains state variable - count, which is initialised to 1 and increased for each - prompt written. Obviously, it would be possible to use - a counter object here, but in this simple program that - seems an overkill. -
A more careful description of what the runtime system does - when the program is run is the following: it creates an object of type - Env, - applies function root to that object, creates an object - of the resulting class and invokes the resulting action. -

Echo3

-Now, let's try a variation; program Echo3 writes -Hello!\n to stdout once a second. The user can change this -message by typing a line on stdin; after the line is finished -with a return, the line typed will be the new message. Here is the program: -

-module Echo3 where
-
-import POSIX
-
-root env = class
-
-   current := "Hello!\n"
-
-   save str = action
-      current := str
-
-   tick = action
-      env.stdout.write current
-      after (sec 1) tick
-
-   result 
-      action 
-         env.stdin.installR save
-         tick
-

The message to be printed once a second is maintained in state - variable current. -
The callback installed with stdin changes - current. -
The initial action not only installs save, it also - invokes the auxiliary action tick, which prints - current and schedules itself for later execution. - -
The scheduled execution time (the baseline) for each instance of tick is - one second after the baseline of the previous instance. Thus there - is no ackumulating drift in the program, even if a particular tick may be delayed in - execution. -

-When running Echo3 one notices a peculiarity of the standard -implementation of the POSIX environment: the screen doubles - as both the output -device stdout and as user feedback part of the input device -stdin. Thus, output is intertwined with input characters in a -rather unsatisfactory way. - rmfile ./examples/Echo3_descr.html hunk ./examples/EchoServer2_descr.html 1 - - - -EchoServer2 - - - -

EchoServer2

-This is a minor extension of EchoServer: when started, it -expects an integer command line argument maxClients, denoting -the maximal number of concurrently served clients. If more clients -connect, they are just informed that the server is busy and -disconnected. -

-module EchoServer2 where
-
-import POSIX
-import Counter
-
-port = Port 12345
-
-root env = class
- 
-    clients = new counter
-
-    log str = action
-       env.stdout.write ('[':str ++ "]\n")
-
-    result action
-       maxClients = parse (env.argv ! 1)
-       env.inet.tcp.listen port (server maxClients clients log)
-
-server maxClients clients log sock = class
-
-   n := 1
-
-   p = show sock.remoteHost
-
-   echo str = action
-      sock.outFile.write (show n ++"> "++str)
-      n := n+1
-
-   close = request
-      clients.decr
-      log (p ++ " closing")
-      result ()
-
-   neterror str = log ("Neterror: "++str)
-
-   established = action
-      cl <- clients.value
-      if cl < maxClients then
-         clients.incr
-         log ("Connected from " ++ p)
-         sock.inFile.installR echo
-      else
-         sock.outFile.write "Server busy"
-         log ("Refused " ++ p)
-         sock.close
-
-   result Connection{..}
-

EchoServer

- We need to keep track of the number of served clients. - For this we use a Counter - object, created by the root object. -

When a new client connects, the counter value is retrieved and - only if this value is small enough is an echo action installed; - otherwise the client is informed that the server is busy and the - socket closed. When a client closes the connection, the counter is decreased. -

- A Counter object is appropriate here, since several server objects, - each interacting with one client, interacts with it. On the - contrary, the line number local to each server object is maintained - in a simple integer state variable. - - rmfile ./examples/EchoServer2_descr.html hunk ./examples/EchoServer_descr.html 1 - - - -EchoServer - - - -

EchoServer

-Now, let's look at a further feature of the POSIX -environment. It also supports writing network programs, -that communicate over the Internet using sockets. -A socket can be thought of as a two-way communication channel, -consisting of both an RFile and a WFile. -

-Two network programs, which -execute on different machines, may connect over -the network and communicate using a socket. -Typically, one of the programs will be a server -and the other a client. Here is a trivial server, the -EchoServer. - This server waits indefinitely for clients to connect on port - 12345. When a client connects, the server starts a session, where - client input rows are echoed back to the client, prefixed by a line - number. Several clients may be served concurrently and - line numbering is independent for each client. - -

-module EchoServer where
-
-import POSIX
-
-port = Port 12345
-
-root env = class
-
-    log str = action
-       env.stdout.write ('[':str ++ "]\n")
-
-    result action
-       env.inet.tcp.listen port (server log)
-
-
-server log sock = class
-
-   n := 1
-
-   p = show sock.remoteHost
-
-   echo str = action
-      sock.outFile.write (show n ++"> "++str)
-      n := n+1
-
-   close = log (p ++ " closing")
-
-   neterror str = log ("Neterror: "++str)
-
-   established = action
-      log ("Connected from " ++ p)
-      sock.inFile.installR echo
-
-   result Connection{..}
-

-Comments to the code: -

The result action of the root definition just installs a - listening callback in the environment. Such a callback has type - Socket -> Class Connection where -
- a Socket object has selectors for the resources - from the environment - needed by the serving object: the remoteHost and - remotePort and the inFile and outFile - parts of the connection. -
- a Connection implements the services provided - by the server - to the environment: an initial action to call when the - connection is established, an action to call with - an error message when a - neterror occurs and a method to call when the - remote client wants to close the connection. -
-
The echoing behaviour is achieved by installing, - when connection is established, the - echo method with the inFile of the socket. -
Additionally, the server logs its connections and - errors, using the logging method - that it get as parameter (which logs to stdout). -

-In order to let you run the server, we provide a simple client, -TCPClient. We do not list the code here; you may review -it in TCPClient.t. The client accepts a host name and a port -number as command line arguments and connects to a server on that -address. When connection is established, the client accepts user input -lines, sends them to the server and displays replies obtained on the -screen. - rmfile ./examples/EchoServer_descr.html hunk ./examples/Echo_descr.html 1 - - - -Echo - - - -

Echo

-Our first example runs in a very simple setting: a computing environment -where the interaction between the external world and the program is through a keyboard and a text screen. -The user provides input using the keyboard and the program prints -output on the screen. -

-We consider a reactive program, where the user -input is just echoed on the screen, line by line, -by the program. This trivial interaction, the "Hello, world" of -reactive programs, goes on indefinitely. -

-Here is the program: -

-module Echo where
-
-import POSIX
-
-root env = class
-
-   echo str = action
-      env.stdout.write str
-
-   result 
-      action 
-         env.stdin.installR echo
-

-Let us explain the program: -

The first line just states the name of the module.
Line 3 contains an import declaration; we will use resources from -POSIX, a predefined library module that provides the types - needed to build programs for simple environment we described above. -
-Module POSIX defines a struct type Env, with selectors -corresponding to the resources available to the program in its interaction -with the environment. -Among these are stdin, which refers to the keyboard, -and stdout, which refers to the screen.
-Module POSIX also acts as the default -target environment for Timber programs. -This target environment prescribes that a program -must contain a root definition -
```
-root :: Env -> Class Action
-
```
-
- -In module Echo, this definition starts on line 5 and -makes up the rest of the program. -
-root must describe the initial behaviour of the program in its -result action, which terminates the class definition. -
-In addition, it may make auxiliary definitions; here of -the function echo, which describes how the program -reacts to an input string str. -The resulting action just installs this function as -a callback with env.stdin. -

When executed, the runtime system invokes the -result action of the root definition (see -Echo2 for a more careful description.) -After that, the program is idle, waiting for user input. -When such (line-buffered) input occurs, the runtime system -invokes the callback with the input line as argument. -

-This trivial program is typical for the Timber programming idiom; -we describe how the program should react to external events and -install, or register, this description with the external device. -

-We note, finally, that the use of stdout and -stdin is consistent with their types as -specified in Env: -

stdout -is a WFile and thus has a write method; -
stdin is a RFile, and thus has an -installR method. -

MasterMind

-examples> ./MasterMind
-Welcome to Mastermind!
-Choose your secret. Press return when ready.
-
-My guess: Red Blue Blue Red
-Answer (two integers): 1 1
-My guess: Blue Black Yellow Red
-Answer (two integers): 2 0
-My guess: Green Black Red Red
-Answer (two integers): 0 0
-My guess: Blue Blue Yellow White
-Answer (two integers): 3 0
-My guess: Blue Blue Yellow Blue
-Answer (two integers): 3 0
-My guess: Blue Blue Yellow Yellow
-Answer (two integers): 4 0
-Yippee!
-Do you want to play again? (y/n) n
-examples> 
-

The program makes use of two auxiliary modules - Data.Functional.List and RandomGenerator. The - former is a library module, while the latter is provided in the - examples directory. -
The program complains if the user gives contradictory answers, - asks for the secret and explains the user's mistake. -
There is no error handling: if an answer cannot be parsed as - two integers, the program crashes. -

MasterMind

-examples> ./MasterMind
-Welcome to Mastermind!
-Choose your secret. Press return when ready.
-
-My guess: Red Blue Blue Red
-Answer (two integers): 1 1
-My guess: Blue Black Yellow Red
-Answer (two integers): 2 0
-My guess: Green Black Red Red
-Answer (two integers): 0 0
-My guess: Blue Blue Yellow White
-Answer (two integers): 3 0
-My guess: Blue Blue Yellow Blue
-Answer (two integers): 3 0
-My guess: Blue Blue Yellow Yellow
-Answer (two integers): 4 0
-Yippee!
-Do you want to play again? (y/n) n
-examples> 
-

The program makes use of two auxiliary modules - Data.Functional.List and RandomGenerator. The - former is a library module, while the latter is provided in the - examples directory. -
The program complains if the user gives contradictory answers, - asks for the secret and explains the user's mistake. -
There is no error handling: if an answer cannot be parsed as - two integers, the program crashes. -

MasterMind

k

+The iterative check of all integers in range for primeness is expressed using +recursion in checkFrom. Alternatively, we could omit procedure +checkFrom, +in favour of an iterative construction in the resulting action: +
```
+   result action
+     primes!0 := 2
+     count := 1
+     forall k <- [3..limit] do
+       p <- isPrime k
+       if p then 
+         count := count + 1
+         primes!count := k
+     env.stdout.write (show (count+1)++"\n")
+     env.exit 0
+
```
+The choice has negligible effect on efficiency (the tail recursive +checkFrom is transformed to iteration by the compiler), +but is merely a matter of taste. +

We end by noting two mathematical facts that the program relies +on: +

To limit the size of the array of primes, +the program uses the moderately clever bound that the number +of primes up to n is less than n `div` log3 n. +
Correctness of the algorithm isPrime depends on the fact that +if k is actually a prime, then there is a smaller prime +p with p*p > k. In fact, by Bertrand's postulate, +much more is true: there is a prime p > k `div` 2. +

merger 0.0 ( hunk ./examples/Primes_descr.html 72 -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -

+procedure checkFrom. +

merger 0.0 ( hunk ./examples/Primes_descr.html 68 -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
+all elements are initialised to the value of the second argument). +

merger 0.0 ( hunk ./examples/Primes_descr.html 63 +

hunk ./examples/Primes_descr.html 1 - - - -Primes - - - -
Primes
-
-As a reactive program, this is quite degenerate: when started, it -expects -a positive integer n>2 as command line argument. It -computes all primes smaller than or equal to n, prints -the number of such primes to stdout and terminates. -
-The algorithm used illustrates imperative programming using updatable -arrays in Timber. Here is the program: -
-
```
-module Primes where
-
-import POSIX 
-
-root env = class
-   limit :: Int
-   limit = parse (env.argv!1)
-   primesBound = limit `div` log3 limit
-
-   primes := uniarray primesBound 0
-   count  := 0
-
-   isPrime k = loop 0
-      where loop n = do 
-              p = primes!n
-              if p*p > k then
-                 result True
-              elsif k `mod` p  == 0 then
-                 result False
-              else loop (n+1)
-
-   checkFrom k = do
-     p <- isPrime k
-     if p then 
-        primes!count := k
-        count := count + 1
-     if k < limit then checkFrom (k+1)
-
-   result action
-     primes!0 := 2
-     count := 1
-     checkFrom 3
-     env.stdout.write (show count++"\n")
-     env.exit 0
-
-
-log3 :: Int -> Int
-log3 n  
-  | n < 3       = 0
-  | otherwise   = 1 + log3 (n `div` 3)
-
-
```
-
-Prime numbers are stored in array primes, which is -initialised with all zeros (primitive function uniarray -creates an array, whose size is given by the first argument, where -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
-The root action notes that 2 is a prime and initiates count -to 1; it then checks numbers for primeness, starting with 3 in -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
-The procedure isPrime works by trial division, using already -discovered primes: to check whether k is a prime, one tries -to find a proper prime factor p such that p*p <= k. If -none is found, k is prime. - - - ) ) ) ) merger 0.0 ( merger 0.0 ( merger 0.0 ( hunk ./examples/Primes_descr.html 72 -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
+procedure checkFrom. +
merger 0.0 ( hunk ./examples/Primes_descr.html 68 -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
+all elements are initialised to the value of the second argument). +
merger 0.0 ( hunk ./examples/Primes_descr.html 63 +
- hunk ./examples/Primes_descr.html 1 - - - -Primes - - - -
  Primes
  -
  -As a reactive program, this is quite degenerate: when started, it -expects -a positive integer n>2 as command line argument. It -computes all primes smaller than or equal to n, prints -the number of such primes to stdout and terminates. -
  -The algorithm used illustrates imperative programming using updatable -arrays in Timber. Here is the program: -
  -
```
-module Primes where
-
-import POSIX 
-
-root env = class
-   limit :: Int
-   limit = parse (env.argv!1)
-   primesBound = limit `div` log3 limit
-
-   primes := uniarray primesBound 0
-   count  := 0
-
-   isPrime k = loop 0
-      where loop n = do 
-              p = primes!n
-              if p*p > k then
-                 result True
-              elsif k `mod` p  == 0 then
-                 result False
-              else loop (n+1)
-
-   checkFrom k = do
-     p <- isPrime k
-     if p then 
-        primes!count := k
-        count := count + 1
-     if k < limit then checkFrom (k+1)
-
-   result action
-     primes!0 := 2
-     count := 1
-     checkFrom 3
-     env.stdout.write (show count++"\n")
-     env.exit 0
-
-
-log3 :: Int -> Int
-log3 n  
-  | n < 3       = 0
-  | otherwise   = 1 + log3 (n `div` 3)
-
-
```
  -
  -Prime numbers are stored in array primes, which is -initialised with all zeros (primitive function uniarray -creates an array, whose size is given by the first argument, where -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
  -The root action notes that 2 is a prime and initiates count -to 1; it then checks numbers for primeness, starting with 3 in -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
  -The procedure isPrime works by trial division, using already -discovered primes: to check whether k is a prime, one tries -to find a proper prime factor p such that p*p <= k. If -none is found, k is prime. - - - ) ) ) hunk ./examples/Primes_descr.html 77 -none is found, k is prime. - +none is found, k is prime. +
- +The iterative check of all integers in range for primeness is expressed using +recursion in checkFrom. Alternatively, we could omit procedure +checkFrom, +in favour of an iterative construction in the resulting action: +
```
+   result action
+     primes!0 := 2
+     count := 1
+     forall k <- [3..limit] do
+       p <- isPrime k
+       if p then 
+         count := count + 1
+         primes!count := k
+     env.stdout.write (show (count+1)++"\n")
+     env.exit 0
+
```
  +The choice has negligible effect on efficiency (the tail recursive +checkFrom is transformed to iteration by the compiler), +but is merely a matter of taste. +
+
We end by noting two mathematical facts that the program relies +on: +
- To limit the size of the array of primes, +the program uses the moderately clever bound that the number +of primes up to n is less than n `div` log3 n. +
- Correctness of the algorithm isPrime depends on the fact that +if k is actually a prime, then there is a smaller prime +p with p*p > k. In fact, by Bertrand's postulate, +much more is true: there is a prime p > k `div` 2. +
) merger 0.0 ( merger 0.0 ( merger 0.0 ( hunk ./examples/Primes_descr.html 68 -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
+all elements are initialised to the value of the second argument). +

merger 0.0 ( hunk ./examples/Primes_descr.html 63 +

hunk ./examples/Primes_descr.html 1 - - - -Primes - - - -
Primes
-
-As a reactive program, this is quite degenerate: when started, it -expects -a positive integer n>2 as command line argument. It -computes all primes smaller than or equal to n, prints -the number of such primes to stdout and terminates. -
-The algorithm used illustrates imperative programming using updatable -arrays in Timber. Here is the program: -
-
```
-module Primes where
-
-import POSIX 
-
-root env = class
-   limit :: Int
-   limit = parse (env.argv!1)
-   primesBound = limit `div` log3 limit
-
-   primes := uniarray primesBound 0
-   count  := 0
-
-   isPrime k = loop 0
-      where loop n = do 
-              p = primes!n
-              if p*p > k then
-                 result True
-              elsif k `mod` p  == 0 then
-                 result False
-              else loop (n+1)
-
-   checkFrom k = do
-     p <- isPrime k
-     if p then 
-        primes!count := k
-        count := count + 1
-     if k < limit then checkFrom (k+1)
-
-   result action
-     primes!0 := 2
-     count := 1
-     checkFrom 3
-     env.stdout.write (show count++"\n")
-     env.exit 0
-
-
-log3 :: Int -> Int
-log3 n  
-  | n < 3       = 0
-  | otherwise   = 1 + log3 (n `div` 3)
-
-
```
-
-Prime numbers are stored in array primes, which is -initialised with all zeros (primitive function uniarray -creates an array, whose size is given by the first argument, where -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
-The root action notes that 2 is a prime and initiates count -to 1; it then checks numbers for primeness, starting with 3 in -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
-The procedure isPrime works by trial division, using already -discovered primes: to check whether k is a prime, one tries -to find a proper prime factor p such that p*p <= k. If -none is found, k is prime. - - - ) ) hunk ./examples/Primes_descr.html 72 -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
+procedure checkFrom. +

) merger 0.0 ( merger 0.0 ( merger 0.0 ( hunk ./examples/Primes_descr.html 63 +

hunk ./examples/Primes_descr.html 1 - - - -Primes - - - -
Primes
-
-As a reactive program, this is quite degenerate: when started, it -expects -a positive integer n>2 as command line argument. It -computes all primes smaller than or equal to n, prints -the number of such primes to stdout and terminates. -
-The algorithm used illustrates imperative programming using updatable -arrays in Timber. Here is the program: -
-
```
-module Primes where
-
-import POSIX 
-
-root env = class
-   limit :: Int
-   limit = parse (env.argv!1)
-   primesBound = limit `div` log3 limit
-
-   primes := uniarray primesBound 0
-   count  := 0
-
-   isPrime k = loop 0
-      where loop n = do 
-              p = primes!n
-              if p*p > k then
-                 result True
-              elsif k `mod` p  == 0 then
-                 result False
-              else loop (n+1)
-
-   checkFrom k = do
-     p <- isPrime k
-     if p then 
-        primes!count := k
-        count := count + 1
-     if k < limit then checkFrom (k+1)
-
-   result action
-     primes!0 := 2
-     count := 1
-     checkFrom 3
-     env.stdout.write (show count++"\n")
-     env.exit 0
-
-
-log3 :: Int -> Int
-log3 n  
-  | n < 3       = 0
-  | otherwise   = 1 + log3 (n `div` 3)
-
-
```
-
-Prime numbers are stored in array primes, which is -initialised with all zeros (primitive function uniarray -creates an array, whose size is given by the first argument, where -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
-The root action notes that 2 is a prime and initiates count -to 1; it then checks numbers for primeness, starting with 3 in -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -
-The procedure isPrime works by trial division, using already -discovered primes: to check whether k is a prime, one tries -to find a proper prime factor p such that p*p <= k. If -none is found, k is prime. - - - ) hunk ./examples/Primes_descr.html 68 -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -
+all elements are initialised to the value of the second argument). +

) merger 0.0 ( merger 0.0 ( hunk ./examples/Primes_descr.html 1 - - - -Primes - - - -

Primes

-As a reactive program, this is quite degenerate: when started, it -expects -a positive integer n>2 as command line argument. It -computes all primes smaller than or equal to n, prints -the number of such primes to stdout and terminates. -

-The algorithm used illustrates imperative programming using updatable -arrays in Timber. Here is the program: -

-module Primes where
-
-import POSIX 
-
-root env = class
-   limit :: Int
-   limit = parse (env.argv!1)
-   primesBound = limit `div` log3 limit
-
-   primes := uniarray primesBound 0
-   count  := 0
-
-   isPrime k = loop 0
-      where loop n = do 
-              p = primes!n
-              if p*p > k then
-                 result True
-              elsif k `mod` p  == 0 then
-                 result False
-              else loop (n+1)
-
-   checkFrom k = do
-     p <- isPrime k
-     if p then 
-        primes!count := k
-        count := count + 1
-     if k < limit then checkFrom (k+1)
-
-   result action
-     primes!0 := 2
-     count := 1
-     checkFrom 3
-     env.stdout.write (show count++"\n")
-     env.exit 0
-
-
-log3 :: Int -> Int
-log3 n  
-  | n < 3       = 0
-  | otherwise   = 1 + log3 (n `div` 3)
-
-

-Prime numbers are stored in array primes, which is -initialised with all zeros (primitive function uniarray -creates an array, whose size is given by the first argument, where -all elements are initialised to the value of the second argument -The program uses the moderately clever bound that the number -of primes up to n is at most n `div` log3 n. -

-The root action notes that 2 is a prime and initiates count -to 1; it then checks numbers for primeness, starting with 3 in -procedure checkFrom. The iterative check is expressed using -recursion, checking for successive numbers up to limit. -

-The procedure isPrime works by trial division, using already -discovered primes: to check whether k is a prime, one tries -to find a proper prime factor p such that p*p <= k. If -none is found, k is prime. - - - hunk ./examples/Primes_descr.html 63 +

) rmfile ./examples/Primes_descr.html ) ) ) ) hunk ./examples/Reflex_descr.html 1 - - - -Reflex - - - -
Reflex
- -
-Reflex is a simple reaction time tester. -Only the Return key is used in interaction with -the program. When pressing Return for the first time, -the user is instructed to Wait...; after a few seconds, -the program says Go! and the user must -strike Return again as fast as possible. The elapsed -time is displayed and the test can be repeated. -
-Here is the program: -
-
```
-module Reflex where
-
-import POSIX
-
-data State = Idle | Holding Msg | Counting
-
-root env = class
-  
-   print str = env.stdout.write (str ++ "\n")
-
-   tmr = new timer
-
-   state := Idle
-  
-   enter _ = action
-      case state of
-        Idle ->         msg <- after (sec 2) action
-                           tmr.reset
-                           print "Go!"
-                           state := Counting 
-                        print "Wait..."
-                        state := Waiting msg
-                 
-        Holding msg ->  abort msg
-                        print "Cheat!!!"
-                        state := Idle
-
-        Counting ->     t <- tmr.sample
-                        print (format t)
-                        state := Idle
-
-   result 
-     action
-       env.stdin.installR enter
-       print "Press return to start"
-
-format t = show (secOf t) ++ '.' : fracs ++ " secs"
-  where t100  = microsecOf t `div` 10000
-        fracs = if t100<10 then '0':show t100 else show t100 
-
```
-
-
-Comments to the code: -
- The program uses a timer object tmr, which is - an instance of the primitive class timer. A timer - can be can be reset and sampled; in - the latter case it returns the Time elapsed since it was - last reset. -
- The program is a simple State machine, where - state changes are triggered in two ways: -
  - The user strikes Return; the case statement in enter - describes the corresponding actions and state changes. Note that - a strike in the Holding state is a user error; - hence the user is accused of cheating. -
  - Two seconds have elapsed in the Holding state and - the action that was scheduled at the previous keystroke is - invoked. -
  -
- The Holding state carries one more piece of information in the - form of a Msg tag, created when the Go message was scheduled. - If the user cheats, that scheduled action must be aborted; - the message tag is needed as argument to the abort function. -
- The time displayed is formatted with two decimals, using - auxiliary function format. -
- Of course, the waiting time should not be fixed to two seconds but - vary a bit randomly; an easy but omitted extension with the help of a module for - generating random numbers. -
- This program should preferrably be executed in some simpler - environment with only a display, one or two buttons and perhaps some - sound-making device. The program would have to be modified - accordingly to import the proper environment module instead of POSIX - and to call the methods of that environment. -
- rmfile ./examples/Reflex_descr.html hunk ./examples/index.html 1 - - - -A summary of Timber - - - - - - - - - - -<body> -Please use a browser with support for frames. -</body> - - - - rmfile ./examples/index.html merger 0.0 ( hunk ./examples/menu.html 20 +
Primes

Primes

Counter

+The Counter example is a minimal example of a class from which one +can instantiate objects with state. Several variations are possible; +here is the one we choose: +

+module Counter where
+
+struct Counter where
+  incr  :: Action
+  decr  :: Action
+  value :: Request Int
+
+counter = class
+
+   n := 0
+
+   incr  = action n := n+1
+
+   decr  = action n := n-1
+   
+   value = request result n
+
+   result Counter{..}
+

+Comments: +

The first four lines of the module body + define a struct, or record, type, + called Counter. This type has three methods, + and will act as an interface to counter objects. +
The rest of the module defines a class counter. + Instances of this class have an internal state consisting of a + single integer state variable n, initialised to 0 when + the instance is created. The effects on the state when methods + are invoked on this object is described. Finally, the + result statement declares that object creation + returns a Counter interface to the object. + Thus counter has type Class Counter. +
To create an object of this class, one writes (within a method + or another class definition) +
```
+ctr = new counter
+
```
+The variable ctr has type Counter, and the newly + created object can be updated by method calls ctr.incr and + ctr.decr. The state can be read by +
```
+val <- ctr.value
+
```
+
Any method call has exclusive access to the state of the + object; there is no need for the programmer to protect calls + further. +
The two action methods are invoked asynchronously, + while the value-returning request of course requires + synchronous communication. +
The notation Counter{..} means "assemble an + object of type Counter from definitions in scope". + It would be possible, and maybe preferrable in this small example, + to define the methods within the result expression as follows: +
```
+counter = class
+
+   n := 0
+
+   result
+     struct
+       incr  = action n := n+1
+       decr  = action n := n-1
+       value = request result n
+
```
+In more complex situations, the {..} is a useful convenience. +
To see an example of use of counter, see EchoServer2. +

Variation

counter

+counterInit init = class
+  
+   n := init
+
+   ...
+

+ctr = new counterInit 5
+

+Thus, we have the typing counterInit :: Int -> Class Counter. +

+We might still keep the definition of counter, but this would +mean code duplication that should be avoided. Instead, we could write +

+counter = counterInit 0
+

counter

Echo2

+Let us make the Echo program just a little bit more +interesting: We add an initial welcome phrase and a +prompt with a line number. Here is the program: +

+module Echo2 where
+
+import POSIX
+
+root env = class
+
+   count := 1
+
+   prompt = do
+      env.stdout.write (show count++"> ")
+      count := count+1
+
+   echo str = action
+      env.stdout.write str
+      prompt
+
+   result
+      action
+         env.stdin.installR echo
+         env.stdout.write "Welcome to Echo2!\n"
+         prompt
+

+The root definition now has two more components: +

The (implicit) declaration and initialisation of the state + variable count, which will maintain line numbers. +
The auxiliary procedure prompt, which writes + a prompt to the user and increases the line count. +

+In addition, the callback and the initial action both call +prompt, and a greeting phrase is added. +

+Some additional details: +

The keyword do signifies the start of a, + typically local, procedure, that may be called from other methods + as above.
show is a function that converts + the integer value count to a string; ++ + denotes string concatenation. Both these are defined in + the Prelude, a library module which is implicitly imported by + all modules.
The user input string given to echo will include + the newline; hence so will the string echoed to stdout. + But to write the welcome phrase on a separate line, it will have + to end with an explicit newline.
The root object maintains state variable + count, which is initialised to 1 and increased for each + prompt written. Obviously, it would be possible to use + a counter object here, but in this simple program that + seems an overkill. +
A more careful description of what the runtime system does + when the program is run is the following: it creates an object of type + Env, + applies function root to that object, creates an object + of the resulting class and invokes the resulting action. +

Echo3

+Now, let's try a variation; program Echo3 writes +Hello!\n to stdout once a second. The user can change this +message by typing a line on stdin; after the line is finished +with a return, the line typed will be the new message. Here is the program: +

+module Echo3 where
+
+import POSIX
+
+root env = class
+
+   current := "Hello!\n"
+
+   save str = action
+      current := str
+
+   tick = action
+      env.stdout.write current
+      after (sec 1) tick
+
+   result
+      action
+         env.stdin.installR save
+         tick
+

The message to be printed once a second is maintained in state + variable current. +
The callback installed with stdin changes + current. +
The initial action not only installs save, it also + invokes the auxiliary action tick, which prints + current and schedules itself for later execution. + +
The scheduled execution time (the baseline) for each instance of tick is + one second after the baseline of the previous instance. Thus there + is no ackumulating drift in the program, even if a particular tick may be delayed in + execution. +

+When running Echo3 one notices a peculiarity of the standard +implementation of the POSIX environment: the screen doubles + as both the output +device stdout and as user feedback part of the input device +stdin. Thus, output is intertwined with input characters in a +rather unsatisfactory way. + addfile ./web/EchoServer2_descr.html hunk ./web/EchoServer2_descr.html 1 + + + +EchoServer2 + + + +

EchoServer2

+This is a minor extension of EchoServer: when started, it +expects an integer command line argument maxClients, denoting +the maximal number of concurrently served clients. If more clients +connect, they are just informed that the server is busy and +disconnected. +

+module EchoServer2 where
+
+import POSIX
+import Counter
+
+port = Port 12345
+
+root env = class
+ 
+    clients = new counter
+
+    log str = action
+       env.stdout.write ('[':str ++ "]\n")
+
+    result action
+       maxClients = parse (env.argv ! 1)
+       env.inet.tcp.listen port (server maxClients clients log)
+
+server maxClients clients log sock = class
+
+   n := 1
+
+   p = show sock.remoteHost
+
+   echo str = action
+      sock.outFile.write (show n ++"> "++str)
+      n := n+1
+
+   close = request
+      clients.decr
+      log (p ++ " closing")
+      result ()
+
+   neterror str = log ("Neterror: "++str)
+
+   established = action
+      cl <- clients.value
+      if cl < maxClients then
+         clients.incr
+         log ("Connected from " ++ p)
+         sock.inFile.installR echo
+      else
+         sock.outFile.write "Server busy"
+         log ("Refused " ++ p)
+         sock.close
+
+   result Connection{..}
+

EchoServer

+ We need to keep track of the number of served clients. + For this we use a Counter + object, created by the root object. +

When a new client connects, the counter value is retrieved and + only if this value is small enough is an echo action installed; + otherwise the client is informed that the server is busy and the + socket closed. When a client closes the connection, the counter is decreased. +

+ A Counter object is appropriate here, since several server objects, + each interacting with one client, interacts with it. On the + contrary, the line number local to each server object is maintained + in a simple integer state variable. + + addfile ./web/EchoServer_descr.html hunk ./web/EchoServer_descr.html 1 + + + +EchoServer + + + +

EchoServer

+Now, let's look at a further feature of the POSIX +environment. It also supports writing network programs, +that communicate over the Internet using sockets. +A socket can be thought of as a two-way communication channel, +consisting of both an RFile and a WFile. +

+Two network programs, which +execute on different machines, may connect over +the network and communicate using a socket. +Typically, one of the programs will be a server +and the other a client. Here is a trivial server, the +EchoServer. + This server waits indefinitely for clients to connect on port + 12345. When a client connects, the server starts a session, where + client input rows are echoed back to the client, prefixed by a line + number. Several clients may be served concurrently and + line numbering is independent for each client. + +

+module EchoServer where
+
+import POSIX
+
+port = Port 12345
+
+root env = class
+
+    log str = action
+       env.stdout.write ('[':str ++ "]\n")
+
+    result action
+       env.inet.tcp.listen port (server log)
+
+
+server log sock = class
+
+   n := 1
+
+   p = show sock.remoteHost
+
+   echo str = action
+      sock.outFile.write (show n ++"> "++str)
+      n := n+1
+
+   close = log (p ++ " closing")
+
+   neterror str = log ("Neterror: "++str)
+
+   established = action
+      log ("Connected from " ++ p)
+      sock.inFile.installR echo
+
+   result Connection{..}
+

+Comments to the code: +

The result action of the root definition just installs a + listening callback in the environment. Such a callback has type + Socket -> Class Connection where +
- a Socket object has selectors for the resources + from the environment + needed by the serving object: the remoteHost and + remotePort and the inFile and outFile + parts of the connection. +
- a Connection implements the services provided + by the server + to the environment: an initial action to call when the + connection is established, an action to call with + an error message when a + neterror occurs and a method to call when the + remote client wants to close the connection. +
+
The echoing behaviour is achieved by installing, + when connection is established, the + echo method with the inFile of the socket. +
Additionally, the server logs its connections and + errors, using the logging method + that it get as parameter (which logs to stdout). +

+In order to let you run the server, we provide a simple client, +TCPClient. We do not list the code here; you may review +it in TCPClient.t. The client accepts a host name and a port +number as command line arguments and connects to a server on that +address. When connection is established, the client accepts user input +lines, sends them to the server and displays replies obtained on the +screen. + addfile ./web/Echo_descr.html hunk ./web/Echo_descr.html 1 + + + +Echo + + + +

Echo

+Our first example runs in a very simple setting: a computing environment +where the interaction between the external world and the program is through a keyboard and a text screen. +The user provides input using the keyboard and the program prints +output on the screen. +

+We consider a reactive program, where the user +input is just echoed on the screen, line by line, +by the program. This trivial interaction, the "Hello, world" of +reactive programs, goes on indefinitely. +

+Here is the program: +

+module Echo where
+
+import POSIX
+
+root env = class
+
+   echo str = action
+      env.stdout.write str
+
+   result 
+      action 
+         env.stdin.installR echo
+

+Let us explain the program: +

The first line just states the name of the module.
Line 3 contains an import declaration; we will use resources from +POSIX, a predefined library module that provides the types + needed to build programs for simple environment we described above. +
+Module POSIX defines a struct type Env, with selectors +corresponding to the resources available to the program in its interaction +with the environment. +Among these are stdin, which refers to the keyboard, +and stdout, which refers to the screen.
+Module POSIX also acts as the default +target environment for Timber programs. +This target environment prescribes that a program +must contain a root definition +
```
+root :: Env -> Class Action
+
```
+
+ +In module Echo, this definition starts on line 5 and +makes up the rest of the program. +
+root must describe the initial behaviour of the program in its +result action, which terminates the class definition. +
+In addition, it may make auxiliary definitions; here of +the function echo, which describes how the program +reacts to an input string str. +The resulting action just installs this function as +a callback with env.stdin. +

When executed, the runtime system invokes the +result action of the root definition (see +Echo2 for a more careful description.) +After that, the program is idle, waiting for user input. +When such (line-buffered) input occurs, the runtime system +invokes the callback with the input line as argument. +

+This trivial program is typical for the Timber programming idiom; +we describe how the program should react to external events and +install, or register, this description with the external device. +

+We note, finally, that the use of stdout and +stdin is consistent with their types as +specified in Env: +

stdout +is a WFile and thus has a write method; +
stdin is a RFile, and thus has an +installR method. +

MasterMind

+examples> ./MasterMind
+Welcome to Mastermind!
+Choose your secret. Press return when ready.
+
+My guess: Red Blue Blue Red
+Answer (two integers): 1 1
+My guess: Blue Black Yellow Red
+Answer (two integers): 2 0
+My guess: Green Black Red Red
+Answer (two integers): 0 0
+My guess: Blue Blue Yellow White
+Answer (two integers): 3 0
+My guess: Blue Blue Yellow Blue
+Answer (two integers): 3 0
+My guess: Blue Blue Yellow Yellow
+Answer (two integers): 4 0
+Yippee!
+Do you want to play again? (y/n) n
+examples> 
+

The program makes use of two auxiliary modules + Data.Functional.List and RandomGenerator. The + former is a library module, while the latter is provided in the + examples directory. +
The program complains if the user gives contradictory answers, + asks for the secret and explains the user's mistake. +
There is no error handling: if an answer cannot be parsed as + two integers, the program crashes. +

Primes

+As a reactive program, this is quite degenerate: when started, it +expects +a positive integer n>2 as command line argument. It +computes all primes smaller than or equal to n, prints +the number of such primes to stdout and terminates. +

+The algorithm used illustrates imperative programming using updatable +arrays in Timber. Here is the program: +

+module Primes where
+
+import POSIX 
+
+root env = class
+   limit :: Int
+   limit = parse (env.argv!1)
+   primesBound = limit `div` log3 limit
+
+   primes := uniarray primesBound 0
+   count  := 0
+
+   isPrime k = loop 0
+      where loop n = do 
+              p = primes!n
+              if p*p > k then
+                 result True
+              elsif k `mod` p  == 0 then
+                 result False
+              else loop (n+1)
+
+   checkFrom k = do
+     p <- isPrime k
+     if p then 
+        primes!count := k
+        count := count + 1
+     if k < limit then checkFrom (k+1)
+
+   result action
+     primes!0 := 2
+     count := 1
+     checkFrom 3
+     env.stdout.write (show count++"\n")
+     env.exit 0
+
+
+log3 :: Int -> Int
+log3 n  
+  | n < 3       = 0
+  | otherwise   = 1 + log3 (n `div` 3)
+
+

primes

uniarray

n

n `div` log3 n

+The root action notes that 2 is a prime and initiates count +to 1; it then checks numbers for primeness, starting with 3 in +procedure checkFrom. The iterative check is expressed using +recursion, checking for successive numbers up to limit. +

+The procedure isPrime works by trial division, using already +discovered primes: to check whether k is a prime, one tries +to find a proper prime factor p such that p*p <= k. If +none is found, k is prime. + + + addfile ./web/Reflex_descr.html hunk ./web/Reflex_descr.html 1 + + + +Reflex + + + +

Reflex

+Reflex is a simple reaction time tester. +Only the Return key is used in interaction with +the program. When pressing Return for the first time, +the user is instructed to Wait...; after a few seconds, +the program says Go! and the user must +strike Return again as fast as possible. The elapsed +time is displayed and the test can be repeated. +

+Here is the program: +

+module Reflex where
+
+import POSIX
+
+data State = Idle | Holding Msg | Counting
+
+root env = class
+  
+   print str = env.stdout.write (str ++ "\n")
+
+   tmr = new timer
+
+   state := Idle
+  
+   enter _ = action
+      case state of
+        Idle ->         msg <- after (sec 2) action
+                           tmr.reset
+                           print "Go!"
+                           state := Counting 
+                        print "Wait..."
+                        state := Waiting msg
+                 
+        Holding msg ->  abort msg
+                        print "Cheat!!!"
+                        state := Idle
+
+        Counting ->     t <- tmr.sample
+                        print (format t)
+                        state := Idle
+
+   result
+     action
+       env.stdin.installR enter
+       print "Press return to start"
+
+format t = show (secOf t) ++ '.' : fracs ++ " secs"
+  where t100  = microsecOf t `div` 10000
+        fracs = if t100<10 then '0':show t100 else show t100 
+

+Comments to the code: +

The program uses a timer object tmr, which is + an instance of the primitive class timer. A timer + can be can be reset and sampled; in + the latter case it returns the Time elapsed since it was + last reset. +
The program is a simple State machine, where + state changes are triggered in two ways: +
- The user strikes Return; the case statement in enter + describes the corresponding actions and state changes. Note that + a strike in the Holding state is a user error; + hence the user is accused of cheating. +
- Two seconds have elapsed in the Holding state and + the action that was scheduled at the previous keystroke is + invoked. +
+
The Holding state carries one more piece of information in the + form of a Msg tag, created when the Go message was scheduled. + If the user cheats, that scheduled action must be aborted; + the message tag is needed as argument to the abort function. +
The time displayed is formatted with two decimals, using + auxiliary function format. +
Of course, the waiting time should not be fixed to two seconds but + vary a bit randomly; an easy but omitted extension with the help of a module for + generating random numbers. +
This program should preferrably be executed in some simpler + environment with only a display, one or two buttons and perhaps some + sound-making device. The program would have to be modified + accordingly to import the proper environment module instead of POSIX + and to call the methods of that environment. +

Advanced type system features

+to appear + addfile ./web/bindings.html hunk ./web/bindings.html 1 + + +Patterns and bindings + + + + +

Patterns and bindings

Patterns and pattern matching

+Patterns occur in several syntactic contexts in Timber (e.g. in the left hand sides of bindings, lambda expressions +and case alternatives). Syntactically, patterns form a subset of expressions; a pattern is one of the following: +

A variable. +
A literal. +
A constructor, possibly applied to a sequence of patterns. The sugered forms for lists and tuples are allowed. +
A fully or incompletely defined struct expression (but not a layout-sensitive struct expression), where + the right hand sides of all fields are patterns. +
A pattern in parentheses. +

+At run-time, patterns are matched against values. Pattern-matching may succeed or fail; in the former case the result +is a binding of the variables in the pattern to values. The rules are as follows: +

Matching a variable x against a value v always succeeds, binding x to v. +
Binding a literal l against a value v succeeds only if the v is the value + denoted by l; no variable is bound. +
Matching a constructor pattern C p1 ... pn against a value v succeeds only if + v = C v1 ... vn and matching pi against vi succeeds for all i; the resulting + binding is the union of the bindings resulting from each of these matchings. +
Matching a struct pattern against a value v starts by stuffing the record; it then has the form + S {sel1 = p1, ... seln = pn}. Matching against a value v succeeds if v = S {sel1 = v1, seln = vn} + and matching pi against vi succeeds for all i; the resulting + binding is the union of the bindings resulting from each of these matchings.
Mathing (p) against a value is the same as matching p against the same value. +

+The special "wildcard" variable _ may be used in patterns; in contrast to other variables, it is not bound + by pattern-matching. +

+ A consequence of the way pattern-matching is done is that patterns must be linear; no variable may occur more than once in + a pattern. + +

Bindings

+Syntactically, bindings are divided into type signatures and equations. Equations are either function bindings, pattern bindings + or instance bindings for implicit struct types. + +

Type signatures.
+
```
+  var (, var)* :: qtype
+  
```
+ Here a qtype is a (possibly qualified) type. +
+ + + + + + +
Examples +
x, y, z :: Int
map :: (a -> b) -> [a] -> [b]
elem :: a -> [a] -> Bool \\ Eq a
+
Function bindings. +
We present first the simplest form of function definition, a sequence of equations, and then how these may +be extended with where-clauses and with guards; these extensions may be combined. +
- Simple function bindings. A simple function binding is a sequence of equations in layout-sensitive syntax, where +each equation has the form
  +
```
+var pat* = expr
+
```
  +
  +The variable (the name of the function) and the number of patterns must be the same in all equations. +The order of equations is significant; when applying the function, pattern-matching is tried starting wih the first equation +until it succeeds; the function value is computed from right hand side of that equation, using the variable bindings obtained. +Within one equation, patterns are matched from left to right. +
  + + + + + +
  Example +
  zip (x:xs) (y:ys) = (x,y) : zip xs ys
  zip _ _ = []
  +
- Bindings with where-clauses.
  +A binding may have attached a where-clause with a list of local bindings in layout-sensitive syntax
  +
```
+var pat* = expr
+  where bind +
+
```
  + + + + + +
  Example +
  formatLine n xs = concatMap f xs
  where f x = rJust n (show x)
  +
- Guarded equations. In addition to patterns, the left hand side may include one or more guards
  +
```
+var pat*
+  ( | (qual)+ = expr )+
+
```
  +
  +In the most common case, a qual is a Boolean expression. After pattern-matching has succeeded, the guards are +evaluated in turn; the right hand side corresponding to the first true guard (if any) is used. +
  + + + + + + + +
  Example +
  lookup x [] = Nothing
  lookup x ((a,b) : xs)
  | x == a = Just b
  | True = lookup x xs
  +
  +More complicated guards that bind variables are possible, but omitted here. +
+
Pattern bindings.
+
```
+pat = expr
+
```
+
+where pat is not a variable (in which case the binding is, perhaps counter-intuitively, a function binding). +
+Pattern bindings bind the variables in pat by pattern-matching against the value of expr. +A pattern binding may not occur as a top-level declaration, but only as a local binding. +
+ + + + + +
Example +
lookup' x ps = y
where Just y = lookup x ps
+
The pattern-binding in the where-clause will fail (and the function application give a run-time error), if +the result of calling lookup is Nothing. +
Instance bindings for implicit struct types. +
+
```
+implicit var :: type
+  funBind*
+
```
+
+The type signature of an instance of an implicit type is prepended by the keyword implicit. For instances, +a type signature is compulsory; only the function binding defining the instance is not sufficient, +

Examples +
`x, y, z :: Int`
`map :: (a -> b) -> [a] -> [b]`
`elem :: a -> [a] -> Bool \\ Eq a`

Example +
`zip (x:xs) (y:ys) = (x,y) : zip xs ys`
`zip _ _ = []`

Example +
`formatLine n xs = concatMap f xs`
`where f x = rJust n (show x)`

Example +
`lookup x [] = Nothing`
`lookup x ((a,b) : xs)`
`\| x == a = Just b`
`\| True = lookup x xs`

Example +
`lookup' x ps = y`
`where Just y = lookup x ps`

+The order between bindings in a sequence of bindings is not significant, with the following exceptions: +

All the equations that make up a function binding must be adjacent to each other with no other binding intervening. +
A type signature must precede the binding equations for the variables that are typed by the signature. +

+Function bindings are recursive. For pattern bindings certain limited forms of recursion are possible, in order +to build finite, cyclic data structures. To be described more... + addfile ./web/default.html hunk ./web/default.html 1 + + +Default declarations + + + + +

Default declarations

+Default declarations come in two distinct forms. They share the keyword default and they both +affect instances for implicit struct types, but otherwise they serve quite different purposes. +

Ordering between instances.
+ For a given implicit struct type T, several instances are typically defined. It is permitted to define + instances at overlapping types, such as e.g. T [a] and T [Int], where the latter type + is more specific than the former. +
+ During type-checking, the compiler + needs to insert instances as implicit arguments to functions that use of the selectors of T. The compiler infers + which instance type T t that is needed and chooses the most specific instance. However, it may happen that there + is no most specific type. The prelude defines intInt :: IntLiteral Int and intFloat :: IntLiteral Float and similarly for + Show. Neither of + this is more specific than the other. Thus a top-level definition such as +
```
s = show 1
+
```
+ leads to problems; should + implicit arguments for Int or Float be inserted? There is no reason to prefer one to the other so s is + considered ill-typed. But the matter can be decided by inserting a default declaration; the prelude declares +
```
+default intInt < intFloat
+
```
+which means that the instance intInt is to be preferred to intFloat. Thus the Int instances +are chosen and s is "1" rather than "1.0". +

Generation of instances.

+A declaration +

+default tD :: T D
+

+where T is an implicit struct type and D is a data type produces automatically an instance following +the ideas of Hinze's and Peyton Jones' derivable type classes. The mechanism applies only in some, rather restrictive, situations, +but these include common cases like the Prelude's Eq and Ord, for which it is easy but tedious +to define instances for a new data type. +

+The method applies only to one-parameter implicit +types, for which the types of all selectors are simple, according to the following inductive definition: +

monomorphic types are simple. +
the type parameter of the implicit struct type is simple. +
if t1...tn are simple, then (t1,...,tn) is simple. +
if t1 and t2 are simple, then t1 -> t2 is simple. +

+The mechanism also requires that instances are defined for the unit type (), the type (a,b) of pairs and +the primitive type Either a b. The default instance builds an auxiliary type A using only these three +type constructors and defines functions in both directions between between D and A. The default instance +for D makes use of the instance +for A (which is well-defined, since instances exist for (), pairs and Either). +

+In addition to the above mechanism, default instances can be defined for implicit types Show and Parse (defined in the Prelude), but as yet only for enumeration types (pending decisions on proper definitions of predefined implicit types for +conversion between values of data types and strings). + + + addfile ./web/download.html hunk ./web/download.html 1 + + +Download Timber + + + + +

Download the Timber compiler v1.0

Source distribution

+ to appear +

MacOS X binary distribution

+ to appear +

Linux binary distribution

+ to appear +

Access the source code repository

+darcs get http://code.haskell.org/timber
+

+ + addfile ./web/examples.html hunk ./web/examples.html 1 + + +Tutorial examples + + + + +

Tutorial examples

+This directory contains a number of simple Timber examples. +In addition to the pages that describe the programs and comment on +the code, the source files are here and can be compiled and run. +

+Module Echo is stored in file Echo.t and is compiled +and linked by the shell command +

+timberc --make Echo
+

+which produces an executable file called Echo which can be +run by the command +

+./Echo
+

+This is generalized in the expected way to other programs; in +particular, the --make option makes sure that all +(recursively) imported modules are compiled in the proper order +before linking is done. +

+Some programs require a command line argument as described in the +respective page. +

A brief summary of the programs is the following: +

Echo. The archetypical reactive program: user input is + read line by line and echoed to the screen. +
Counter. The quintessential stateful class; its instances + maintain an integer value that can be increased and decreased. +
Echo2. Slight extension of Echo: the output + lines are decorated with line numbers, thus adding state to the + root definition. +
Echo3. Another extension: The last input line is + repeatedly echoed once per second, showing use of Timber time + constructs. +
EchoServer. Still a variation: Echoing user input + over the Internet. +
EchoServer2. A variation of the previous: limiting + the number of concurrently served clients. +
Reflex. A simple reaction time tester. +
MasterMind. A bit more complex: The user chooses a + secret in MasterMind and the program does the guessing. +

+ addfile ./web/expr.html hunk ./web/expr.html 1 + + +Expressions and patterns + + + + +

Expressions

+Timber has a rich expression language and we divide +the description in three parts: +

Basic forms of expressions. +
Here we describe the Timber form of expression forms that have counterparts in most functional languages. +
Classes, actions and requests. +
These forms are special to Timber and provide the building blocks for + object-oriented programming. +
Further forms of expression. +
Every Timber program will include expressions from the previous two groups. In this + third group we describe more esoteric forms that may be ignored by the beginning Timber programmer. +

+ +

Layout-sensitive syntax

+Layout of program code is significant in Timber. In many cases, sequences of syntactic elements can be written in +tabular form, where each new item starts on a new line and in the same column as the beginning of the previous item. Multi-line +items are possible by intending subsequent lines; the end of the sequence is signalled by "outdenting", i.e. indenting +less, as in the example +

+   showSeq xs = concat (map showLine xss)
+     where prec = 100
+           showLine x = map (showItem 10)
+                            (comp prec xx)
+
+   showItem n x = format n ('_' : g x)
+

+The definition of showSeq has a where-clause with a list of two local definitions (defining prec and +showLine). The definition of showLine spans two lines, indicated by indentation. The last definition, +of showItem, has another indentation level, thus is not part of the where-clause and is hence not +local to showSeq. Instead showSeq and showItem form another list of bindings. +

+It is possible to avoid layout-sensitive syntax by enclosing such sequences in braces and using semi-colon as +separator: let {x=1; y=f x 3} in g x y; this is generally not recommended. + +

Basic forms of expressions

+ +

Variables. A variable is an identifier (which may be qualified and which may be an operator enclosed in parentheses). +
+ + + + +
Examples +
x, counter, Dictionary.d, (+)
+ +
Literals. Timber literals include integer literals, floating point literals, character literals and string literals. There + are no surprises here and we give just a few examples. +
+ + + + + + + + +
Type of literal + Examples +
Int 37, 0, -123
Float 1.23, 3E12, 0.4567E-6
Char 'a', '3', '\n', '\t', '\\'
String "Hi", "Error\n"
+
+Every occurrence of an integer literal except in patterns is during desugaring replaced by application of the function +fromInt to the literal. The Prelude defines +
```
+typeclass IntLiteral a where
+  fromInt :: Int -> a
+
```
+and instances for Int (the identity function) and Float (conversion). +
+This device will make many functions that mention integer literals usable for both Int and Float arguments; +a simple example is +
```
+sum :: [a] -> a \\ Num a, IntLiteral a
+sum [] = 0
+sum (x : xs) = x + sum xs
+
```
+
Function (and constructor) application. Application is denoted by juxtaposition, binds tighter than all operators and is left associative. +
+ + + + + + + + +
Examples + Comments
f 3 Parentheses not needed
g (x+2) Parentheses necessary
Just (f x) Constructor Just applied to f x
map f (g xs) map f applied to g xs
hMirror (x,y) One argument, which is a pair
+
Operator application. An operator may be used in infix form between two operands. This is just syntactic +sugar for application. +
+ + + + + + +
Examples + Desugared forms
x+3 (+) x 3
f x+3*x (+) (f x) ((*) 3 x)
3 `elem` xs elem 3 xs
+
+Precedence and associativity of operators is determined syntactically; see the name page for details.
Constructors. A constructor is defined in a data type definition or is one of the primitive constructors : and [] +for lists, False and True for Bool and () for ().
Lambda expressions.
+
```
+\pat+ -> expr
+
```
+
+denoting anonymous functions. The sequence of patterns must be linear, i.e. may not include more than one occurrence +of any variable. +
+ + + + + +
Example +
\x -> x+3
\ (Just x) d -> insert x 0 d
+
Tuples. +
+Pairs, triples etc are expressed using parenheses as delimiters and comma as separator. These are also desugered to +application: +
+ + + + + +
Examples + Desugared forms
(a,b) (,) a b
(f x,3+5,True) (,,) (f x) ((+) 3 5) True
+
+Here (,), (,,) etc are primitive constructors for the types of pairs, triples etc. +
List expressions. +
List expressions are sequences delimited by square brackets and with comma as separators;[1,3,7] +is a list with three elements. This form is desugared to the primitive form of lists, which has as constructors +[] (the empty list) and : ("cons", which builds +a list with its first argument as first element ("head") and second argument as remainder ("tail")). +
+ + + + + +
Examples + Desugared forms
[1,3,7] (:) 1 ((:) 3 ((:) 7 []))
[f x, p 3] (:) (f x) ((:) (p 3) [])
+
+ +
+Let expressions. +
+
```
+let bind+ in expr
+
```
+
where the list of bindings is layout-sensitive. The bindings are recursive, i.e all the +names defined in the bind list are in scope in the right hand sides of these bindings (and, of course, +in the main expression). +
+ + + + + + + +
Example + Comments
let size = f 100 f, defined below, is in scope
f 0 = 0 Pattern-matching allowed
f x = g x (x+2)
in concat (map f xs)
+
+
Struct expressions. Expressions denoting values of a struct type come in several forms: +
- Fully defined struct expression.
  +
```
+[ type_constructor ] { field (, field )+ }
+
```
  +where field has the form +
```
+selector = expr
+
```
  + The type_constructor is the name of a struct type. Since the struct type is uniquely determined +by its fields, the type name is optional. +
  + + + + + + +
  Examples +
  Point {x=3, y=1}
  {x=3, y=1}
  Counter {inc = inc, read = read}
  +
  The examples presupposes type definitions +
```
+struct Point where
+  x, y :: Int
+
+struct Counter where
+  inc  :: Action
+  read :: Request Int
+
```
  +
  +The last example is to emphasise that selectors (the inc and read in the left hand +sides of the fields) are in a separate namespace from variables (the right hand sides). Thus the equations +are not recursive; the example requires +that definitions of these variables are in scope. +
- Incomplete struct expressions.
  +
```
+type_constructor {[ field (, field )+] ..}
+
```
  +
  +The trailing .. indicates that the struct value should be stuffed, by adding fields +of the form x = x for each selector x that is not explicitly given a value in a field. +
  + + + + + + + +
  Example + expands to +
  Counter {..} Counter {inc = inc, read = read}
  Counter {read = readreq ..} Counter {read = readreq, inc = inc}
  Point {x=0..} Point {x=0, y=y}
  +
  +Obviously, because of subtyping, the type name cannot be omitted here. +
- +Layout-sensitive struct values.
  +
```
+struct bind+
+
```
  +
  +where the bindings have layout-sensitive syntax. +
  + + + + + + + +
  Example +
  implicit showList :: Show [a] \\ Show a
  showList = struct
  show [] = "[]"
  show (x : xs) = '[':show x ++ preC (map show xs)++"]"
  +
  +The list of bindings in this form of expression differs from all other occurrences of +lists of bindings in that they are not recursive. We are defining the selectors in a struct +but allow pattern matching equations in layout-sensitive form; occurrence of the same name as a +variable in the right hand side must refer to some other definition in scope. This is particularly +common for structs defined to be type classes, as here. See the section on type classes for +more explanatation. +
+
Case expressions.
+
```
+case expr of alt+
+
```
+
+where the sequence of alternatives is layout-sensitive. The simplest form of an alternative is +
+
```
+pat -> expr
+
```
+
+ + + + + + +
Example +
case f a b of
[] -> 0
x : xs -> g x + h 3 xs
+
+

Examples +
`x, counter, Dictionary.d, (+)`

Type of literal +	Examples +
`Int`	`37, 0, -123`
`Float`	`1.23, 3E12, 0.4567E-6`
`Char`	`'a', '3', '\n', '\t', '\\'`
`String`	`"Hi", "Error\n"`

Examples +	Comments
`f 3`	Parentheses not needed
`g (x+2)`	Parentheses necessary
`Just (f x)`	Constructor `Just` applied to `f x`
`map f (g xs)`	`map f` applied to `g xs`
`hMirror (x,y)`	One argument, which is a pair

Examples +	Desugared forms
`x+3`	`(+) x 3`
`f x+3*x`	`(+) (f x) ((*) 3 x)`
3 `elem` xs	`elem 3 xs`

Example +
`\x -> x+3`
`\ (Just x) d -> insert x 0 d`

Examples +	Desugared forms
`(a,b)`	`(,) a b`
`(f x,3+5,True)`	`(,,) (f x) ((+) 3 5) True`

Examples +	Desugared forms
`[1,3,7]`	`(:) 1 ((:) 3 ((:) 7 []))`
`[f x, p 3]`	`(:) (f x) ((:) (p 3) [])`

Example +	Comments
`let size = f 100`	`f`, defined below, is in scope
`f 0 = 0`	Pattern-matching allowed
`f x = g x (x+2)`
`in concat (map f xs)`

Examples +
`Point {x=3, y=1}`
`{x=3, y=1}`
`Counter {inc = inc, read = read}`

Example +	expands to +
`Counter {..}`	`Counter {inc = inc, read = read}`
`Counter {read = readreq ..}`	`Counter {read = readreq, inc = inc}`
`Point {x=0..}`	`Point {x=0, y=y}`

Example +
`implicit showList :: Show [a] \\ Show a`
`showList = struct`
`show [] = "[]"`
`show (x : xs) = '[':show x ++ preC (map show xs)++"]"`

Example +
`case f a b of`
`[] -> 0`
`x : xs -> g x + h 3 xs`

Classes, actions and requests.

+Classes in Timber should be thought of as in object-oriented programming: a class is a template, from which +we may create several objects. An object encapsulates its own copy of the state variables defined in the class. +

Actions and requests are methods that a class may expose to the outside; they may manipulate the local +state of objects. +

+Procedures are subroutines that may be called by actions and requests; they are typically not exposed +in interfaces. In contrast to actions and requests, a procedure always reads and writes the local state +of its caller, irrespective of the scope in which it was defined. +

+The syntax of these constructs are similar; they are all built from sequences of statements: +

A class expression is the keyword class followed by a sequence of statements. +
An action expression is the keyword action followed by a sequence of statements. +
A request expression is the keyword request followed by a sequence of statements. +
A procedure expression is the keyword do followed by a sequence of statements. +

+In all cases, statement sequences have layout-sensitive syntax. See the statements page +for further descriptions. +

Further forms of expressions

+To be written. + addfile ./web/gentle.html hunk ./web/gentle.html 1 + + +A gentle introduction + + + + +

A gentle introduction

+The overall purpose of a Timber program is to react to events sent to it from +its execution environment. This process is potentially infinite, and the order of external +events is also not generally known in advance. +

+To capture this intuition, Timber defines its primary run-time structure to be a set of +interconnected reactive objects, that each encapsulate a piece of the global +program state. A reactive object is a passive entity defined by a set of methods, whose +relative execution order is left to be determined by clocks and external events. Between +invocations, a Timber object just maintains its state, ready to react when a method call +occurs. Like real-world objects, Timber objects evolve in parallel, although the methods +belonging to a particular object are always run under mutually exclusion. Concurrency as +well as state protection is thus implicit in Timber, and does not require any direct +mentioning of threads or other concurrency constructs. +

+Objects are created by instantiating a class. Methods are either asynchronous +or synchronous, as denoted by the keywords action and +request, respectively. The most radical property of Timber is that it is +free from any indefinitely blocking constructs; because of this, a Timber object is always +fully responsive when not actively executing code. This process structure should be +contrasted to the common infinite event-loop pattern in other languages, where blocking +system calls are used to partition an otherwise linear thread of execution into event-handling +fragments. +

+Each reaction in Timber is furthermore associated with a programmable timing window, +delimited by upper and lower constraints called the baseline and the deadline +of a reaction. The semantics of these constraints is formally defined like the rest of the +language, and serves the purpose of codifying the legal behavior of a Timber system in a +platform-independent manner. The timing window is inherited by each method call by default, +but can also be manually set by the programmer; using the constructs after for +moving a window forward with an offset, and before for setting a timing window +width. Both values are measured relative to the fixed reference-points of baselines, never +from the point in time a method call is actually made. Posting a message to arrive at some +specific time into the future is thus easy in Timber, and defining a periodic process amounts +to the special case of repeating such a pattern recursively. +

+The following Timber example shows a simple implementation of a sonar driver that +is coupled to an alarm. The specifications assumed state that a sonar beep should be 2 +milliseconds long, with a maximum jitter of 50 microseconds, and that the required accuracy +of the measurements dictate that time-stamps associated with beeps must also be accurate +down to the 50 microsecond range. The figure below illustrates the timing windows +constraining the involved methods ping and stop, and thus, indirectly, the actual +beep produced. +

+Furthermore, the sonar is supposed to sound every 3 seconds, and the deadline for reacting +to off-limit measurements is 5 milliseconds. These specifications look as follows when +translated into Timber code: +

 
+sonar port alarm critical = class
+    rm = new timer
+    count := 0
+    ping = before (microsec 50) action
+        port.write beep_on
+        tm.reset
+        after (millisec 2) stop
+        after (sec 3) ping
+    stop = before (microsec 50) action
+        port.write beep_off
+    echo = before (millisec 5) action
+        diff <- tm.sample
+        if critical diff then
+            alarm count
+            count := count + 1
+    result { interrupt = echo; start = ping }
+
+

The header sonar port alarm critical here defines function sonar to take +port (the port controlling the beeping hardware), alarm (the method to call +in emergency) and critical (a boolean function on time values) as parameters. The +shown class construct creates a local timer object instance tm, initializes +a state variable count to 0, and furthermore defines the asynchronous methods +ping, stop and echo. The resulting interface is a record +containing methods named interrupt and start, which are just exported +aliases for the local method names echo and ping, respectively. +

+A timer object allows the time between the current baseline and the baseline of +the last timer reset to be measured. This is utilized in method echo, where the +time since the last invocation of ping (bound to differ from the beep emission by +at most 50 microseconds) is sampled and analyzed to determine if an alarm should be sent. +When this happens, the provided alarm method is given the accumulated alarm count as an +argument. Notice how each ping causes two future events to be triggered: one call +to stop 2 milliseconds from the current baseline, and a recursive invocation of +ping itself after 3 seconds to keep the periodic sonar activity alive. +

+As an example of how a sonar object might be instantiated to run on a bare-metal embedded +system, here follows an example of the root declaration for such a system. +

root regs = class
+    crit d = d < millisec 15
+    a = new alarm (regs!com_port_addr)
+    s = new sonar (regs!sonar_port_addr) a crit
+    result [ s.start, s.interrupt, a.ack ]
+

+On this level, the interface to the software (as seen from the hardware) is the list +of interrupt handlers it provides (enclosed in square brackets). Consequently (from the +software perspective), the hardware takes the shape of an array of device registers that +can be read or written (with ! being the indexing operator). The parametric class +root above is thus of a type that can be instantiated and used directly by the +run-time system of a typical bare-metal platform, although it should be noted that the +exact shape of a root definition can vary between Timber platforms -- under the POSIX +environment, for example, the root class returns just a startup procedure, while taking +a full-featured operating system interface as an argument. +

+The semantics of Timber allows a natural implementation in terms of an EDF scheduler, +where the asynchronous methods of a program correspond to tasks, objects take the role +of shared resources, and all methods (synchronous as well as asynchronous) simply denote +code sequences that require exclusive access to the owning object. Timber also relegates +management of its garbage-collected heap to idle time, thus facilitating direct +application of known schedulability and execution time analysis methods. The implementation +technique used furthermore allows both objects and messages to be created in large numbers +without incurring any run-time penalty, at the same time as the number of threads behind +the scenes (i.e., the number of execution contexts and stacks) can be limited to the +maximum preemption depth a system is expected to need. +

+Additional features of Timber not covered here include a strong static type system +supporting subtyping, parametric polymorphism with overloading, and automatic type inference; +a rich set of heap-allocated immutable datatypes; first-class citizenship to all values +(meaning that methods as well as classes can be sent as arguments and stored inside data +structures); and a referentially transparent evaluation semantics in the purely functional +tradition. + addfile ./web/haskell.html hunk ./web/haskell.html 1 + + +Timber for Haskell programmers + + + + +

Timber for Haskell programmers

+Much of Timber syntax is taken from Haskell, so the Haskell programmer glancing +through Timber code will feel at home. This page summarizes instead the most important +differences between Timber and Haskell. +

Timber has strict semantics, not lazy as Haskell. This has a major impact on the + programming styles of the two languages. +
Timber has Haskell-like type classes, but with slightly + different syntax for both type class and instance declarations. The reserved word starting a + type class declaration is typeclass. + The main reason for this change is that the word class + in Timber is used to denote the well-known concept from object-oriented programming. + Instances of such types are + named values of the type, tagged by instance. The following excerpt from + the Prelude illustrates the concept. +
```
+typeclass Eq a where 
+  (==),(/=) :: a -> a -> Bool
+
+
+instance eqUnit :: Eq () 
+eqUnit = struct
+  _ == _ = True
+  _ /= _ = False
+
```
+
+One cannot attach a deriving-clause to a data type definition. Instead, one can separately +request default instances of some implicit types. +
In addition to data types, Timber has a dual notion of struct types. For both data and struct types there is a notion + of subtyping with inclusion polymorphism. +
Qualified types have another syntax in Timber. To illustrate, here is the definition of the function elem + from the Prelude: +
```
+elem :: a -> [a] -> Bool \\ Eq a
+elem x []           = False
+elem x (y : ys)     = x == y || elem x ys
+
```
+
+ Note: A call to elem will evaluate both arguments + completely (because the language is strict), but will not traverse its second argument + further when an equality becomes True (because the disjunction "operator" || is non-strict + in its right operand). +
In Timber one can express monadic computations using do-notation, but this is reserved for a particular primitive + monad Cmd s of commands operating on a state s. It is possible to define the concept of a general + monad as in Haskell (it is in fact defined in the prelude), but the do-notation is not available for general monads. +
The Cmd monad provides powerful constructs for object-oriented programming, with objects encapsulating a local +state and methods manipulating this state. This is achieved while retaining the pure nature of the language; a computation with +side-effects is clearly indicated by a monadic type (and can hence not be used in a non-monadic context). +
+Further, methods execute concurrently, but with exclusive access to the state of the object; thus Timber is also a concurrent +language with some real-time constructs. +
The main program of a Timber program is not of type IO () (this type does not exist in Timber), but there must +be a designated root module with a root definition; the type of this depends on the target environment. In the present +distribution, only a rudimentary POSIX environment is provided. +

The type system of Timber implements many of the non-standard features that are implemented as extensions in GHC. See +more details on the page that discusses advanced features of the type system. + addfile ./web/histcred.html hunk ./web/histcred.html 1 + + +History and credits + + + + +

History

+Timber is a direct descendant of +O'Haskell, +which was developed at Chalmers University of Technology in 1999. O'Haskell +extended the lazy functional programming language +Haskell +with object-oriented concepts such as methods, classes and subtyping, while retaining the +purely functional execution model of its ancestor. It also introduced the characteristic +notion of concurrent reactive objects that Timber subsequently has adopted. +

+The Timber language attained its main shape during the Timber project, which was run at +the Oregon Graduate Institute between 2000 and 2003 as part of the DARPA PCES program +(Program Composition for Embedded Systems). Here the semantics of time-constrained reactions +was developed, and it was also decided to abandon the lazy execution model of Haskell and +O'Haskell in favor of a more standard (i.e., strict) parameter passing mechanism; primarily +for the purpose of facilitating more predictable execution times. A prototype Timber +interpreter was developed at this time, based on a similar implementation of the O'Haskell +language. +

+After 2003, work on the Timber language regrettably had to continue at a slower pace, +primarily concentrating on completing the implementation of the Timber compiler. Since +2007, however, the project has regained momentum, and the language is now being actively +developed and maintained by groups and individuals at Luleå University of Technology, +Chalmers University of Technology, University of Kansas and Portland State University. +Version 1.0 of the Timber compiler was publicly released in the fall of 2008. + +

Credits

+ +People and organizations involved in the development and support of Timber: +

+ + + + + + + + + + + + + + + + + + + + + + + +
Johan Nordlander Björn von Sydow Andy Gill
Per Lindgren Magnus Carlsson Pawel Pietrzak
Viktor Leijon Peter A Jonsson Andrey Kruglyak
Simon Aittamaa Johan Ericsson Jimmie Wiklander
+

+ + + + +

+ + addfile ./web/home.html hunk ./web/home.html 1 + + +Timber Home + + + + +

Timber Home

+[TIMe - eMBEdded - Reactive] +

+Timber is a general programming language specifically aimed at the construction of complex +event-driven systems. It allows programs to be conveniently structured in terms of +objects and reactions, and the real-time behavior of reactions can furthermore +be precisely controlled via platform-independent timing constraints. This property +makes Timber particularly suited to both the specification and the implementation of real-time +embedded systems. +

+Timber is deeply rooted in the functional programming tradition, although it also +draws heavily on object-oriented concepts, and has the notion of concurrent +execution built into its core. + +

News

Nov 11: Major web site update. +

+ addfile ./web/index.html hunk ./web/index.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_download.html hunk ./web/index_download.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_examples.html hunk ./web/index_examples.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_gentle.html hunk ./web/index_gentle.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_histcred.html hunk ./web/index_histcred.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_limplans.html hunk ./web/index_limplans.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_pubs.html hunk ./web/index_pubs.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/index_summary.html hunk ./web/index_summary.html 1 + + + +Timber + + + + + + + + + + +<body> +Please use a browser with support for frames. +</body> + + + + addfile ./web/java.html hunk ./web/java.html 1 + + +Timber for Java programmers + + + + +

Timber for Java programmers

+Timber can be seen as an object-oriented programming language with +many familiar features, but also some less familiar. This page summarizes +both similarities and differences. +

+The Timber compilation unit is a module. Within such a module one +defines e.g. types, functions and classes. So there are many other +entities in Timber than classes and objects. +
The correspondence to a Java interface is a Timber + struct type. Here is an interface suitable for a simple counter object: +
```
+struct Counter where
+  incr  :: Action
+  reset :: Action
+  read  :: Request Int
+
```
+
+A class that implements this interface provides two actions + (asynchronous methods, that do not return results): incr + to increment the local integer state by one, and reset to + reset the state to zero. To query the state, we use the request + (synchronous, value-returning method) read, which simply returns + the value of the state. +
+ A Timber class consists of +
- Declaration and initialization of local state variables; +
- Declarations of methods, i.e. actions and requests, that + access and update the state. +
- Possibly local, auxiliary, definitions. +
- Specification of a result, which typically is one or more + interfaces that the class implements. +
+Here is a counter class: +
```
+counter initVal = class
+                    val := initVal
+
+                    incr = action
+                             val := val + 1
+
+                    reset = action
+                             val := 0
+
+                    read = request
+                             result val
+
+                    result Counter {..}
+
```
+
+ The class itself starts with the keyword class. We see + the initialization of the state variable val to initVal, + the three method declaration and finally the result specification; + here Counter {..} means: assemble a value of type Counter + from definitions in scope. +
+ Note that there is no constructor method within the class. Within + the methods of another class we may write +
```
+  c1 = new counter 0
+  c2 = new counter 10
+  
```
+ to create two counter objects, with initial value 0 and 10, respectively. +
Timber has parametric polymorphism, so the kind of generics + introduced in Java 1.5 is naturally supported. +
Timber provides powerful ways to define new + value-oriented data types and functions on these, without attempts to + force this into an (often ill-suited) object paradigm. A consequence is + that Timber classes have no static variables or methods; such entities + are naturally defined as values and functions outside classes. +
+ All types in Timber are first-class, which makes it possible to use classes + and methods as parameters to functions, as function values, as elements in + data structures etc leading to new programming patterns. counter above + is a simple example of this: it has type +
```
+counter :: Int -> Class Counter
+
```
+ i.e., it is a function that when applied to a integer (the start value) returns a + class, from which we later can create objects. +
Timber has subtyping between struct types and inclusion polymorphism + but does not support inheritance. Since classes and methods are first-class types + in Timber it is often possible to find other ways to express most useful occurrences of + inheritance. +
+ Methods always execute with exclusive access to the state of objects; thus + they can execute concurrently, leading to a very simple concurrency model for + Timber. + +

+ addfile ./web/lex.html hunk ./web/lex.html 1 + +Lexical structure + + + +

Lexical structure

Comments

+A Timber program may contain two kinds of comments: +

A line comment starts with the lexeme -- and extends to the next newline. +
A general comment starts with {- and extends to the first matching +-}. This allows for nested general comments; a closing -} matches only +one opening {-.

Names

+A Timber program consists mainly of definitions that give meaning to names. There are six +separate namespaces in Timber: +

variables, selectors and constructors, which all denote + different kinds of values. +
type constructors and type variables, which denote types.
module names, which refer to modules. +

+Names are simple or qualified; the latter are used to disambiguate names defined in different modules. +

Simple names

+Simple names come in two lexically distinct forms, identifiers and operators. +

+An identifier consists of a letter followed by zero or more letters, digits, single quotes and underscores. +The initial letter must be upper case for constructors, type constructors and +module names, and must be lower case for variables, selectors and type variables. The following lexically correct +identifiers are keywords of the language and may not be used as names: +

+
+action    after     before    case      class
+data      do        default   else      elsif
+forall    if        import    in        instance  
+let       module    new       of        private
+request   result    struct    then      type      
+typeclass use       where     while  
+
+

An operator is a sequence of one or more symbol characters. +The symbol characters are defined by enumeration: :!#$%&*+\<=>?@\^|-~. +An operator starting with : is a constructor; otherwise it is a variable. Only +variables and constructors have operator forms; the other four namespaces contain only +identifiers. The following lexically correct operators are keywords and may not be used +as names: +

+.    ..   ::   :=   =    \    \\   |    <-   ->   --
+

+An identifier may be used as an operator by enclosing it in backquotes; `elem` is an operator. +Conversely, an operator may be used as an identifier by enclosing it in parentheses; (+) is an identifier. + +

Examples: + + + + + + + + + +
Names + Possible namespaces +
Color, T3, T_3, T_3' constructors, type constructors, module names
x, env, myTable, a', x_1 variables, selectors, type variables
+, #=#, @@ variables
:, :++: constructors
#3 ILLEGAL; mixture of operator and identifier symbols.
+

Names +	Possible namespaces +
`Color, T3, T_3, T_3'`	constructors, type constructors, module names
`x, env, myTable, a', x_1`	variables, selectors, type variables
`+, #=#, @@`	variables
`:, :++:`	constructors
`#3`	ILLEGAL; mixture of operator and identifier symbols.

Precedence and associativity

+The precedence and associativity of operators are determined by their syntax. The operators in the following table +are listed in decreasing precedence, i.e. an operator that appears in a later row binds less tightly. Function application, +denoted by juxtaposition, binds tighter than all operators. + + + + + + + + + + + + + + + +
Operators + Associativity +
@ Right
^ Right
* / `div` `mod` Left
+ - Left
: ++ Right
== /= < > <= >= None
&& Right
|| Right
>> >>= Left
$ Right
+For an operator that is not listed in the above table, the precedence is determined by +first deleting all characters except +-*/<>. If what remains is +

Operators +	Associativity +
`@`	Right
`^`	Right
* / `div` `mod`	Left
`+ -`	Left
`: ++`	Right
`== /= < > <= >=`	None
`&&`	Right
`\|\|`	Right
`>> >>=`	Left
`$`	Right

a non-empty +sequence of + and - characters, the associativity and precedence of the operator are the same as +those of + and -.
a non-empty sequence of * and / characters, the associativity and precedence of the operator are the same as +those of * and /.
a non-empty sequence < and > characters, the associativity and precedence of the operator are the same as +those of < and >.
something else, the associativity and precedence of the operator are the same as those of @.

+The operators in the table above are defined in the Prelude, but can be redefined in user modules, except for the following +three exceptions: +

: is the list construction operator and is supported by special syntax; +the notation [a, b, c] is syntactic sugar for the list a : b : c : []. +
+ In harmony with this, the empty list has the (lexically illegal) name []. +
The operators && and ||, denoting logical and and or, respectively, are predefined in the language +and are non-strict in their right operand. +
+ This means that, if evaluation of a in +a && b gives False as result, the result of the complete expression is False and +b is +not evaluated (and, in particular, a runtime error or non-termination that would occur during evaluation of b is avoided). +
+Similarly, if the left operand to || evaluates to True, the result of the complete expression is +True without evaluating the right operand. +
+Thus, semantically speaking, && and || are not operators at all but special expression-forming constructs.

Qualified names

+Timber modules are used to manage namespaces. In this mechanism, simple names are extended to qualified forms, where the +simple name is prefixed by the name of the module where it is defined. To allow several modules with the same name in a system, +module names themselves may be qualified. +

A qualified module name is a sequence of simple module names interspersed with periods, such as +Data.Functional.List. The module name (given in the module header) is here just List, but the full name must be used by +importing clients and is also used by the Timber installation to store and retrieve modules in the file system. Exactly how this is done is +installation-dependent. +

+Imagine a module Dictionary, which defines among others the names insert and |->. An importing module may +refer to these names using the qualified forms Dictionary.insert and Dictionary.|-> in order to avoid possible name conflicts. See the modules page for more information on import and use of other modules.The simple name that is the suffix of a qualified name decides if the +name is an operator or an identifier and if it is a constructor or not. +

+A qualified name may not be used at a defining occurrence, only when a name is used. (The module prefix is uniquely determined by +the module name, hence superfluous in the definition.) + addfile ./web/limplans.html hunk ./web/limplans.html 1 + + +Limitations and future plans + + + + +

Current limitations

+Compiler error messages, especially those resulting from type errors, are far from satisfactory. +
+Recursive typeclass instances are naively generated, sometimes resulting in extensive work +duplication. +
+Garbage collection of objects with a state including arrays is sensitive to an (unlikely) +race condition that may cause state updates to be forgotten. +
+The abort will sometimes fail to abort a message that has been scheduled to +start but yet not been received. +
+Deadlock detection is currently not implemented. +

Plans for the next release (Jan 2009)

+Fix the abort and deadlock detection deficiencies. +
+Add multidimensional flat arrays to the compiler back-end language, which will +improve the efficiency of array operations in general (and also solve the garbage collection +problem mentioned above). +
+Merge the Timber +supercompiler +into the main branch of the implementation, thereby adressing +the generated code quality of recursive terms overall, including recursively defined instances. +
+Make a substantial overhaul of the error reporting infrastructure of the compiler. +
+Add a GUI interface to the POSIX run-time environment. +
+Provide a proof-of-concept run-time environment for a bare-metal target platform: the ARM7. +

Longer term plans

+Add exception handling to the language. +
+Extend the type system with support for functional dependencies. +
+Turn subtyping coercions into simple casts along the left branch of every subtype hierarchy. +
+Extend the syntax to allow explicit self parameters, explicit state types and explicit +overloading witnesses. +
+Implement a generic OpenGL interface. +
+Add support for more bare-metal target platforms. +

+ addfile ./web/logo.eps hunk ./web/logo.eps 1 +%!PS-Adobe-2.0 EPSF-2.0 + +%%BoundingBox: 0 0 173 78 + +% Timber logo + +% To get another color as background (exterior to the clock): +% Uncomment lines 24-37 and edit line 27 (0 0 0 gives black, 1 0 0 red, 0 1 0 green etc). + +% To get the timber-lang.org URL in the lower right corner: +% Uncomment lines 122-131. + +/wood { + + dup 20 sub 0.5 mul setlinewidth + + dup 5 ge + {20 sub dup mul 500 div 1 exch sub} + {0.1 mul 0.4 add} ifelse + + dup dup 0.8 mul exch 0.5 mul setrgbcolor +} def + +%0 0 173 78 rectclip +2 setlinecap +gsave + +%% Painting the background (exterior to the clock) +% +%0 0 0 setrgbcolor +%30 65 moveto currentpoint translate +%2.23 1 scale +%-63 0 moveto +%0 0 63 180 90 arc +%100 63 lineto +%100 -100 lineto +%-63 -100 lineto +%closepath fill +% +%grestore +%gsave + +% Shading of clock + +30 65 moveto currentpoint translate +2.23 1 scale +0 0 63 0 360 arc +clip + +<< + /ShadingType 3 + /ColorSpace /DeviceRGB + /Coords [0 0 0 0 0 63] + /Domain [0 1] + /Function + << + /FunctionType 2 + /Domain [0 1] + /C0 [1 1 1] + /C1 [0.6 0.65 1] + /N 4 + >> +>> + +shfill +grestore +gsave + +% Clock radii and circumference + +30 65 moveto currentpoint translate +0.5 setgray +1 setlinewidth +2.23 1 scale +0 1 11 { + 0 0 moveto + 30 mul 0 0 63 4 3 roll dup 30 add arc +} for +stroke + +grestore +gsave + +% Grey border in left/top border + +0.4 setlinewidth +0.5 setgray +0.2 3.5 moveto 0.2 79.8 lineto 166.3 79.8 lineto stroke + +% Arrows + +30 65 moveto currentpoint translate +0 1 20 { + dup 20 sub 0.5 mul setlinewidth + 0.04 mul 0.2 add dup dup setrgbcolor + + 0 0 moveto + 0 -44 lineto 3 -44 lineto 0 -49 lineto -3 -44 lineto 0 -44 lineto + stroke + + 0 0 moveto + 120 0 lineto 120 3 lineto 125 0 lineto 120 -3 lineto 120 0 lineto + stroke +} for + + % Arrowhead white centers + +0 setlinewidth +1 setgray + +120 0 moveto +120 3 lineto 125 0 lineto 120 -3 lineto closepath +fill + +0 -44 moveto +3 -44 lineto 0 -49 lineto -3 -44 lineto closepath +fill + +grestore +gsave + +%% URL in lower right corner +% +%0.5 setgray +%/Courier findfont +%6 scalefont setfont +%103 2 moveto +%(www.timber-lang.org) show +% +%grestore +%gsave + +% Finally, the word TIMBER + +% T + +0 20 moveto currentpoint translate +0 1 20 { + wood + 15 45 moveto 45 45 lineto stroke + 30 15 moveto 30 45 lineto stroke +} for + +grestore + +% Scale to make remaining letters smaller + +-5 6 translate +0.8 0.8 scale + +gsave + +% I + +60 20 moveto currentpoint translate +0 1 20 { + wood + 0 15 moveto 0 40 lineto stroke +} for + +grestore +gsave + +% M + +75 20 moveto currentpoint translate +0 1 20 { + wood + 0 15 moveto 0 40 lineto 0.1 40 lineto 10 27 lineto 19.9 40 lineto 20 40 lineto 20 15 lineto stroke +} for + +grestore +gsave + +% B + +110 20 moveto currentpoint translate +0 1 20 { + wood + 0 15 moveto 0 40 lineto 8 40 lineto + 8 34 6 90 270 arcn 0 28 lineto + 8 28 lineto + 8 21.5 6.5 90 270 arcn 0 15 lineto + stroke +} for + +grestore +gsave + +% E + +139 20 moveto currentpoint translate +0 1 20 { + wood + 13 15 moveto 0 15 lineto 0 40 lineto + 13 40 lineto + 0 28 moveto 12 28 lineto + stroke +} for + +grestore +gsave + +% R + +167 20 moveto currentpoint translate +0 1 20 { + wood + 0 15 moveto 0 40 lineto 8 40 lineto + 8 33.5 6.5 90 270 arcn 0 27 lineto + 8 27 lineto + 15 16 lineto + stroke +} for + +showpage addfile ./web/logo.gif binary ./web/logo.gif oldhex * newhex *4749463839615a019c00f700003636363838383e3e414343434c4c4c4d4f5b52535b5353535758 *5b5b5b5b616161686c866b6b6b6e59366f7286735c39735e4073624a7460457474747566557760 *3f78726a797b877a664b7a76707b623d7b63427b6c667b6d597c7c7c7d694b7d6a507f79747f80 *87806640806c508075798080808084a182838a8374698389b484725584735c848693856a42857e *8e85889c867d81868aa2877d7c878889888293898ca3898dab8a6e448a87a38a8a8a8a8fb18b8c *928b8d9b8b90ab8b91b38c7c668d71468d80768d92bb8e90a38f72488f95c48f96c8908e8a9091 *b89198cc92826c92867a928b93928ea79292929294a3929ad49375499385759393999397b3949d *db959fe196784b9698a3969abb96a0e597897697a1ea989cc398a3ec997a4c9990939aa3e29aa5 *f39b8d7a9b9ca29b9cac9ba1d09ba3dc9ba6f99d9d9d9e9eb29e9ebd9ea2c29ea8ee9eaafe9f7f *509f804f9fa0a39fa2bc9fa8e2a07f4fa07f50a09aa5a19484a1a9e8a1abf2a1adfea29b93a2a2 *a3a38251a3a4b3a3a7d5a3abe1a4a8c5a4aadba5b1fea69b8ca6a4aba6b0f5a7a8afa7a8b3a886 *53a9acd5aab1e1aab5feababababadc9abb1daabb2ecabb4f2ac8955acacb4acacbcada498aeb0 *d6aeb8feaf8c58b08c57b0b5dbb28e58b2acacb2b2b2b2bcfeb3b4bab3b4c7b3b5d6b3b8e4b4aa *9eb4bbf2b6915ab6c0ffb7bbdbb9945cb9bcccbab2a6bab3acbabde3bbbbbbbbbcd5bbc3febcc2 *eebcc2f3be985ebeb8b1bec2ddbfbdc0c0c7fec1bcc1c2c2d6c2c6e6c2c8f3c39c61c3c5dbc3ca *fec4bdb5c6c6c6c6c6c9c89f63c8c6d4c8cefec9cbe4caccdacacef1cbcbcbcca366ccc5bccccb *d5ccd2fecec9c4ced1eed0a667d0ced6d0d6fed1d3e6d1d5f1d2cdc9d3d3d3d3d3dad4a969d4d9 *fed5d9f3d7d8e0d8ac6cd8d5d4d9d6dcd9ddfedbdbdbdbdceddcdce2ddb06edddff2dde1fedee0 *f3e0dcd7e1e5fee2b571e2e2e2e2e4f3e4e1dde5e5e9e5e9fee6b872e7e8e8e8e6e4eaecfeebeb *ebececf3edbd76eef0fef0c077f0eff0f3f4fef5c379f5f5f6f6f8fef8c67bfcca7efecb80fefe *fe21f90404000000002c000000005a019c000008ff009ff41948b0a0c183039f9858684207c287 *1009aa6168424dc48b0775501488b1a3c78f7dca3cd14871a18e271641aa5cd9474e4b39306196 *9949b3a6cd9b3873eacc99a5a7cf9e50820a1d4ab4685022489326b5c1b4a9d3a6302822fb47b5 *2ad53e56b36add4a351d49134fe4711dcb351dc57464d35a95a7d0245ab570e3c2d557cd535b86 *3a1c21132bb76fd57dfff609c647b8b0e1c3880dd75bccb85ebcc79023476e47b9f2b9cb983393 *dbccd99b67cfd8428b161d2d1ab3d3a85113f3c5ba356b58b063c33ef5a9b6ed4f983035dabd9b *10a13dc0dfbcb9c1f00957ac7eb7ea9bc8b05a72ad6619be7d5eb51a4535faa86b27fbcd15738a *7d804dffdf1e57f03ec28313ab57dfd8b163c9f0e355b69cb93ee7fbe43e831e4dda34ea2aaab9 *26a06cb2dd565b6ebcf5f61b707b08670545df6c851c7954b9429127e445b7d078cf7942912b14 *86988e2ddf31548678215267de79ebb598587bf1c5371f7df59d835f679ff1d75f69a80160c026 *cc10b39a80af11389b81b8e9c69b6f0b36285c0b0c4d689594145ac71076da696802877d2d4791 *73293e970e307d9454912b1186b9dd8ae9b9d8627b8cc528d98c94d568e38df9e9e78d8ed894e6 *1f33010c108003bb0c49a42f461e69a0924b36199c11146597159514b285579ac969c9655cdf7c *15969a72c9834c99253d812660a086785e9b6ebe09a79c90d1ff69276678eac767683c9e160001 *040c204015860e9828924926c824830d8e4111305a511aa223cb8a79d673c050e448aa6989eac8 *570b3de1493592624b219bacb68ad8abb04e26ebac37ea79ab9fa6ed9ac001821a00c9a188264a *dba28c36722c836fd8505cb3e222035ea6d37649ea4253899b155d9e70db9023e03a9ca2608105 *669eb9ebc1f95ebaf2cd38eb65edbaaba39fba12a0800209f43aa82c44260a0b92081aeb1bc06f *4441115f55399ba257c5f10c97a67db173970e9baa09f15d26e925b4c56a92cb22c72f7a0c329d *edb05bb2ad7cf2b8ab021330306faf02fc20ac91fbde56b382c8261bad553a609aaa3e0b9b00e6 *d009c365e5427d84ff9b6a7725f21dcc3b50174ed58a54770c63ba5867ad357e5c771dafca1378 *3001cbf40660af6bfaa66d5bbffede1c5cc0576675259ad85ac81086784b1797870c81f8b77766 *8697b4e1d80236d8d48917862ec8218b5c63ad26f307efd7132c1436cb2e3b0073be049ee2f981 *fdfeebe41191c25d3b8a61ee5d91df65e53d9697cda93966dd0ba9813aeeec6b4c6eefe73616cf *c772caeab87d5bef2739f227e960b9d80720db0f6e21b3e9e5a67aa273d217be34a57f006e7b4f *a38ea54c22b7ad108d3b9e8ae073e4412633a9af82ed0ba1c6e05735f95d6d5d76cadf9e24170d *fea9410d0ab11ce604558041e88b58a04ba070d28082d535b02a4b2b495efff6421e6831845963 *b92057aac5906b6d475b12f356c5444845f7bd8f84f88011fdea273cfc112f47272b8d0b1dd107 *356864792d1394034a81369a21b049c2214eb77ea81588492c2f534c8ec1a204beaa28f161756b *5872e8b2ad527dab8f554ce4c6b0e8bbc531ae8b295461185b48391da8c1139e70040cfd17b6b1 *f96a07d1a359824207c737408a21741c0b140d99c7b800ad5b1afca31f8f763bae04912243d460 *2215b9b17225ee778f84a46624b9bf4a5e1218aef044196378b979d1d086b0981ef56c56ca07b9 *ee2a7dd156031ec0cd6e7af39be00ca738c749ce729ab3010148a73ad7c9ce76baf39df08ca73c *e749cf7adaf39ef8cca73e5de8ff0960200318992ce31919c03c412d808dd15cd428ad271c6531 *44903e4bcb03e0e0878a5af4a218cda84637cad18e7ab4a3707800af464ad2929af4a4284da94a *57cad296baf4a5308da94c673a52b059b29fdfa8063292a9c991fccf930250c1ccdc68339cbda1 *870b61dd3f224a9607f821159388aa54a74ad5aa5af5aa58cdaa56af9a0a3f3c6065600dab58c7 *4ad6b29af5ac684dab5ad7cad6b6baf5ad700deb046e0a8c6fa4e31bff4ce6324d20436706a000 *6810253591f586a8f0ad67cf71ea24c0f0d1c63af6b190ad281826e1d50958f6b298cdac6637cb *d9ce7af6b3a00dad68474bdad29af6b498a5eb37e4a18f74e814a06434a309d0e8b205ff48426d *6fc4991c2b82d8e428f6a9a908ae70874bdce21af7b8c84dae7289eb07ca3e4007d08dae74a74b *ddea5af7bad8cdae76b7cbddee7af7bbe00def748ff90d49c923a73bcde4267f1a405fa9e073b9 *1ddd10f0d25bbffc3615c978867ef7cbdffefaf7bf000eb08007acdf6474d5b92f4cb08217cce0 *063bf8c1108eb084274ce10a5bf8c218ce3083fb80d370b516afc854260cf9dacccc01f6808305 *d8291752dfbedcf719e888b18c674ce31adbf8c638ceb18e63fc8c037b1593400eb290874ce422 *1bf9c8484eb29297cce4263bf9c9502e725dc1d7dad70654b6b435a82416aac33728217b4b4d6c *739f0a637a98f9cc684eb39ad7cce636bbf9ffcde8e8f1981f008c3adbf9ce78ceb39ef7cce73e *fbf9cf800eb4a0074de8421b5acfc828ef56ceab539eaeb793ed0d2a9771a63386488aa9637931 *3ae8910f7e78fad3a00eb5a8474dea529b7ad4f9a0479c7dfc806fb8fad5b08eb5ac674deb5adb *fad6b8ceb5ae77cdeb5efbfad7b546e43f3e9c57113373867fb582824a59e985f0c54cd086b6a6 *e9c18f7e58fbdad8ceb6b6b7cded6e7b7bdbfc50b59c9dab8f729bfbdce84eb7bad7cdee76bbfb *ddf08eb7bce74def7adb9bddd972ed3faf3cd08206e0001e887649de22f0829b60dad5feb6c2b5 *ed0f7f2cfce1d70ef7aae77cef8a5bfce218cfb8c637eeee7c5b39b6fd4ee3bf036ef02d61d3b7 *63ff4e45993b7dea968bdada2e8ff9a7533d71e702fbe638cfb9ce77cef39edf5ad8c40ef15efb *6a62655bcf49cd36015f30cd9569bff9e96aee34cc530df5aa9bb9e65e3db4d6b7cef5ae7bfdeb *60e773a211c9e8f4f6949300249b0a528c7430337d2b9adeb1dc694c6d98ab7aee78c7fa03a2cc *f7befbfdef800fbce08d3ce587e91bb6029d2d41456edbf83ae9cb963eb97d539e5f025b7ebfd7 *d874c2257e8dcb7bdec073d6b0e8474ffad29bfef4a86f30870b4f95a0eb75c444a7211ad6b66c *9cadd8042d96cb7d97cbfbe1cea2cc9b17f72c7a4f7c568bf7f8c84fbef297cffce65797bce645 *afa37d0a69b57f8ecba59caf49721f17c53236b21f55b9ffe6ed3e71f07b74b29545adfad7cffe *f6bbfffdf0cfac6a597b787e2bdedfb685afe3e3583ac9bbf8a95b158053c558e25777fd207172 *36590228805df55571f58010188112388114588172a55a77556c435762b247548d524a86650213 *f2765a3151e6d751514566e37780e276609475821b1552343583345883367883389883246553e4 *d568ea457d69e75e43a5504585334865024a458254a14de6d484dea40129077ce4376e7ea0014e *7885e8b44f5ab8855cd8855ef88560984ec6d44ffb0672f7c778086540fbf7060ec530dc5747d5 *5048b874487ef14a60910e083785ac960eb4e417fa800c72881774b84b846815bdc448f5904526 *144cc2344c90ff1339a32146632874b0c7817f054dd2447ba48433d6b4216f386c75c134134344 *cfb1477c931d79c8827a376c81244180184583588821842a88c3488a18278b013c8de888380289 *b822893c884967c75e64034ab29189d84758b7974afbd01da2e810a4a81d46b41048f40fa98880 *ac56154cb4104e9425a3e241eb238becb348b648188ec48834c28bf7513cc643493c6886591600 *07d546fcc276fc374788f54025613b2132410d2137d7d8827366159d123422d24125a13eb5248e *aab248bc4342e7082bbb48325fb44293e44295886c3554401eb889a373543e54151273260be917 *df701de01390ab68155ed2001af09230199331d9005ce19232299314ff001edc03178570933249 *935b61933e399431b9012b4006bf206c5c81316440944ef99432f900d0101f24009544b9011f00 *047d500cbef88bee38574008546623333884406df3065dc04055713a201422aa93547017852b88 *8d03a9159ea00193b05c93a0015c8197c8350923c007a22882d1b815cd300279795c7bd9978959 *7ca9600aa6b05845a0014bc00d7db10f5c00068e597c9ce00253091f24a0089b195c91e9075230 *02206008b7d227930336cab378cdf33c9d23581f8833d8137922a968d842376a598272698074e9 *5c7d990a520006c6799cc82905a9c0975ba101c4899cc789057ea0081bc05aa128444e9315f2b0 *018ae00758009dc6a99cccffa915ce599ce0799ed0f99d7e009960e00240000f7001185c2059e8 *599ff6799c52600a9e49958b759ff6e9079a900a8a10041b500993f495b1a739f7d21ab3598fb5 *393a02933e93e23076f804b7a39254f800c309069c705c9ca099e39915cec9a1c5f5a11fba022c *19877744872bc0a1244a5c1fba9c1bdaa1c507999ca00860800593600a60b001bf9016e6319fcd *359ac9c5a3faf9999241028b15a08e690a9c405960500702ea0229e00c91e83594138465e31a04 *744344f8a04e92066ff38914628a22a894d6f89bc1b792e4990a9a990cd710a7726a6020baa1f8 *25a771ca0b9c8005c489078bf68a25d101ca89059cc00b787a0d742aa3cde9a677ff7aa88e7aa8 *cf900cbc900a9ce09d4fea02854016415a519300a78ffaa9a01aa7cf300b6070a4fcc9a19e1aaa *909a0cc2c00b91c9583cba01bdd01f29b33222e73c31e3a56a334aa143693b33a1a9328d26508d *99a6a67a58976daa9999e70eccea0ee8700d8c1aa25631a2a9b0acccfaacbc80a3faa90c64210f *c1d0073a60012ec0a38a60a8e8d0accf1aad766aadcddaaeee7aade8200e883a0b1fba9e38e0a7 *5ad14b42daa9e2f0aefefaafed8a0edb40aaa60a1f20b0589c900ce70ab0fe1aafdbf00caeea9d *a65007b2ca9afe212f99b339f8428fb865963813a16041306ae28f710317189a8d8baaacee900f *2c9b0fee00ad759ab2d5bab22c2b90d3ffb901f09916f0a001dda9829cc6b22fabae327b0d34db *b2467bb4464b0fce8aa8a6e007a58a03a49015bab3a9cda5b0f680b4589bb52d4b0f035baafb69 *b008abb05aabb557b70dc9300b08eb071ba00bb90228bce22bc0b2b1ba4a3d8ee7364724b229e2 *3d5862b2c6aa8a19baae2b6b6d2e0bb38a9aac339b0f824b0fe2900c3cfaa124a01624e0a2a690 *0ce2c069821bb4316bb8448bb8107780a9e60e66db5560a0091b609987a33b85b1af569b709d8b *6da9d6b5059ba4618b0e9c0b71fc50b3d8faa13c0a02ccf027813228bb1024721b3dc8688fa604 *66a9441e6f8984ff475905b8a67f3bb481db0f832bb49a1bb80ef7bac9b0a7c4490664410683ff *9ab0db60b9d98bb9cb191eec20a28cbab9fde0709d7bbb8a0b7a94f501f88031e4a2bae8600fed *dbbaaecbb504fbb59271b0a84abbfbfbbe34770dbc90099a290561f0273e020941122c9c33b7d3 *04a6c2f10650725878bb1dbc593ecdebb3d08bb2d7cbb9d59bb9eaabb2b57bbb2fcb0b8ba59f3f *ba15bf30ae9365a82bcbba25bc9c78919dd4cabed43bb62dcbbaf0bbb83c9a0a41b00a863835f8 *abbf9eebc3640bbb2eb00c73d20e029cb004bcc43eccbad46b0fd88aa39ca001baf01fa921c1ac *d1a5a1d4916c333a9d68026da98449e429e93b79ce2b857e2bc2277cb8974bb81ab0293b3cbd30 *a7c5d0caa91bb00e5ab10e1bf082d59abf587cc31aff601742b4c724acb4007b665257bedbc0c2 *93b501f59b1e2c92c476c7b00c2bb0ff0bc5ea32c5629bb80c2bc9889bbd2d58079a000642901a *a721c60c4a960eda2884351c032321e461a67d2366713c9702299cd24bc2e6ab0126204855e1c8 *3097b8423cba7540027ea30f1fc0caa54ab9967b80772cb4f300a826a0ccd4fbb2a1ba0d957bb5 *7dbc6a9a8903cd6045a9cba9566b77f2aaaa9f3aaa5e2bcac123c5b3fbc8dba0aae2b069b59b6a *8bbba75d1cbc612ccbd0738c999843a594960f751cdb21acc40ac7207cacc23cc2d90ca2dc58c7 *3cdccf5cbbbd0b3c05563105ca89aae3dbcf155db855e1adde5cbdc8c50bc9b00d889cb895dc9d *75b004e4ff48189ccc82e230a9a369a44f1c2b9541ca55fcba3a6d5cb360a895dbcf415b07a620 *057730d0c3cbb1f065bcbba50363c1c66b71346da97b7d1b9c5e05b8c48cc7064915298dd4083c *0958600a3860c4ffb00a38600a3a4ac3fdfcd5d68bd1d35bc2e8e90785cac3fca0c51ccd0998bc *2a8671d3e196d34eeb9fe7999f3d5dcff63cc0f83c0b850d9e759097d6fcc8393d0976e0072ce0 *d44442c6c75896c6bb4077cbd0c9a1b768cab7bf0c9cc1dcd5c35cd21a50226092d2d7bcd7cfea *d87130091b600ee650c871e007b39079f69070a926d7263cadeb5bd7983bd4c315b6475dd223c0 *0e8921d88acb0b784da49d49cff301d48dad99c655afe2f7db82ff8b0e8c7bd61a400c0172281c *499bb63c3a3f405f559d1ccbab54db71b2c84ad7c22da3b0b3102002dbde4dbdf1eba6f3fb01cd *f5a6cb7d80f670cd8aecd525ed0232e902788dc2304db038400dcfcdcef9ebced26dd656e9930f *00c57482dd0ffeb437999f6050ae239db884eb02ad10cb04dda0b8f5d963aacb72413e0b7137e4 *21df134ddfac4d157a9bd2ccaad1ffac9958c0a7a83ae0df6cdc788ce0df8cc777e10116a001ad *4cc59c1b6e958cd752f00b135eb5158ed3172e05ac608e11192358e3e1fcedc4b9a01fce200441 *e0a6a60063f8cc0b75c00941f008b1fcd49dfda5cb564a206b1c64a18415aa4bbe1cd1733cdfc4 *ede0496ebdfec8e344ffeeb295bc58c135c3dbc0c7fe6ce4733de8765ce8753a0fd7190114aec4 *52bee55d8e18d04dd893c0e5c0543f8a4d1962febaff5be6b6f20138daa955dce954fe074242e7 *b171d075fb06694ce330ae16c1602da062e3aa4dd1966ed2ff60443c7e0d032edbd7e0d8c6c9db *be0ddc8a9bd1c58ce4076e15e950c8609009a5cc8253ce09557ee5b0cee9d1dd5ca4fee5602e2b *a9eebf5ecbea1629049b6e77533eea6b20bce64dc1c562c14fd27f7b0e170e9d2ac2aea1ab5dec *d2fa0fd592ecd19eb8e5578051eec7d47ee403afc82430f113bf019aa999cf50d75cebe6a61004 *cd20eeedace5e6be01145ff2267ff27c70ea97b1ee64ae3fd3a0ed502eefd2ff0dee7f802f057d *eb3493efb5373ab7e7e764ba84588d2d016fedd5ae15df90ec702ded423cb9cb3eb8709de3118f *b9684b5590f9d6255eec2e8004a0600d89b8ce584eee84ad094fba805105065380352b7fcf1fae *9f94900b6eff0aa10002215de9aafeb48f60eb8a52cb1ea9401f02174c45dae232f4510ff1c45e *bd2d7dcd63ce0bbc70f5636e600f3fe9c95cdcc27d9edf3909e6dacfe0edd6a6a001247726da80 *0fa12edddf69d8c84959673f1f99c1f2041b042ed0faad8f03406ef9577fc3288ef70965e7bd0a *300d12827aae1611f5de1623f8855ff4c30fad4c1fdb0effd2fc2dc4744ffc385ee89c10fdd21f *fda6900ae66ae01bff822c403b81ff1aef5a3efde01ffed3dfb3a75f27a9aff6634eaa9c0099ec *0f9938aa08bd5dc5d40bde00bd01b67fd0c9383a90b71059bdc14004106a4c0c3451eddf418409 *152e64c8f0819f497e523d43478f5fbf7efce8a17b960aa29f070d35a40293ea9abb7c18f3b9bb *46329506912e4fa6ecb7b2a5c46b152fd6dc5891a64674374da254c9d2254c86234bce2c7a2dd9 *53a8509f5d13e71323bf7c41499a0a420b1fbe78d640511918c10fc464e8ec5da5272eea5bb851 *7945f433a5dddd7379f582980486535a9af9e86d9be507cc61c460eaf8e1c48b22bdc08379293a *9bc2d765ccbe606de60cebd427d0a141636a54ba3421d47b54bf79d385a0094f0d19f659ff184e *07c127f264efe6bdf061c4893ad972f41831645299446b1a2d8974a1d2a181994fe23573a760c8 *576dce5daadce6d198dd23a3235fde3c3a779053fae3b98dbba60df3becec7376f198bb393d2ae *cdd8f3fcffffdca2cbae76f432902fbf005349b2591a74b0415e784926a7ec54d20a0caefec8ec *b2ce3afc4cb44f3021cd34d408516db5345ac0adb784684b0898d71cc187451a77fb4da2c77602 *aaa38f8e7b2e39e95a6a2ebce89a22c92f5eb6a9b0269adae38593c38a5c4ec89788648ac97cb2 *d4724b2d315ad02d533094a210facae422bffdb4e3724d36374a664003e344f02f7422dbe64e3c *f3bc13bdecd813ccbdbee0db10b30e37fb5034ff114d6ba44413577b6388d774abd1c57ff071e4 *35606ad4b4a11b83b368381e8db3d23be6aa444e3c2331c43019712ae4e7bab69209334c29bf1b *f2d422d9f372575e77c5aa2d1e218aaf4cface444bad7e74ed75595fed41e7cdb3ec8a73afbee8 *8c8c1e6cb3d5165b7bf2d98927b7b692a289410b3514c410472431b513dfb0e235643675519e27 *08d2219c4df355a8d31c412d0ea45183040fd72b6d2d0c47abbc148cb8b3664175ca817f445559 *66fdb15861c1c4e1d1af0dba21763e63f543966266997516dabaa6cd8b9c3915cc884d2ebf5d30 *a88327d940960dcd3d1444754f63770fd6be88315fdaaa794d8d79f455fa207e85eb8f61510926 *954affe71482aee052a154a4ba3a75ccea9ac9fc023255532596122b98b594f9d77021aa63858f *bf0a39cd97d34efb64385566b95a0549ee95e45f839a0b0b53705823b35bccf50cdd7415fd19e8 *375224480d7dfb00e5b5d8965ebae94f9f0e1560a905bed56caca99422152ca853d2cec15339fd *615bcbb67a6c9eb6b55dbd8bfc8c95132c52c10198b8e746b6bfdb8bd7f6d9bc572667f9bd13ac *33d99279459b1e77346e5d8a10caf590f110155df467d6deb0c15e4937bd8d208334dffc234f75 *dce8731f6787bdd4aa13ba7a6a974650d51456d58b7556308c8076b1ab1f42ee271d3d25b02af4 *e896c2583299b3c0ed63c2e38f46c491400ceac929c953defff25af63c2ca5ed2af6688b5352a1 *88de810104382394e27696ae9e7def4490831441bea134dc944f7dfae29cfba0063ad2e16f74f2 *ab15fd1e42194fbdcf2394d9c001c956c08338714abc78d08322948c6d248c1f27a3d508c241ac *7a50902de2a06215cd7846ba744015d33807f398f7c1f100482db0da86304c6118d46120169849 *9c0bd195a87581ef0d4780d7d20622a31d6aae87feea51c09ee8488835c70223d0da2c72423345 *f86504d490220121f91dc324e6307e508429b8660f58810d2258b0047deaf14a31f6878c991465 *2d6d7996080c44078658e31bf906c23fc56575dad14a8ff6d8429dfdd17b8c6a97bb5ee30acd99 *2053895424fbfaffe5b97fc5cf7e03a4df27e9078c0ee00075aa0354ef7060897f74b29ba1239b *29dcf94e4e18863a57b2e09bc0e00716cca71ef880259a8667415e90f29d032568413dd281f311 *84077f78c5077ec93a4e4434a2fc6b5564c0549220908b433a7b61f79629c82d604e7d94a36635 *8173cd1d65d39b545b2978c2110155fd2519500a1310a2c84d962e641feaa4120e5cf0d39f0641 *22096ad5759e650ac26de02baf646a2c010a11300055aa53a5aa0b98400e67a8c20c28780d041e *ba20c224060b38e91a58dfa3815168c68f3cf3def71a05b92e707520945a1a5d4b9aaf4562b391 *ec8ca4ecb639bf9ca6a3026e4b452aea10910ddce3a6808d1842f6b153ff9c1e851b93ad46357e *b1013068c20f96ac1001d5c1d47ac4231e53f06705db12d04948810fcb606d6b5dcbda610c2317 *b3cd8534dc488e6284a20c26f0aaf3ece4b0544c621224519dab9cd591c382a1038a8305e30019 *c866c6952076551a75ef5aa3bca674af41149d5f0d18d9d17143039ab8a761e0c38def32f656fb *38c86321abde97102b1c1b40aa299ee11d7a08c9142e0807685f49da6399968c10914227ee72e0 *02a94c2fb7659e37bc810d0c7cb53d0edbaf04a430abb4742e633335a7190ac5bde7faecad4193 *ab0948ba43eb5e9745d955e2768958bac6feb588393d0829c4890573a233bd333e0a7bddfb587c *f0f4281ffb004d5d26986b50ffd805d678a568450b60910918b5053eb0823bc8600767d91b7004 *ab9243b101ca6cf64a5354441c6c568ace7434c4eb6ae6174a7c6214ab9887d6749a76a3c6dd47 *f2d5930959c2e95c17011ddc70b13c6ece8fdd1b64f0c6b74cf3a02fe1ee1b19fdbaa01b4e7632 *94e9f6d4d41a38c10a667083b5ec602e4f18432e0881095c80d44c60d1556e2209945260a88e36 *2e90237e839b27a78f92a658ce36a273e7ec0cc4170bd1bb8386f110ffa18f0f9ce5011e18c834 *855ce8af00f92bcf56f47cc2c1022940c9249d2dd508d841e92797768c53ee8495178ce54f3f18 *1ba1fe9392336002986a9b22a834eb2408e7022f2c4e998e2b5133b7f0e6ebea7ad7ff9ceab50f *e1d75263efb8d8defd860634d089d71802d1f0d580b4e9436d17385ce3fa1b272f8a6aa167d477 *03e00e7780c7bd4a8da75ce52b77f80372a1656cc49cdd8351f21acc60020df4656b63b6c9c1fc *b0815238b7adfd76d4155e23f0ea0e5c532cfea136152e6c28a633d15064052bfe611bdc505b03 *717b362f0afbf5c26a020b8ab02408b7883c30288204241fadb86519504e805dee73973b275cf0 *7275c77cdd126ef7a84571192a8893a8ab3eaa9862f0c79e11bd5def9aae9c91aef48430fde07a *5e279efb1a7584cc432003d13ad7c16bcb7b7262168f611d540bc1764bfff3b4a1047debc170e1 *bbeb5df6330feb7eff7e191080e1a473acff3786460088d0c4d0ad33648d1244ea78c8d348f22a *a53c8d83dd5dcc23041f97c3f9d43dcf58ba17564214fac9715de28265a0deed00cd7ef9bf3eab *d8cb5ee67ca7b9df31838a0d40a9b83ff9dabf3080095943773540ab61b307fef8e4fb87e57331 *195bb8a8d33a8530b41f339acefb189eba06088c4009dc0671488ff570129dc300b66b3b939325 *09fc4010fcc06750b25750bff5f3ad2e733fcc6882d7a1a8cefa1f8cb2002f08848fa2b537b881 *d7489f5d03c0e41bc03b7bbe3cb3bc3dfb87c76a2f43fb0a76684062e924ea7107277cc227cc16 *6f511818e48a4e00b7bbe0c028630b28ec422fec4274a83d172841f58b06da53b2dbe3100c2025 *ffb29a420ccc2c0d283513b0012fc803c5638d318081d710b4ff4b08f60a40df283846fac10284 *3a847b893ffcb1683b42252c934eb21bb5d99585b989b3c08076a034044bbd0a8244bb69bffd22 *436c8806513443f613c334d48c4518813099bf11228ee49280d7300114f00125f882d5b88212cb *8de4eb03052c42220444cef196c0993c21ac3c20bcbc7d88367cb0b825b43e071c1bbf899e97d9 *08b0e98bfdc205d142b003d344e891c692e9bb4f0cc55164066638c351bb848dda8c19b8b055d1 *89c0011bb1f31d1b38831f28b18140811be83f13e04114ebc51f73ac3f9433ced996a63bc4039c *ba648c9b66a4b8eb93126ff412ac2021ebb137d72103ff27d3c6bbd0449979485e01c7311c4772 *2cc752543274ec905200b38699097ba81eb0b9a31482003d400d3750821bb04782802640ec0362 *51c465f4c7440cc85fdc94a60110627c3e2de9a65e3ca0a3a41a857c46f158ca2173cae8e0442e *c196304c86134a211238078cac324da44a48f4c48f8c8690244738d212b12cc90e618353c38254 *5392a0c04a9d330529d88021781c67ca41403c089d544869f349f732425fc42ef6498667384cc4 *3c4cac244085438f27bc10444c4a99704c2784ccad6b4a479c4c28b4cc86cc892ffc4c77200f71 *700a5eb8a39200830f1887ae34104bab40d07c4d3014c35728cb90fca0cd14c345d09914f08b92 *78866d7886ff27c1233f7081128849e27b8328381a1d0ac0bec4cc9e5c44fa004cc12442436baf *4e31bf6cfa49f7828e09f940ac2cb4bf4c46ee04c1efac36e79cb854e84e092ccfcb7425f454cf *100cc16748062a32854c2a2529608172d04695b1b4f8fc4f001dc1519b4dda14c904014101ddaf *dcdc9e48d8009d9390ac9c044e9082085002417a831f38bebde4cbf3fc98f05cc4f0044cf7fa8d *f23a0b133d517902097f548ab8a33b6dab38a76cd1b97bd10e9db656cb3e1a75a5576251ec9c3b *77e28488182b8f18013ce0ca2a533028eb5125053bf423d0b2240604d184ec43bf053d97d07002 *c18ba828a9830d78813d782bc8f90215419f0d6d911a3dd33261c6ffe87cac87082ee17a533885 *538f788084cc4c2970bdd3694f3bc553f374ce91b8d3d6cb53ff62aa3f75bdd6c382d0bb231c00 *8161a8b24debcfb3305449053dd8735272240628ed0b3c5550ce609cdceb0b2c00521ca0003400 *d3f03102e52c53334553563dcf078003148d5514858307e0bae1c2ce49d0d38bbb55f3cbd533cd *b91ecdd53e98874105d625655253e88bba64015b403073d38b292889639dd654b03b51084962c0 *0c1050841eb5bbdc8cb54f1884f81b2e30d8801c781ca0c9434c51558568ce567dd78f69800798 *577aad577ba5d706889b06603996cbd778e5d795f3d70edd57804db90630011ee8afd0122d822d *5880dd001298024f0007ffbc78d60e620287cdd88c7d806bcdd6cc00018dd58007003ea16b841a *9082e1e4003bb441e3cb217655083980579925960020000598001d50034f00866fd0077df80660 *f00435d081095000020880994d5a991dd4575287dd228860d840a9c5c4aeacd867edb406238774 *cb3b131447b22c50daf4d84141a664423c7589800d4802305d8d2f9081677ad9858859a59dd99a *bdd99cddd99efdd9a01ddaa23ddab9fddbf3645a4a0b2dea1b084a985a92ab5a67b558ac5d9ead *75b0ae8db95124cbaf05db6c15dbb1652e7ddb3745418398b44142c28d7480db852803c085d7ba *c5599de5599f055aa1255aa345dad3555aa6ad5dff023763780d2a0087a9cdc2ffaae54ae0bd5a *ac7d5cae35c1c9ad5cb065064c1ddbcc602e701591c49321e2eb023d248869225d8530ddd965d5 *d4bd5bd6d5dbd7ed5bd9ddde1add277eda27f4b5dd8545dc7800877a19081a3006b653dc4765dc *c6dd5a6c28de3204c9e4555e5fc05ced71a15883de8f9a21c8799454c5ded205ada5325ff2fd98 *ee5dddbc755dbe8ddd072e5ff51d5cf64d5c44788d50b844fa3d52e16d5cadc5dfc8f55a51ecdf *4b5d5ee6552be672aefc13315345ce12d381785160862883416d601ebee008c6dbd6dd5bd8f5db *0bd6d10656df268b8724dee00d5485d7280375f8dde01de1e17ddc13d6bbc95561ff6de13e7a61 *106b2b9f39ce2e705b82f0045cc3e1ff1c4662ff72cfbffde1efa5e0211e5fc055e3da65623bbe *c876908684e2016910618b6d2312765c133ee12cd66200ce5ccd0531e11bbe664a037d5483d145 *e3862803275b583a665a23d627078e1b379e6021165f3465e0f3bde441bde33b56dc7278da8150 *853f3eb7fb1de42b2ee4fec5d443ce19cd7d5e3056bc0356821abe61499ee4a9052dd12265a6c2 *074a0080004866655e6665b659d50562f0ade0a365666a0e0000a0845126664b662a53b6e310ae *b2c2358144a0e22ab6e25896e5e4a5e5164ec7b532db1ab4412b18d381708533fe6560eee64aa6 *e304180002e8677ffe677fb65b090ee2f0355a803e680218800450e3615e5f25c66753fee6ff04 *dbb45e28312ac8863809644ffbb4fcbd62144e612d5e67b2f59053186002e637bc7c832d20e343 *5a4e7b2e5d8826b9255662a632869a4d0005c8699ddee99c7ee637fe649e0e6a054880a3955f9a *5edf998ee9889668ab9d9669208b7bec054026616f28618ef6e85044612ddee275d65ccf30e95c *d6e5a0c1c1c989e497de0d4a566a2616810138809b9d00b88e6bb9f6694f0edfb9be6b05388001 *1001b5ee6bdffde6565e993f780d507865e2c56aafdd6a755ee72e4ea6e75d3346769431c850dc *d0c1b346ebbede6075180085660066d301d00e6dd11ee868166dd3be0d0f60807d1e0075c8ec53 *0661a6aedf3f661e27268832c886db32678f3edeffad2647911ee9ede11e8f7ae7e31c037db4e1 *cba691b4be44d7dec044b8e9093081275003eaaeeeeaee036876dd3eb06eeeae970920ea004884 *e6dec0d85edcc0ce68062b8684d28162205efd8d5c744ee75a0ee076e699e146e91936eed7d081 *eb4deede2803fa1def784080b6166847f004044ff004ff69056f7047a860bd4e0001cfc6f236d2 *f39e168dce0655360155b8eadd8e6ff9fe6d76e62845163e666aa6c9deeffef6efff2e6f0ac767 *9b268004f0ec27c06e60b8711cbf7164986064c8f11cf7843e7882d4066fa346dc2cc4c2f2e6cf *0bc7708d765cabae84d7f803c4fee8de66e1dff6eae6126ed288a17e9be12fa06c5d5a7116ffef *e04df2ffae4c5ce616ad0b28f0e856034770851dff06399ff309a6f339470657787013285abdbe *00aa3d723397e20269ea256f72377adc5ab0e8633867fe55e1c5e6622c2f692d37715d5e8d2d20 *6b5df2e531af913288133f0e74c51d07ce9e710ff0de6a480779f059553f0855f7597948876a10 *e221e76cd504758cd40bd95e72573674abd6ed63806a594485fd05f1e415f111f790cd45bcb04e *69776169e9d6f44de7f456b6da234df23f806ee9c6ee1daf67d9f859640072ef06ef3f48f2bcf0 *635de7345e3f742b7eef501c6c82a884e345de599e6f44765e492ff1653f4ee4acde8150033e8c *f64de9f47357998afddd76300036cfd9374706b3968d74c0f3ff07875dbd368082cf755c1f7874 *9f6a43776f989bf250780d283886dec65663c7f264e79945ae74c8190323b0c73e6878800f7837 *521e8cb7d85eb8691ab7f16a70e98490875807f7213f5aa9aef9f34ef74ee378c89df2e3d5051e *b0975a98772b17e94817eed168044a4757d6e8821d88454fe0f998e77412a679a237903577eb36 *5ff89e6d086fcf7381e0f301b880b1cfe82b33fa12ee75589ef28fa65c72dc852c788d47085be5 *a5775bf66aaa87deab67f628e077e916f3afcf9732a07bb1d7f56c1875cf3675984708589775d5 *e66c8c3ef7e5997bbaaf7ba44f7abc975c620f4941780d33f085c02f7993bf77e7826c46595ba0 *f9822170f97f6ffcffa52903070bfdd037906b97f1e8ae714fd8f685f07670df73717765d0f77d *aa1efd9863f758367d901e795428311e3826a93779aa8f61fc3660c8b10267d70157f07add777c *f7767e434778b3577838bffc87677b891f0003507f5e1ffd2c8bfed2c7e2786f74c506085fc464 *513161d004245f0a172e84e5f021c487a73e4dfc64f1a2454c1a3135eae8911048427b46927cf3 *a6cb1014074da8a9f6ef25cc983267d2ac69f326ce9c3a6596f1e6f327d0a03ec9012567f428d2 *a44a8dd60a402001030f4ffa7802564d5e4c79d58079eaf3c40383040402d45a6af62c51a16ad7 *626bebf62ddcb86da3cd8d66d72eb3bc7af7f2d54b4c2043856b56ceb9d5ff30226258a716636c *fc4963238e1e3b86044972a4c9374a60acd4e109ebced0a247931e9de5adcfb66b57ab353a94e8 *d20b030e2898c0d2912b64dff4bdd4f70d992b476a4c4c507060c005b3458fb26e1e542e74e874 *b1ddc5dbf77a5f627fff060efc68251459891133767c71a3e4c995455ece6ce5c64a137d5c96ae *6fff3ee9d3d1517b53edfcbf4fd30c3000541ee8a04655d5a4f3523a5b79a2860e602530e03400 *02e8df7e19ca555d75d879e89776dc7537a242a3f070100a8c8c375145e6a137d947955db64766 *5ba4b4d213c0f0861f8f3dfa18937e1a0a890d50fe35b7865309d8369527bac923cf6f5d3d419c *5801ac612186436ae9d6741ce2ff65dd87d711c34c88249a19912c50ac2408442d9a97517a30ae *3763665f18d142679e2cf8239f7ddaa7df745b0aba9f01b3d576206ec8a4930e70c2e950dc7106 *0c3aa9745e76c80c986166c79d88660676cb780fb5b152156f9ef7188ceac9d81e8d631cc1d94a *8e7ce327adb58a0685a577513a282a4946c5a4550e7a25e158a8ec3a69ae996a8a9d76647afa6c *a88941a292413c44e2e246a93632677b268d6104ac07cd672bb9e5de04455f5f26cbe1b16ec946 *9b6d6a24dae870900ee040bbd455a76fae7a29bbeca69d3e4b62b4e36124490f2b01026764da6e *6bd98c98bd6167b806f581cc8ee66abcf13fe802ccd7baebd635575bc7084060540756ffc51584 *120e20c03124eb3b32bf21fffbb1a621ea3cf099059367ea2755aca485c3db3e0c319d36e2b9d2 *c51973fc74b91ee33c35a636475345924b5225259563556175d57bdd4cb5873b03c673cf3e4ba4 *18d0186172c64a361ca26a4811d3f886153f502b2ec650fbadb1c763923d387685c28ba8a3f61a *4038e37c09be9d766843ab769b8b95d7f68b8de4b1b4092888b12a9d6f8ca1047c79cefa37eae6 *42c190cead37fef126be4ad5c7b0618db5c9eb00b7ae50e4920f4c796296b70d67b6a91e62c34a *4a846ed21543546cc213aeec993af5e4ae2e79eb8f0bfeba0386c65baf71f7e64e66f665fa2ef9 *2da0c2e20bf0950f7f5ef1dacae8c54a3764ff3631e97b5b8c0c68d5fb6febf5ce67a6de11507b *796916f9b4238b93154807110acbcb76a1b3031a907cac13980033d8be9fb9c954e8e1489ce4c4 *ad91a0616f2d88c20f3867902778e274ff7b2100332843b461ed29b6e95a00aa30c31dfe6e83a1 *12defb3e1842ba81ae2426f982fe0ea20347f00f864eb4de7878c843c3d5467152dca10fa365b9 *0e62ee8345a3ccd1d8b33cbc392f3e2c01c6f49ea8465a41218bebbb228920e12bdb052021701c *911b8107c4f7c10f325f0ca348c45812cc8c210a658c8f1a5ce1c23532925644c8e306cfd73dda *84cf01e78324266161112e7631737f5c0fd2ba7544d2a9d020895c642353e927229c2293ae8c48 *29ff1838210194e295b654cce5f8d8184f7e9110942962e8c6608521c8c08c3ae8031a55a94c72 *11c13c6eaadc2da37502a78ce504d1fc612b71b9c95cea124e8ff1a31f7b094a411a31335730c2 *0d9208bd26f56f99ee7464372f02c42d92278f8c18d0805464cb2d6e319e6fc2441f413844f9fd *1298466c9515d0594a131c1318bb792744c965037f52b431e5e1674516c388090420001360c436 *fb29cf8c72b2a21e14e240c53942bb99e46e5f48e80d16ca12575c25a2362d970d1ad611219ab4 *a7160984090e70001380d4a726156264525ab471d6cd6e77cbcc18ae70841f3ccf20c7a4693b6f *aad55ae5f48f9341a946e067d49f9ac0031e3041208c1affd680662e9c5e4d15539bead4fb89ce *0a5395813aa1e708873a6dab7eb5950d42f2d62f8275a7603d2c40817a90b422f6b08605a75207 *1b5783d249626fd842148cb083aa5ab50fb949e35f438bd3c95666b0a67dab620d1288d3b276a9 *a495ab536964c4316056b330c82bf43caba8be8ab6b7388ded1e5e0b92820eb7b5a94aad09e860 *5cb81297a923a16c6ce94a5bbbfec00632b5aabcac025adf7277633668e9dd801b5be192b73262 *58c9e7040b48d23e1794e2052e5d45b7052b2861083790c175b1bb570575b7bfd433010c6cf083 *2128210a56f8c218e29b99f73298c1e73d88181a2ce1b95af67e637869148e3084eaded68cf141 *546ebe9155fffb9218751e5e090a5a00831b0cd80805b6c21610ac60f0de6fc22379b041226ce3 *192bf8c2f38d82128cb0e11bc0a005b88dcf13e4e50aedf2b6c44eae9e3c1a048ce0f4410d533a *f18953ac6219dc6007031e82118e5060035be10a5b10c317103c8635a7e17e5658c915ee978635 *af39cd62d8c215ac60852800f90842def00eee5b642363f9c449ee036eb43be227331aa2fa48c7 *37aa818c297bc2115ed141a133ade94d739ad33a988a233cb1646454e31be96872a353dd687d44 *f91b919ef4945de1894ad34e0db67e02ae1d88e94e5bd581b84eb2ad69176a512f1918a476753a *e4816a5533bbd9ce7e36b4a32ded6953bbdad6beb6680302003b addfile ./web/logo.pdf binary ./web/logo.pdf oldhex * newhex *255044462d312e330a25c4e5f2e5eba7f3a0d0c4c60a342030206f626a0a3c3c202f4c656e6774 *68203520302052202f46696c746572202f466c6174654465636f6465203e3e0a73747265616d0a *7801d55bcd92dc2812bef314bc40cb424220ce3e6cc4de26eab00fd0b1b373686fc4ac0f7efdfd *32139084904455b73bbaec43516ac8fcf2974c50fdadffd07febb1d76ed23fb4f17d67038ddfd2 *3884ce7ba74defbb69d2669869327dbcea179b9fbd18432b559c1dbf12214c93bf615d370c36ad *1a88ce803f47ca436228d3d402e555ff4bff57f7baeffa2984e027a0f1a3f6be0b56ffefdffcd7 *6ffff869f47f7e4294a11b469aac4d94eaf587fa76fbcbe89f7f41541296ff4804e6b4da00faa8 *7f01ce3f35280d44a9efa69effe9db777a28e4154f15067de75c7098c3145f7fe80108e7a083ef *7ae77a43fa34b6336ef5086a8d8f8c19bb6956a60fdd3c1868149ffd086d986e72561b8b953da9 *af42b598f3a6c3d88dbd57669a3bdb7b3d03e5084aacd2611eb5f31d18f083b99baca9922d27a9 *373d0d00e7b5995de7032cef3ad7035b309db1534296bed6a00a7895a6bc6908ede14691c28b19 *3a67e7cce065705dc09ffd214a554c79833f996e98c47d48d6976984b0a01995f1e24c37ce205a *6854adec54ce015517806c249545cbbcf8b10b01f623bbe9f82dd15035e18b3988a9f86486734d *66c5c3d96e04e408434d70a4c1558d9490c6292019c51da7ce0f1678933e86b19bed9cf5357553 *a8db3d6954668062348aefc6d1f6a028361bba307b15bd91bf54016e26c0dee232323fba5322ac *168f3b4657ce795bbc5b244cce9f159042e8448bc51444650c4331844a411a0d95be266b43f01b *5209325e4c11bf301ee218da42e4e7efca23b0299d3ad721e7c8971b1822df7cfb8eb4f2fdb64c *ae8e907f383fab1f9c320d888da346cec027d29cc32762347d4f9f92cf274eece04e03868124ee *2684363f1908589a73d301d05914918bd0ec46090d64a4046e40eabd68128821c1a2ed076804cb *2c59185876a3120b96452cea51cd642c6940baba69e42346338a95a199fde8184db293bad74e09 *4461a759ff5240407b0fed3e95d1359695cfa8269f39c082128035134301b852502ca3bbd0244f *56a71e7c8446b064afb5322254f1d943586275c491929c7489a6032c2e6926fbad2d47eadd6812 *ef9961516ca72785cf38d6cc94fd773f4a587e7f9e41b61734d983a7dd28a1f9fd7946b008008a *a6fda8c40215ffa63c63a3665cf6e0fde818cd47e719cb79c665afdd8faeb17c549ea16d95f626 *2f1e8c888ea3e51955eabc53269f59ec9434b342f3ae3c43dd021064af8d2342159f3d84e5a13c *3344cd8899c88377a34fcc33036b66cefebb1f25cdfcfe3c83564ad0640f9e77a38426f90cf2e8 *6faa670c63093903ef472596c57f3fba9e59ba5bf263ee62b992d88f8e3121a6d443d5676d8752 *a882a11fb45bf87fcaf3b2e2a5c26157f1a627c5ae8863019c4048058c767d5b25eb3774d4a89b *69cd9f94415027a1ea3da8bdff949a7ea97ad635a218bda73834bc49ffd068a01928e88ed43148 *e6e2c237ba6d3a8058931ce42154046c922e4e08b1c72dfbd9527f8c5c3af6a4693349a5754c26 *15bf3e2e82f3e4c437663c221882fa8490446326b3ec6d922e229e24961872af9f54724e91f752 *dca149f0fc50044b84f04961bd53b48ffae1a48038b033cb85d1d833a21d197802bcbeb0572af4 *9c23331b2c9f44bf4408e730f8572704c34b126447b869a9d1bc616f2132a27122231a3f24c3fe *23fabae9545ef92909e6fa2c980fa7789223425f20749fbd48dd1535ab54d4cc23e121fdb82c98 *356d7840f8a6ada26c35cbc64f644212d04a3374ae1fc177a3f30c2e6c429fece58734b2d3b9bd *927e188f5401411a53dafb6db29c15d76ec39336f090fd792927ec813fd7148df34bc9e649cdde *8b179367f3a82dffa46d33cc492b3e07860d493f0df927ee78b2d1c15e3e643cb2d1887eaef24f *b15965a3e348927d19e285e4450da8649f595749a2f722488fb20f9a6f88c28248f3cd36a7b24b *064cc68e7ab4f0157c4e9663c977b10323c8bc7021b124755ab02c6427f39d9835a6716a65596c *6efc2331a4f1fd42877327827a92b6c91f6a0b51f863a1b0e19648b0aee42e17b28c51c2ecc6a9 *e7dea4e53dbf29aac6f5cc9125ccf96a49c4b5855135c789b72ea14daa394fb51b8e2ca1ed4435 *17a975b35052d75aa390b0baf5ed978d513527a9b32ee118bde622596e38b28438f167a817c971 *b390251ca26a2ed26165a1f0cb5e933a2838ba24bfba8426aa2670574abbca2edd517ad9f06309 *715d201c4fd3db76214bb84404a759496b94f66b696dc3372e4f112fcb53f2daa5b1babca7696b *cf6d93a6007239af5ca5291c0673b6c1e76401729a7083254337420350f19bc69d6018e4a1378a *e7795c0ad0fc9b6e4c6b554642eb805162b830daa4414a45651a24bd55199d4a5432e2b449568d *b9f5a0da6d67945556a8cec580b948b31b4670e06b1bed246277df55cb9071552d6fd834b9c28a *0dc75591c6d94295347ecd08d4363eb762c43e37a51df138ed53e43323d4d7f86c74ee9251b14d *4061d58afc5aa2ab286adc56aa8cee8aa2cb8dfd636288b72da8eb64dbca164295746da1a3186a *dce6368a7b28860eb74548b9ea19368c1e8aa2621ba56dadd6555c33ba8aa2b8091e6fbbd942ef *8aa1629b86baaadbf4b53c5731d4b8ad5719dd1543d53280ec24650039c4d2dd54d9499eb9def8 *38ad825cdc892eca866caf4a4481d2353b4eaea765064bf32e77682a4bf016079725f8e4cc3d07 *6c953c0a035e02a261b0d80426d3e1c50e1a2a1bf0fd551e5b1cc8e0314fc54b1f56f37a1ebd6a *d0e411de2320aa718cc9b89ba52f0ae49cb658ec899ad363a68c31eef047a28cc940c814f0c954 *eb051179432e24567dde738bb829c548c4b214235f7c66118bde1922568f3c9f5bc44d310011ab *3de9538bb82e7cc94df331c6aaf07d66018b929b23b152723fb78831d948b14f91583b5c7f6611 *1bdb8ce71671736e46c9a67625f1d42272b289cd3c0998934d2a009e7c4f2cce2249c4da35ce33 *dbb0682749c4e58e61b9627a66118b461622562fbf9e5b4449361727d14f2da29c604bf34e3694 *db213a735b2e0c9f59c0c66383e716311ec1c83d0459b172cdfad46dd4eaa804e285f38be0bb6c *496dfaa03fa2eb577c04f0ceae3f77f9fc8642c89bc6ee6ee78ec6582dc71bef14542dc71b72a6 *f1f0f1863a3d1e7a660b361d4c19839fb3c8d994e91d1c900f7d64c8e7533241863c818f94e887 *6013ee55e36153f3ad59851d0ef2aed8e1f86fc76e7360c337337c2885a05cbf09f69074899dc4 *11dd0916872760573d3ca948871348964ece63abca4cec166536dca3d1adc6093b395b6c63a79a *5e72686316c5cc8eb297ad68f0d97295069fd92938234cdfee9735764dcd769b7451ab593a9c1b *177e5934bee428b9a358bff1b6f7cb87c2e0f0968dc260f55edc9e5df2cb064759c26073bc06d9 *aa0de1892aef0a82a23923765995f11dbb8f0c82a251227679cf5bbf8bd7a4caeb30289a16b0ab *362d1f1506c51d1c5566b53bb813db9d38ca3e0c6219787e135761f65010148535a952de128494 *f12d41aa512aec1e0a82c65bb913767785c1aae08464bb8293645ceee64e989ed82f65cd25d073 *f1274d590e846af15761fa901d0f0bb18f0cf34d510485565f22c28fad7351c443297ff092741c *78bcb24b5634166f9cd0a59dc34fca796c675445afe9cbd4e157f866a4e9f2ee91010d7e090953 *98327d216da5e718820e5564a073c7eb480932c5e22164827f0764c54833b435648a9c13c86dc5 *598b968f21e307ea51e56d5a3e868c5f6ab416782d903fc9311a8a444e7b11f257708c83421339 *6c757b953c99b2d2039efca16ed15aac7e21b7687c952c69f92bb8c561d10cc75817cd2d5afea4 *7c715878d396b22abc5b207f52be682bde23e0afe016870d00d53cab1fd9b4e8f893dca2b58968 *81fc496ed1da887c21c7289a192af8a59921c7909e74bdf37d858da4ad21fa426e71d85441dbeb *a6ea0bb9c56163466e917fe4158b0a395962f4b5e2fe93f2c5457347ba5e357727eec12d04b719 *f795f8f5ae440affb3121fc0da5ee1e4deed043857e56dc0957d6fa18f935c6e32e110cb4f14e4 *90427e2af70050f578df57e94870e219fbbe3ffe0f006f64ba0a656e6473747265616d0a656e64 *6f626a0a352030206f626a0a323935300a656e646f626a0a322030206f626a0a3c3c202f547970 *65202f50616765202f506172656e74203320302052202f5265736f757263657320362030205220 *2f436f6e74656e7473203420302052202f4d65646961426f78205b302030203137332037385d0a *3e3e0a656e646f626a0a362030206f626a0a3c3c202f50726f63536574205b202f504446205d20 *2f436f6c6f725370616365203c3c202f437331203820302052203e3e202f457874475374617465 *203c3c202f4773312039203020520a2f47733220313020302052203e3e202f53686164696e6720 *3c3c202f536831203720302052203e3e203e3e0a656e646f626a0a372030206f626a0a3c3c202f *436f6c6f725370616365203820302052202f53686164696e67547970652033202f436f6f726473 *205b20302030203020302030203633205d202f446f6d61696e205b203020310a5d202f45787465 *6e64205b2066616c73652066616c7365205d202f46756e6374696f6e20313120302052203e3e0a *656e646f626a0a392030206f626a0a3c3c202f54797065202f457874475374617465202f4f504d *2031203e3e0a656e646f626a0a31302030206f626a0a3c3c202f54797065202f45787447537461 *7465202f534d20302e3032303030303030203e3e0a656e646f626a0a31322030206f626a0a3c3c *202f4c656e67746820313320302052202f4e2033202f416c7465726e617465202f446576696365 *524742202f46696c746572202f466c6174654465636f6465203e3e0a73747265616d0a78018594 *4d48146118c7ffb38d04b106d19708c5d0c12454260b5202d3f52b53b665d54c09629d7d779d1c *67a799dd2d452284e898758c2e564487884ee1a143a73a4404997589a0a34510055e22b6ff3b93 *bb6354be3033bf799efffb7cbdc300558f528e63453460cacebbc9de98767a744cdbfc1a55a846 *145c29c3733a1289019fa995cff56bf52d1469596a94b1d6fb367cab76991050342a7764033e2c *793ce0e3922fe49d3c3567241b13a934d92137b843c94ef22df2d66c88c7439c169e0154b55393 *331c9771223bc82d45232b633e20eb76dab4c9efa53ded1953d4b0dfc837390bdab8f2fd40db1e *60d38b8a6dcc031edc0376d7556cf535c0ce1160f150c5f63de9cf47d9f5cacb1c6af6c329d118 *6bfa502a7daf0336df007e5e2f957edc2e957ede610ed6f1d4320a6ed1d7b230e52510d41bec66 *fce41afd8b839e7c550bb0c0398e6c01faaf00373f02fb1f02db1f03896a60a81591cb6c37b8f2 *e222e70274e69c69d7cc4ee4b5665d3fa275f06885d6671b4d0d5acab234dfe569aef0845b14e9 *264c5905ced95fdb788f0a7b78904ff617b924bceedfaccca5535d9c259ad8d6a7b4e8ea263790 *ef67cc9e3e723daff719b7673860e58099ef1b0a3872cab6e23c17a989d4d8e3f19364c6575427 *1f93f3903ce71507654cdf7e2e752241aea53d3999eb979a5ddcdb3e3331c43392ac5833139df1 *dffcc62d2465de7dd4dc752cff9b676d9167188505011336ef363424d18b181ae1c0450e197a4c *2a4c5aa55fd06ac2c3e45f951612e55d1615bd58e19e157fcf7914b85bc63f85581c730de5089a *fe4effa22feb0bfa5dfdf37c6da1bee29973cf9ac6ab6b5f19576696d5c8b8418d32beac29886f *b0da0e7a2d64699de215f4e495f58de1ea32f67c6dd9a3c91ce26a7c35d4a508656ac438e3c9ae *65f745b2c537e1e75bcbf6afe951fb7cf6494d25d7b2ba786629fa7c365c0d6bffb3ab60d2b2ab *f0e48d902e3c6ba1ee550faa7d6a8bda0a4d3da6b6ab6d6a17df8eaa03e51dc39c95890bacdb65 *f529f660639adeca4957668be0dfc22f86ffa55e610bd73434f90f4db8b98c6909df11dc367087 *94ffc35fb3030dde0a656e6473747265616d0a656e646f626a0a31332030206f626a0a3739320a *656e646f626a0a382030206f626a0a5b202f494343426173656420313220302052205d0a656e64 *6f626a0a31312030206f626a0a3c3c202f4c656e67746820313420302052202f46756e6374696f *6e547970652030202f4269747350657253616d706c652038202f53697a65205b2031333635205d *202f446f6d61696e0a5b20302031205d202f52616e6765205b20302e3630303030303020312030 *2e36353030303030203120312031205d202f46696c746572202f466c6174654465636f6465203e *3e0a73747265616d0a7801edd0639325690005e11cdbb66ddbb66ddbb66ddbb66ddbb66d1b75e2 *ada8b871bba7b7777667633f74c6f30bf2c70f7ef8f039e073e0cf1cf8fe1d1fce816fdff8dffa *fa95ffd2972ffc399f3ff36ff9f4897feee3477ecf870ffc86f7eff9bbdebdc3fbdebec59bdebc *c13b5ebfc63b5ebde22fbd7c89d75ebcc00bcf9fe3b567cff895a74ff1c29327fccae3c7fccaa3 *4778eae1433cf5e0019eba7f1f4fddbb874777efe2d19d3b7874fb361eddba8547376fe2e6c60d *dc5cbf8e47d7aee1e6ea55dc5cb982abcb977173e9126e2e5ec4d5850bb8397f1e57e7cee1eaec *595c9d3983abd3a77175ea14ae4e9ec4d58913388e1fc7d5b163388e1ec5d59123380e1fc6d5a1 *43380e1ec471e0008efdfb71ecdb8763ef5e5cedd983b17b378e5dbb70ecdc8963c70e1cdbb7e3 *d8b60d63eb561c5bb6606cde8c63d3261c1b37626cd88063fd7a8c75eb30d6aec5b1660dc6ead5 *18ab56e158b91263c50a8ce5cb31962dc358ba1463c9128cc58b31162dc258b81063c1028cf9f3 *31e6cdc3983b1763ce1c8cd9b33166cdc298391363c60c2cd3a7dba64dc3983a1563ca142c9327 *db264dc2983811cb8409b6f1e3b18c1b671b3b1663cc182ca347db468dc23272a46dc4082cc387 *db860dc33274a80c19621b3c18cba041b68103b10c1820fdfbdbfaf5c3d2b7aff4e963ebdd1b4b *af5ed2b3a7f4e861ebde1d4bb76ed2b5ab74e962ebdc194ba74ed2b1a374e820eddb4bbb76d2b6 *adad4d1b2cad5b4bab56d2b2a5b46821cd9b4bb366d2b4a93469228d1b4ba346d2b0a1346820f5 *eb4bbd7a52b7aed4a923b56b4bad5a52b3a6d4a841f5ea52ad9a54ad2a55aa48e5ca52a99254ac *48850a52bebc942b2765cb4a993252ba34a54a49c99252a284142f4eb16252b4a8142922850b53 *a890142c28050a903fbfe4cb2779f34a9e3ce4ce2db97249ce9ce4c821d9b34bb66c64cd2a59b2 *9039b364ca241933922183a44f2fe9d29136ada44943ead4922a1529534a8a14923c39c99249d2 *a42449228913932891244c488204123f3ef1e249dcb8c48923b163132b96c48c498c18123d3ad1 *a249d4a8448922912313291211234a8408840f2fe1c21136ac840943e8d0840a25214312228404 *0f4eb060040d2a41821038b0040a44c080040820fefde3cf1f7efd8a1f3ff8f68d2f5f62f51377 *b27f790a656e6473747265616d0a656e646f626a0a31342030206f626a0a3835320a656e646f62 *6a0a332030206f626a0a3c3c202f54797065202f5061676573202f4d65646961426f78205b3020 *3020363132203739325d202f436f756e742031202f4b696473205b203220302052205d203e3e0a *656e646f626a0a31352030206f626a0a3c3c202f54797065202f436174616c6f67202f50616765 *73203320302052203e3e0a656e646f626a0a312030206f626a0a3c3c202f50726f647563657220 *284d6163204f5320582031302e352e342051756172747a20504446436f6e7465787429202f4372 *656174696f6e446174652028443a32303038303832363039333830325a303027303027290a2f4d *6f64446174652028443a32303038303832363039333830325a30302730302729203e3e0a656e64 *6f626a0a787265660a302031360a303030303030303030302036353533352066200a3030303030 *3035363733203030303030206e200a30303030303033303636203030303030206e200a30303030 *303035353430203030303030206e200a30303030303030303232203030303030206e200a303030 *30303033303436203030303030206e200a30303030303033313639203030303030206e200a3030 *3030303033333033203030303030206e200a30303030303034343533203030303030206e200a30 *303030303033343339203030303030206e200a30303030303033343834203030303030206e200a *30303030303034343839203030303030206e200a30303030303033353338203030303030206e20 *0a30303030303034343333203030303030206e200a30303030303035353230203030303030206e *200a30303030303035363233203030303030206e200a747261696c65720a3c3c202f53697a6520 *3136202f526f6f7420313520302052202f496e666f203120302052202f4944205b203c31323063 *393435313661316261343664646361646131613237333330626263313e0a3c3132306339343531 *3661316261343664646361646131613237333330626263313e205d203e3e0a7374617274787265 *660a353831350a2525454f460a addfile ./web/logoBlack.pdf binary ./web/logoBlack.pdf oldhex * newhex *255044462d312e330a25c4e5f2e5eba7f3a0d0c4c60a342030206f626a0a3c3c202f4c656e6774 *68203520302052202f46696c746572202f466c6174654465636f6465203e3e0a73747265616d0a *7801d55c4b72e43612ddf314b880d0040182e4ba1713313b8716730085db5ea827a2470b5f7f5e *7e00fe4012a552abbbec0813a480447e5f66822cff307f981fa6c5bf6ef06618cdfffe34ff31ff *355ffef5e6cc5f6fe6cb575c5fde78466bde5ee80f1dfde1c9b9d686c9c4de7c4f370d6e5ed38d *f1adedba609ec260fbde74b8c77f5e8c6bf5de0d4c40a7e91d28600affa599263b0c312d70dd48 *24e8f262badef3e895474f7eb9afdc7d63c1b080186c66eaaf4add9c50579669ab24a6ced65b12 *f425ffedfd8242d30d746fdb7e9aa6a187ac6484c14e61610756f70fd3d9ce8ba1480dc4c077f3 *e5f96f67defe86a8b02251da58d1c142defc03bdff3b5bb4b57dcbff98e7afd99a3f0c4f950d5a *1be3143187b66bb04d070ec7c94c836d636c1d0cee5cb02e2e1e41adfac8396ffb11569becd839 *5809d716d66a9ded63685cc0ca96d457a02a734c9af36a266f7d3b18d78f36e03a824b0f4a6cc3 *6ef44d1c2c36e007a3ed035cb5407637e9d5f41d9803dd31da61825f451b5bf03639eb027c55e4 *4db7259a9b29af06420fbdd125cd93eb6c0cd0826ef0d4453be1cfc331979b2988a3e06cd777ec *bb90d53cf51ec282a62ae3293aeb47103dd1e8664e03aa7102679e54a696791abc9d26d88feda6 *77d9d625e1654e93e780aad018e15cbd5bec1183f51445ca6a0fc576716fa40610b29e02922aae *efedd005f0abfa309db723549bf4d5db7e9aed3e330592aa7499018a6a94c17a1f5a50149b7576 *1a876473b949422fa9a9c56502eccd2e83a8a4c5ea4e99f0ec71c7dc6de7bccedead12aaf36705 *680819d16293985cc5a546902a1a51a961a8864841aa86d2db59cc17f30c28012e2b44fc8371a7 *63680b913fdf0f086cc0bd8bd102b4e4e6b9712df086b3c6d7e7c5e479d93c02fe283e736e7020 *e6bd0166e00a248bf056c468ba4f57c273c400432076a701b3811c833fe9932e0de8c9b3996cdf *b0282217f1b51b5d710342ca4d03eeeee2061a020723ebb5c9a3f91921f3a966665e66cdb59494 *6ed60cf088b9f16265f0a023f0959ebd8b1b290cc44e30649d9d46e185720f651febb7a3e66e5e *92638cccd489cfa04a616e5228cc41318f1237c0afec134b0f2eda69a999cc0d0f889ba4ab8d07 *0fc24bf6dab01b255ee003ca4bb38aa677f092b8eb1253124d3169463c18760abbd19e1b896d50 *02772edec38db025c5e6b389ac993efbef7e74c40be8302fe0e983700668cf38d367bfdd8faeb8 *9935732fce88ff0a2b2de25947b0571ad5f3927c0ad777e14c509f89d96f75447ce9b37771b38c *a6e4a697f920b0cfc4ecb5bbd127e20ca555ca0743f6e0fd2869e6e7e30c750be025fbef7e9478 *f9f938d3a966c44c940ff6a33d373f0b673ad6cc98fd773f3ae2e5e37106ad14e3cc983d783fba *e2e6e370c6b16626f15fc4b38e60af34aae7e55e9c99bb5bf263ee625bc23e1dcdcf3eb1c6a28a *18ed16fe5de9a1911af2ce7a0166446dd5c44dbd8063019ca34895ac45611915bfa9c651350827 *947556f9f91b9a08b6b0b83ed76519ab64d092648e8ba9ef060d3417e2c8143897e16a84efb90c *6742e900622ea45004cbc33221e37b81be4488c9a42cb6ac3f3c978e07fc800cf3934a8754fc0e *ba08ce9381cf5ff0930443ce793652b7cee89432da2c60513f891fd1d773934ace5ef7c6f20c37 *ddc00f0ff593f8813f3c9b81d121b6cc117c3e8c2c1746be658a7564b8d0a3041dc9cc0ecb7bd1 *2f11c2390cfea924c4f61a1c7b0b08f6a27122231aaf2383f24a08f549b0d8b26020e987a99e1f *2173622fcaff7b7fded8cba4a266f4448af413b360c1257e9a0a422cd628899fc84c49c0202d90 *e8472aaf39beb6fca452626a93bd862e8d42bfb617e2e98410f333498b0a7e86c096c328886baf *ed25f104dcd8c47b4ae053f6e7b99c0807fe2c0dc29690f0c3651aa97918c48bc9b34ffc798b3f *489b42684c5a1972608469ad1fc4d34a3f2bfcd18c27e98df899323f9268d6fa497898f493f067 *93acb2d17124c9be0cf1a6e44565775c71257966592589deeb82b411106341a4f9669b13dccb80 *c9046f7c20dd78d307c11aab1d18b1cc0b9504827201eaa58552525dc0382f246fcd3b469c3b71 *959a772cc2f67ec76851f883ad93c027c31516f27e3b5826096737de2feb55351740cc0b5712f6 *5655730ebcfb1d03a9066c29d4c27645a82d2d949e683887d6c242564d8d4657127a55cd397416 *4ce1493564c373b0dc338a137f09fe2d3882d8021c4b0b45351770c80b57328a0d2fc06fbf9f53 *d54c027764cd12dc9516ea8ec7f046796dbf708e082e9acf614d9737b82a02407f1a89b23c8157 *11c60abba35821509f7d68015bfbe997304532e23098610a5766b2eff1064b86d1430350f1abc1 *5bc6a9938783cb57ace3128aac00dd275e662157b056bf51c38c9436d258cf68369fa62daad9d5 *464892b74b74089b907251edae36822a6eda88ab6186d995418bf5f0f546a0766a234d3cb9ba28 *56cbbc0de212d777bac206c6092f72d9b0a8a7afe5d9fa5c7609f5b94ad82f6e24b42a9d9bd304 *2c7492263e268a8266dc5d5ac1e68b8abd2851315cb3ca5234a9ea04a26708b9f6b877c5d061da *22a7c815ff7df0c331c4698e62e83ccd5d2bee2a860ed322365fa445dee8ae28eac8154054d328 *1456ec2aae25ba8aa2aab45bdce6a618daa46948b64bd31f1343f80a8033d1749cd6a96a2d4a74 *530ccd29b8a20cb8df21e68cba281bc82d4add4fbd74299167a4508438ed8e4ec9a3d4b9ae172e *cb12b211be580137df71152ec70941c1483675f80888865380b97b67f161070fc384fb171de340 *068f792a3efa080dafa7116680268ff01d0151d53126e3dd16df805c34018b07a2168dcf9431c6 *3b7cdfc86470c8147065aaaabf810a2278f9454104367c00503ca68855a5d8238b785804c2b28b *22f0b145ac2a061e5a4489c4f3c29705c4b78fb832c4dc09360c0acd2781cda6e48673164bee47 *b66165b1ffc82256b41992151f3765708343b5dff6dc8cf0747e25f1d05664b0b968ad58c00705 *9bc3a68e60676eea1ed98695ede4238b58d9c83eb688ab169a60a7f462eea1459433825cd9145f *18b2800f0a3615c7068f9e13f9c002ce797160f1c86e7acb510915e01fd4f54bf93df7f7f775fd *0d77fd749e80238283aebf784843c0b33da4a1b3ae871614c073f8166a164c4e951ea995aa3a98 *720e3f67912adcb511274e7ce823436e1e65820c79023782f443b01eef55f5b0091f1ead0f89e8 *543cbfd65a7c0c90b6c351d80ddbe15469b75dd5814d613b1c8bdf2edde1e109e45c1c9e14b6c3 *9975ed7612e3f40ab2f23ddac976e2ad32e1d276976fd328c44f36935386bacd9aca06bf6e3b15 *f3c42f2b9b6dde4e8e686ff04bf2e275186c1a5fb847f1338c3ae954af59ba7d185436a185edde *150607c76b8b60bfdb51e620a86cce0ab2a598bb29082a1aa58f0c83caa6e544ba45d45d87c1e6 *1ddc5103c1db7d4018acdec4c13d8ac57c9d6cd74150595817b67b57101c16b914068b6f0935b1 *de96e912a2cc61704bc15902e977c93867ef8a377405c5a6085cf8e8b51d4fdfd39d6c7253985f *16451ce4ddc845115983879242f16daa0e06bc9ea7b10bf826885eda45fca49cc7614455840ff0 *e9a609bdc5aff09de7e9fc2ed181060f308529eb1bc6fc1ce502965245063a377c8e24d4b8db38 *65193fc33f63199fbedec0727a3fba63b9ae38db6859ed78ab96cb2c0b6bd55a3e2cf080945ae0 *fd6e8e51f94debefe4189785261d806c19fe956e5151acfe6e6ec1052f52d1d54f3736c197906d *0b719f81179ba21921572e9a372cff4ac7a828bc7f37c75815efe420d2a043dba9532f04df915b *2c339fbac832f39531b92af3a1fad4cc57db006cdc22b39cfca32e599fb2dc08285d26ebda26e2 *88e5c47b1dcb1f525f70230277b8fae95025cb9f8117b5cdcc86e5e40f5b885bfab28eaf7df9c6 *fa62d51051f7957f6ea83f87faddd0829b2a728b8b9f5e6d749c1c78abe3cf708bc3c68c206ed1 *986d58fe956e71d1dc41ff61f1b3b20de347ba3ef067fc6f83a4f6bfa9c44f3f995896f80dfdff *7d52d2583488e4d7dbb703a58a6ec938b5a7d21f5db653a7082d65636e48529bb56ba7ce9bcc8d *867fa56bfcf17f6e9691310a656e6473747265616d0a656e646f626a0a352030206f626a0a3239 *37350a656e646f626a0a322030206f626a0a3c3c202f54797065202f50616765202f506172656e *74203320302052202f5265736f7572636573203620302052202f436f6e74656e74732034203020 *52202f4d65646961426f78205b302030203137332037385d0a3e3e0a656e646f626a0a36203020 *6f626a0a3c3c202f50726f63536574205b202f504446205d202f436f6c6f725370616365203c3c *202f437331203720302052203e3e202f457874475374617465203c3c202f477332203920302052 *0a2f47733120313020302052203e3e202f53686164696e67203c3c202f53683120382030205220 *3e3e203e3e0a656e646f626a0a382030206f626a0a3c3c202f436f6c6f72537061636520372030 *2052202f53686164696e67547970652033202f436f6f726473205b203020302030203020302036 *33205d202f446f6d61696e205b203020310a5d202f457874656e64205b2066616c73652066616c *7365205d202f46756e6374696f6e20313120302052203e3e0a656e646f626a0a392030206f626a *0a3c3c202f54797065202f457874475374617465202f4f504d2031203e3e0a656e646f626a0a31 *302030206f626a0a3c3c202f54797065202f457874475374617465202f534d20302e3032303030 *303030203e3e0a656e646f626a0a31322030206f626a0a3c3c202f4c656e677468203133203020 *52202f4e2033202f416c7465726e617465202f446576696365524742202f46696c746572202f46 *6c6174654465636f6465203e3e0a73747265616d0a780185944d48146118c7ffb38d04b106d197 *08c5d0c12454260b5202d3f52b53b665d54c09629d7d779d1c67a799dd2d452284e898758c2e56 *4487884ee1a143a73a4404997589a0a34510055e22b6ff3b93bb6354be3033bf799efffb7cbdc3 *00558f528e63453460cacebbc9de98767a744cdbfc1a55a846145c29c3733a1289019fa995cff5 *6bf52d1469596a94b1d6fb367cab76991050342a7764033e2c793ce0e3922fe49d3c3567241b13 *a934d92137b843c94ef22df2d66c88c7439c169e0154b55393331c9771223bc82d45232b633e20 *eb76dab4c9efa53ded1953d4b0dfc837390bdab8f2fd40db1e60d38b8a6dcc031edc0376d7556c *f535c0ce1160f150c5f63de9cf47d9f5cacb1c6af6c329d1186bfa502a7daf0336df007e5e2f95 *7edc2e957ede610ed6f1d4320a6ed1d7b230e52510d41bec66fce41afd8b839e7c550bb0c0398e *6c01faaf00373f02fb1f02db1f03896a60a81591cb6c37b8f2e222e70274e69c69d7cc4ee4b566 *5d3fa275f06885d6671b4d0d5acab234dfe569aef0845b14e9264c5905ced95fdb788f0a7b7890 *4ff617b924bceedfaccca5535d9c259ad8d6a7b4e8ea263790ef67cc9e3e723daff719b7673860 *e58099ef1b0a3872cab6e23c17a989d4d8e3f19364c65754271f93f3903ce71507654cdf7e2e75 *2241aea53d3999eb979a5ddcdb3e3331c43392ac5833139df1dffcc62d2465de7dd4dc752cff9b *676d9167188505011336ef363424d18b181ae1c0450e197a4c2a4c5aa55fd06ac2c3e45f951612 *e55d1615bd58e19e157fcf7914b85bc63f85581c730de5089afe4effa22feb0bfa5dfdf37c6da1 *bee29973cf9ac6ab6b5f19576696d5c8b8418d32beac29886fb0da0e7a2d64699de215f4e495f5 *8de1ea32f67c6dd9a3c91ce26a7c35d4a508656ac438e3c9ae65f745b2c537e1e75bcbf6afe951 *fb7cf6494d25d7b2ba786629fa7c365c0d6bffb3ab60d2b2abf0e48d902e3c6ba1ee550faa7d6a *8bda0a4d3da6b6ab6d6a17df8eaa03e51dc39c95890bacdb65f529f660639adeca4957668be0df *c22f86ffa55e610bd73434f90f4db8b98c6909df11dc36708794ffc35fb3030dde0a656e647374 *7265616d0a656e646f626a0a31332030206f626a0a3739320a656e646f626a0a372030206f626a *0a5b202f494343426173656420313220302052205d0a656e646f626a0a31312030206f626a0a3c *3c202f4c656e67746820313420302052202f46756e6374696f6e547970652030202f4269747350 *657253616d706c652038202f53697a65205b2031333635205d202f446f6d61696e0a5b20302031 *205d202f52616e6765205b20302e36303030303030203120302e36353030303030203120312031 *205d202f46696c746572202f466c6174654465636f6465203e3e0a73747265616d0a7801edd063 *9325690005e11cdbb66ddbb66ddbb66ddbb66ddbb66d1b75e2ada8b871bba7b7777667633f74c6 *f30bf2c70f7ef8f039e073e0cf1cf8fe1d1fce816fdff8dffafa95ffd2972ffc399f3ff36ff9f4 *897feee3477ecf870ffc86f7eff9bbdebdc3fbdebec59bdebcc13b5ebfc63b5ebde22fbd7c89d7 *5ebcc00bcf9fe3b567cff895a74ff1c29327fccae3c7fccaa34778eae1433cf5e0019eba7f1f4f *ddbb874777efe2d19d3b7874fb361eddba8547376fe2e6c60ddc5cbf8e47d7aee1e6ea55dc5cb9 *82abcb977173e9126e2e5ec4d5850bb8397f1e57e7cee1eaec595c9d3983abd3a77175ea14ae4e *9ec4d58913388e1fc7d5b163388e1ec5d59123380e1fc6d5a143380e1ec471e0008efdfb71ecdb *8763ef5e5cedd983b17b378e5dbb70ecdc8963c70e1cdbb7e3d8b60d63eb561c5bb6606cde8c63 *d3261c1b37626cd88063fd7a8c75eb30d6aec5b1660dc6ead518ab56e158b91263c50a8ce5cb31 *962dc358ba1463c9128cc58b31162dc258b81063c1028cf9f331e6cdc3983b1763ce1c8cd9b331 *66cdc298391363c60c2cd3a7dba64dc3983a1563ca142c9327db264dc2983811cb8409b6f1e3b1 *8c1b671b3b1663cc182ca347db468dc23272a46dc4082cc387db860dc33274a80c19621b3c18cb *a041b68103b10c1820fdfbdbfaf5c3d2b7aff4e963ebdd1b4baf5ed2b3a7f4e861ebde1d4bb76e *d2b5ab74e962ebdc194ba74ed2b1a374e820eddb4bbb76d2b6adad4d1b2cad5b4bab56d2b2a5b4 *6821cd9b4bb366d2b4a93469228d1b4ba346d2b0a1346820f5eb4bbd7a52b7aed4a923b56b4bad *5a52b3a6d4a841f5ea52ad9a54ad2a55aa48e5ca52a99254ac48850a52bebc942b2765cb4a9932 *52ba34a54a49c99252a284142f4eb16252b4a8142922850b53a890142c28050a903fbfe4cb2779 *f34a9e3ce4ce2db97249ce9ce4c821d9b34bb66c64cd2a59b29039b364ca241933922183a44f2f *e9d29136ada44943ead4922a1529534a8a14923c39c99249d2a42449228913932891244c488204 *123f3ef1e249dcb8c48923b163132b96c48c498c18123d3ad1a249d4a844892291231329121123 *4a8408840f2fe1c21136ac840943e8d0840a252143122284040f4eb060040d2a41821038b0040a *44c080040820fefde3cf1f7efd8a1f3ff8f68d2f5f62f51377b27f790a656e6473747265616d0a *656e646f626a0a31342030206f626a0a3835320a656e646f626a0a332030206f626a0a3c3c202f *54797065202f5061676573202f4d65646961426f78205b30203020363132203739325d202f436f *756e742031202f4b696473205b203220302052205d203e3e0a656e646f626a0a31352030206f62 *6a0a3c3c202f54797065202f436174616c6f67202f5061676573203320302052203e3e0a656e64 *6f626a0a312030206f626a0a3c3c202f50726f647563657220284d6163204f5320582031302e35 *2e342051756172747a20504446436f6e7465787429202f4372656174696f6e446174652028443a *32303038303832363039333433345a303027303027290a2f4d6f64446174652028443a32303038 *303832363039333433345a30302730302729203e3e0a656e646f626a0a787265660a302031360a *303030303030303030302036353533352066200a30303030303035363938203030303030206e20 *0a30303030303033303931203030303030206e200a30303030303035353635203030303030206e *200a30303030303030303232203030303030206e200a3030303030303330373120303030303020 *6e200a30303030303033313934203030303030206e200a30303030303034343738203030303030 *206e200a30303030303033333238203030303030206e200a303030303030333436342030303030 *30206e200a30303030303033353039203030303030206e200a3030303030303435313420303030 *3030206e200a30303030303033353633203030303030206e200a30303030303034343538203030 *303030206e200a30303030303035353435203030303030206e200a303030303030353634382030 *30303030206e200a747261696c65720a3c3c202f53697a65203136202f526f6f74203135203020 *52202f496e666f203120302052202f4944205b203c393130386531646534633665666366666666 *63373464363864643938316463383e0a3c39313038653164653463366566636666666663373464 *363864643938316463383e205d203e3e0a7374617274787265660a353834300a2525454f460a addfile ./web/menu.html hunk ./web/menu.html 1 + + + + + + +

+ + + + + + + + + +

+ + + + + +Future plans + + + + +

Future plans

+Bla +

+Boo +

+Bah + addfile ./web/posix.html hunk ./web/posix.html 1 + + +The POSIX environment + + + + +

The POSIX environment

+Timber is intended to be usable in many different +situations, ranging from embedded systems to +standard desktop applications. The interfaces +between the Timber program and the external environment +are very different in these cases. +

+Thus a Timber application must be built for a particular target +environment. This distribution provides only one environment, +the POSIX environment. Also this is incomplete and a more complete +version will be provided in a future release. +

+module POSIX where
+    
+type RootType = Env -> Class Prog
+
+type Prog = Action
+
+struct File where
+    close :: Request ()
+    seek  :: Int -> Request Int
+    
+struct RFile < File where
+    read  :: Request String
+    
+struct WFile < File where
+    write :: String -> Request Int
+   
+struct Env where
+    exit     :: Int -> Request ()
+    argv     :: [String]
+    stdin    :: RFile
+    stdout   :: WFile
+    openR    :: String -> Request (Maybe RFile)
+    openW    :: String -> Request (Maybe WFile)
+    installR :: RFile -> Action -> Request ()
+    installW :: WFile -> Action -> Request ()
+

+The root module of a program targeted for this environment must +import POSIX and contain +a definition root :: RootType. +

+Here the type Env collects the services that the environment +provides to the program: the program can call a function exit +to terminate the program with a status indication, access command line arguments +through argv, the standard input and output streams +as stdin and stdout, open files for reading and +writing and install listeners on files; see below for more on these. +Within a definition +

+root env = ...
+

+these services are accessed using dot notation as env.argv etc. +

+The read and write on files are non-blocking operations: +

read returns a string of the bytes that are available + in the file at the time of the call. If no input is available, the empty string is returned. + Input is line-buffered, so no input is available until the user strikes return. +
write takes a string as argument and tries to write it to the file; + the returned value is the number of characters written; for regular files this should be + expected to be the length of the argument. +

+Because of the non-blocking nature of input and output, programs need a way to be notified +when input is available or output is possible. This is the role of the listeners; a call +

+env.installR env.stdin inpHandler
+

+installs the action inpHandler as a listener on stdin; whenever input +is available (i.e. the user strikes return), the runtime system calls the listener. So, in +this case inpHandler will typically start by reading stdin. +

+Execution of a program proceeds as follows. The runtime system is responsible +for initialization: it creates +an environment object with interface env :: Env, applies root to env and +creates an object of the resulting class; this gives an interface to the initial action of the program. +The run-time system executes this action; this may +lead to creation of more objects, scheduling of future actions etc. +

+After this initial computation the program comes to rest and +reacts to events, such as scheduled timer events or IO events on files with installed listeners. +

+ addfile ./web/programs.html hunk ./web/programs.html 1 + + +Programs and modules + + + + +

Programs

+A Timber program consists of a collection of modules. One of these is the root module and contains the root +definition. The root definition must have a prescribed root type, that may depend on the target environment. +A Timber installation may support several target environments/platforms. +

+The other modules in the program provide auxiliary definitions, used by the root module and by other auxiliary modules. +The compilation unit in Timber is the module, so modules may be compiled individually (but see below for dependencies). + +

Modules

+ +The syntax of a Timber module is +

+module moduleName where

+   importDeclaration*

+   topLevelDeclaration*

+private

+   topLevelDeclaration*

+ +

+Here, as in many places of Timber syntax, indentation is significant. The import and top-level declarations must be indented at +least one step and be vertically aligned, i.e., the first character of each declaration must be in the same column. +An exception is the (common) case where there is no private part; then indentation can be omitted (and all declarations start in the +leftmost column). +

Module names

+A module has a simple name, which is an identifier starting with an +upper-case letter. Modules are conventionally stored in files of the same name with suffix .t, i.e. +module Dictionary is stored in Dictionary.t. +

+Projects and Timber sites may use hierarchical module names to allow multiple modules with the same name +or to indicate structure e.g. in a library. Thus, module Dictionary may need to be referred to by +clients as e.g. Data.Object.Dictionary; it is up to the implementation whether this module is +stored in Data.Object.Dictionary.t or in Data/Object/Dictioary.t +relative to some installation-dependent notion of search paths. Module hierarchies in Timber have no other significance +than to support organizing and subsequently finding modules in a file system. +

+The module name is given in the header, as described above. + +

Dependencies

+A module may depend on other modules, i.e. use types or values defined in these modules. In a Timber program +the dependency graph between modules must be acyclic; no recursive dependencies are allowed. This means that +modules can be compiled in dependency order: when a certain module is compiled, all the modules it depends on have already +been compiled. A compiler option can make the compiler decide on recompilation order after a system has been changed. + +

Import and use of other modules

+Following the header is a sequence of import/use declarations, i.e. declaration of the modules that the current module depends on. +There are two forms of such declarations: +

Import declarations, exemplified by
+ import Data.Objects.Dictionary
Use declarations, as in
+ use Data.Objects.Dictionary

+Both forms of declaration give access to all exported entities from the named module; the difference is that in the latter case +one must use the qualified name of an imported entity, while in the former case the simple (unqualified) name is enough, unless name +clashes occur. +

+Name clashes are handled as follows: +

Within a module, name clashes are forbidden in the sense that one cannot define two top-level + entities within the same namespace and with the same name. Thus the exported names from a module cannot clash.
Fully qualified names are supposed to never clash, i.e., a Timber installation is supposed to be set up so + that fully qualified module names are globally unique. Thus use of a module can never lead to name clashes + and clashes on import can be resolved by resorting to qualified names.
If a module imports two entities with the same simple name from two different modules, this simple name is not in + scope in the importing module; the qualified names must be used. The Timber compiler emits a warning when such situations + occur.
If a module imports an entity with the same simple name as a locally defined top-level entity, the local definition + shadows the import, i.e. the simple name is in scope and refers to the locally defined entity.

Exports

+ All the entities (types, defaults and values) defined in the sequence of public top-level declarations are exported, i.e. can + be referred to by importing/using modules. Entities defined in the private part are not exported and hence not visible to importing/using + modules. In particular, this means that the type environment of the public part must be closed, i.e. the type of an exported value + must not mention a type defined in the private part. Imported entities are not re-exported, i.e. the import relation is not transitive. + + addfile ./web/pubs.html hunk ./web/pubs.html 1 + + +related publications + + + + +

Related publications

+Peter A. Jonsson and Johan Nordlander, + + Positive Supercompilation for a Higher Order Call-By-Value Language. +To appear in 36th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL), +Savannah, GA, 2009. +

+Johan Nordlander, Magnus Carlsson and Andy Gill, + + Unrestricted Pure Call-By-Value Recursion. +In ACM SIGPLAN Workshop on ML, Victoria, BC, 2008. +

+Martin Kero, Johan Nordlander and Per Lindgren, + + A Correct and Useful Incremental Copying Garbage Collector. +In IEEE International Symposium on Memory Management (ISMM), Montreal, QB, 2007. +

+Johan Nordlander, Mark P. Jones, Magnus Carlsson and Jan Jonsson, + + Programming with Time-Constrained Reactions. +Technical report, Luleå Uniersity of Technology, 2005. +

+Magnus Carlsson, Johan Nordlander and Dick Kieburtz, + + The Semantic Layers of Timber. +In First Asian Symposium on Programming Languages and Systems (APLAS), +Beijing, China, 2003. +

+Johan Nordlander, Mark P. Jones, Magnus Carlsson, Dick Kieburtz and Andrew P. Black, + + Reactive Objects. +In Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing +(ISORC 2002), Arlington, VA, 2002 +

+Andrew P. Black, Magnus Carlsson, Mark P. Jones, Dick Kieburtz and Johan Nordlander, + + Timber: a Programming Language for Real-Time Embedded Systems. +Technical report CSE-02-002, Oregon Health & Science University, 2002. +

+Johan Nordlander, + + Polymorphic Subtyping in O'Haskell. +In Science of Computer Programming, 43(2-3), 2002. +

+Johan Nordlander, + + Reactive Objects and Functional Programming. +Doctoral thesis, Chalmers University of Technology, 1999. +

+ addfile ./web/simplestyle.css hunk ./web/simplestyle.css 1 - +body { + font-size: 12pt; + font-family: helvetica, "lucida grande", sans-serif; + margin: 0; + padding: 2em; +} + +h1, h2, h3, h4, h5, h6 { + font-family: georgia, times, "times new roman", serif; +} + +p,a,ul,li,em,strong,span,div { + font-size: 1em; +} + +p { + width: 37em; +} + +ul, ol { + width: 35em; + margin: 1em 0; +} + +li + li { + margin-top: 1em; +} + +img { + border: 0; +} + +pre { + width: inherit; + overflow-x: auto; + margin-left: 50px; +} + +tt { + margin: 3px; +} + +a:link, a:visited, a:active { + color: #1C5380; + padding: 0.1em 0.2ex 0 0.1em; +} + +a:visited { + color: #584781; +} + +a[href]:hover { + color: #111; +} + +a[href^=http] { +// background: transparent url(data:image/gif;base64,R0lGODlhCQAJAJEAAP///wAAAP///wAAACH5BAUUAAIALAAAAAAJAAkAAAIXlI8ZK8sdGpggWhrAyXVGSVUGh42OIxQAOw%3D%3D) no-repeat scroll right center; +// padding-right: 13px; +} + +a[href$=pdf]:after { +// content: ' (pdf)'; +} + + +div.navbar h3, div.navbar h4 { + margin: 0.5em 0; + text-align: center; +} + +ul.menu { + border-right: 1px solid #ddd; + border-left: 1px solid #ddd; + border-top: 1px solid #f0f0f0; + margin: 3em 0; + padding: 0; + list-style-type: none; + width: 100%; +} + +ul.menu li { + padding: 0; + margin: 0.1em 0; +} + +ul.menu li a { + display: block; + padding: 0.2em 1em 0.1em 0.5em; + text-decoration: none; + background: #fafafa; + color: #222; + border-bottom: 1px solid #ddd; + border-top: 1px solid #fefefe; +} + +ul.menu li a:hover { + color: #000; + background: #FEF7ED; + padding: 0.2em 1em 0.1em 0.55em; +} + +ul.menu li a:active { + font-weight: bold; +} + +table { +// border: 1px solid #eee; + font-size: 0.9em; +} + +th, td { +// border: 0 !important; +} + +th { + font-weight: bold; + font-size: 1em; + border-top: 1px solid #fefefe; + border-bottom: 1px solid #f0f0f0; + background: #FEF7ED; +} + +tr { +// background: #fafafa; +// color: #222; +} + +tr:hover { +// background: #FEF7ED; +} + +TH, TD { + font-size: 1em; +} addfile ./web/stmts.html hunk ./web/stmts.html 1 + + +Statements + + + + +

Statements

+Statements form the bodies of classes. Within the sequence of statements forming a class definition, there may (and indeed, typically +will) also occur definitions of actions and requests, which themselves have statement sequences as their bodies. +

+Statements will typically have side-effects, affecting the state of objects or the external world. This implies that the order of statements within +a sequence is important. Also, for the statement forms that bind variables, the binding affects only the rest of the sequence. +

+The available statement forms are: +

+ State variable initialization
+
```
+  svar := expr
+  
```
+
+ Here svar is a state variable. These have the same syntax as ordinary variables and share namespace, but + there are no rules for shadowing, so a state variable must be distinct from all ordinary variables in scope (and from other, + already defined state variables in scope). The variable + being defined may not occur in the right hand side. Initialization implicitly declares this variable as part of the state of objects + instantiated from this class. +
+ List of bindings. +
These have the same syntax as bind lists in general; they are recursive and within one binding group + order is insignificant (with the + exceptions detailed at the end of the bindings page), but the bindings are only in scope + in the rest of the statement sequence. +
In addition to local bindings as they are used in general, a particularly important case is definitions of actions + and requests (which can only be defined in the statement sequence of a class). +
+ Creation of objects
+
```
+  var = new expr
+  
```
+ The expr must evaluate to a class; the effect is that a new object is created, its state initialized and its + interface bound to var +
The result statement.
+
```
+  result expr
+  
```
+ In the sequence of statements of a class, this must be the last statement. It defines the interface of the class, i.e. how + the variable referring to an object may interact with it. +
Within an action or a request, the result statement indicates termination of the method and the value returned (for + requests; for actions the result is (), the dummy value of type ()). +

+ The forms of statements up to now are the only forms that may occur in the statement sequence at the outermost level of a class; + creating an object + may only involve initiating the state, creating other objects and returning the proper interface. The remaining forms + occur only within methods and procedures. +

+State update.
+
```
+svar (! expr )* := expr
+
```
+The left hand side is here either a state variable or an array L-value (when the svar is an array). Array indexing +is denoted by the ! operator; several indexing operations may occur for multidimensional arrays. The right hand side may +mention this and other state variables.
+Request/procedure call. +
+
```
+pat <- expr
+
```
+Here the right hand side must evaluate to a request or procedure; the statement expresses a call of this method and matching +the pattern against the returned value. +
+The alternative form
+
```
+expr
+
```
+may also denote a request or procedure call where the binding is omitted or an action call (which does not return a value). +
+
After and before statements. +
+
```
+after expr expr
+before expr expr
+
```
+Here the first expr must be a time interval and the second an action; the latter is given a new baseline (the after case) +or deadline (the before case). +
+Conditional statement. +
+
```
+if expr then
+  stmts
+elsif expr then
+  stmts
+else
+  stmts
+
```
+
+The elsif may occur zero or more times; the else part zero or one time. +
+Case statement.
+
```
+case expr of
+  (pat -> stmts)+
+
```
+The alternatives may use guards and/or where clauses just as in function bindings. +
Forall statement. +
+
```
+forall (qual)+ do
+  stmts
+
```
+Here the simplest form of qual is var <- expr, where expr evaluates +to a list. The statement sequence in the body will be executed once for each element of the list, with var bound to +that element. +

+We finish with a simple example. +

+struct Counter where
+  inc   :: Action
+  read  :: Request Int
+  reset :: Action
+
+counter = class
+  s := 0
+  inc = action
+    s := s+1
+  read = request
+    result s
+  reset = action
+    s := 0
+  result Counter {..}
+

+ addfile ./web/summary.html hunk ./web/summary.html 1 + + +Language summary + + + + +

Language summary

+These pages aim to provide a summary of the language constructs of Timber, including +syntax descriptions but with very little of motivation, explanation and examples. +

+They are intended to be useful for a reader who is exploring Timber and wants a reasonably +concise summary of the language. A Timber tutorial, with extensive motivation and examples, +will appear as a separate document. +

+Some syntactic constructions are described in simple BNF syntax, but this document does not give +complete formal syntax for Timber. In BNF descriptions, terminals are in +typewriter font, nonterminals in italics and meta symbols in red. + addfile ./web/tclass.html hunk ./web/tclass.html 1 + + + +Type classes and qualified types + + + + +

Type classes and qualified types

+In mathematics and in most programming languages, + and - denote addition and subtraction; but what should +their types be? Of course, we want to be able to add both integers and floating-point numbers, but these two functions correspond to +completely different machine operations; we may also want to define arithmetic on new types, such as complex or rational numbers. +

+To better understand the problem, consider a function to add the elements of a list of integers to an accumulator. +Assuming that + only means integer addition we could define +

+add :: Int -> [Int] -> Int
+add acc (x : xs) = add (x + acc) xs
+add acc [] = acc
+

+As long as there are elements in the list, we add them to the accumulator and call the function recursively; when the list is empty the +accumulator holds the result. +

But this function makes perfect sense also for floats (or rationals, or complex numbers, or ...) and we would like to use it at +those types, too. One could imagine an ad hoc solution just for the arithmetic operators, but we prefer a general solution. +

+A first step is to introduce the following struct type: +

+struct Num a where
+  (+), (-), (*) :: a -> a -> a
+

+An object of type Num Int has three fields, defining addition, +subtraction and multiplication, respectively, on integers. (Of course, we can construct an object of this type using any three functions +of the prescribed type, but the intention is to supply the standard arithmetic operators.) Similarly, an object of type Num Float +defines the corresponding operators for floating-point numbers. +

+Assume that we have +properly defined numInt :: Num Int. We can then define +

+add :: Int -> [Int] -> Int
+add acc (x : xs) = add (numInt.(+) x acc) xs
+add acc [] = acc
+

+Unfortunately, the first argument in the recursive call now looks horrible. We cannot accept to write integer addition in this way. But there is +at least something positive; we can generalize the type by giving the Num object as an argument: +

+add :: Num a -> a -> [a] -> a
+add d acc (x : xs) = add d (d.(+) x acc) xs
+add d acc [] = acc
+

+We can now use add for lists of any type of objects for which we can define the arithmetic operators, at the expense of passing an extra +argument to the function. +

+The final step that gives an acceptable solution is to let the compiler handle the Num objects. We do this by declaring +Num to be a type class, loosely following the terminology introduced in Haskell: +

+typeclass Num
+

+For such types, the selectors are used without the +dot notation identifying a struct value from which to select. Whenever a selector of a type class occurs in a function +body, the compiler +does the following: +

adds an extra parameter of the type class to the function;
changes the selector occurrences in the function body to a selection from that parameter.
wherever the function is used, adds an object of the proper type as an extra argument. +
changes the type of the function to be a qualified type; the type class occurs as a constraint after \\. +

+Our running example now becomes +

+add :: a -> [a] -> a \\ Num a
+add acc (x : xs) = add (x + acc) xs
+add acc [] = acc
+

+As a convenience, the declaration of the struct type and the type class declaration can be combined into one single declaration: +

+typeclass Num a where
+  (+), (-), (*) :: a -> a -> a
+

+To use function add to sum a list of integers, we could write e.g. add 0 [1, 7, 4]. The compiler must now insert +the extra argument numInt, a struct value with selectors for the three arithmetic operators at type Int. +However, since there might be several objects of type Num Int defined, we must indicate in instance declarations +the objects that are to be used at different types. The definition of the struct value and its instance declaration can be combined +into one declaration. As an example, here is an instance of Num for rational numbers: +

+data Rational = Rat Int Int
+
+instance numRat :: Num Rational where
+  Rat a b + Rat c d = Rat (a*d + b*c) (b*d)
+  Rat a b + Rat c d = Rat (a*d - b*c) (b*d)
+  Rat a b * Rat c d = Rat (a*c) (b*d)
+

+This definition should be improved by reducing the fractions using Euclid's algorithm, but we omit that. We just note that the arithmetic operators in +the right hand sides are at type Int; thus the compiler will insert the proper operations from the instance numInt, avoiding +the overhead of extra parameters. +

+This solution combines ease of use and flexibility with type security. A possible disadvantage is inefficiency; an extra parameter is passed +around. To address this, the user may add a specific type signature; if the user assigns the type Int -> [Int] -> Int to add, +giving up flexibility, the compiler will not add the extra parameter, instead inserting integer operations directly into the function body. +

+Several type classes, including Num, are defined in the Prelude, together with instances for common cases. +

+The compiler must be able to select the proper object of a type class to use whenever a function with a qualified type is used; this choice +is guided by the context of the function application. In certain cases ambiguites can occur; these are resolved using default declarations. +

+Normally, the combined declaration forms are used both for type classes and instances. Separate typeclass declaration of a struct type can only +be done in the module where the struct type is defined. +

Subtyping constraints

+Also subtyping relations may be used as constraints in qualified types. As a simple example, consider the function +

+twice f x = f (f x)
+

+Obviously, twice has a polymorphic type. At first, it seems that the type should be (a -> a) -> a -> a. However, it can be assigned +the more general type +

+twice :: (a -> b) -> a -> b \\ b < a
+

+Types with subtype constraints will never be assigned by the compiler through type inference, but can be accepted in type-checking. + addfile ./web/timberc.html hunk ./web/timberc.html 1 + + +Timber compiler + + + + +

Timber compiler

+This page describes briefly the command line options to timberc, the Timber compiler. +Installation is not described. +

+timberc expects a number of options and a number of files to compile. The most +common uses are the following: +

timberc -c Mod1.t Mod2.t ... +
The given files are compiled (first to C by the timber + compiler, then to object files by the C compiler). No linking takes place. This usage requires that all + files on which the given modules depend have already been compiled. This is the typical way to compile + new modules during the development of a Timber system. Can be modified to option -C to avoid + C compilation. +
timberc --make Mod +
The compiler expects Mod.t to be the root module of a system for the default environment (i.e. POSIX). + All modules in the system are compiled by timberc and gcc as needed and in dependency + order, followed by linking. The executable is called Mod. This option obviates the need of a makefile + to rebuild the system after changes in any modules. Can be combined with --root=name when the name of + the root definition is name (rather than the default root). +
timberc Mod.ti +
Displays the API of module Mod, i.e. all exported kinds, types, defaults and top-level values with their types, + typically in a browser window (installation-dependent). +

+ addfile ./web/time.html hunk ./web/time.html 1 + + + +Time constructs + + + +

Time constructs

Absolute time

+Timber allows explicit expression of time constraints on reactions in +a program. As a basis for this, we assume a notion of absolute or real time, +which progresses independently of program executions. With each action +call in a +program is associated two absolute time instants, the +baseline and the deadline. The intuition is that +execution of the action must not start before the baseline and must +be finished by the deadline. The time interval between these two +instants is the time window of the action. +

+Timber programs cannot express or access absolute time, but the runtime system +has access to a realtime clock and can obtain the current +time.The resolution of this clock is platform-dependent. + +

The type `Time`

+There is, instead, a primitive type Time of +durations, or lengths of time intervals, that may occur in +programs. +Time values can also be computed by the runtime system as the +duration of the time interval between two instants. +

+The type is abstract; Time values can be constructed using the +primitive functions +

+sec, millisec, microsec :: Int -> Time
+

+which expect a non-negative argument. Of course, e.g., +sec 1 and millisec 1000 denote +the same time value. +

+There is a predefined instance numTime :: Num Time, +so time durations can be added and subtracted using +arithmetic notation, as in sec 2 + millisec 500. +Subtraction of a larger value from a smaller yields +time 0 and multiplication is undefined (an attempt to multiply +two time values raises an exception). +

+To deconstruct time values, one uses the primitive functions +

+secOf, microsecOf :: Time -> Int
+

+secOf rounds downwards to whole seconds +and microsecOf returns the fraction, +a value between 0 and 999999. + +

Time constraints

+Time windows of reactions are assigned as follows: +

The time window of a reaction to an external event has + as baseline the time instant when the event occurs, and + as deadline an idealised instant infinitely far into the future. + +
In particular, the start action of a program gets as + baseline the time instance when program execution begins. +
+
When a message without time constraints is sent (i.e., an + plain action is called) from a method with current baseline bl and deadline dl, + the reaction to the message inherits both bl and dl.
+ The rule in the previous item can be changed by explicit + program constructs: +
- The expression after t act + sets the effective baseline for act to the current baseline plus t. +
- The expression before t act sets + the effective deadline for act to its effective baseline plus t.

act

Action

after

before

Special case: if the baseline denoted by an after construct is an already passed time instant, + the effective baseline of the reaction is rounded off to the actual time of the call. +

+ +

The class `timer`

+ As mentioned above, programs cannot access absolute time, + but they can measure durations of time intervals. For this, + they make use of the primitive class timer, + where +

+timer :: Class Timer
+
+struct Timer where
+   reset  :: Request ()
+   sample :: Request Time
+

+ When a new object of class timer is created, it + stores the baseline of the current reaction. When, later, + sample is called, the duration from the stored time to the + current baseline is returned. Calls to reset updates + the stored time to the current baseline. + +

Scheduling

+ Baselines and deadlines provide the basis for scheduling + of Timber programs. The scheduler is preemptive and uses the + EDF strategy (Earliest Deadline First): +

+ At each interrupt (from external sources or internal + runtime system timers) or method termination, the reaction to + execute next is chosen as follows: + Messages with future baselines cannot yet execute and are + stored in a list sorted by baseline with a running timer + that expires at the earliest baseline. Eligible messages are + sorted by deadline and the message with the earliest deadline is chosen + for execution. + addfile ./web/toplevel.html hunk ./web/toplevel.html 1 + + +Top-level declarations + + + + +

Top-level declarations

+The body of both the public and private parts of a module is a sequence of +top-level declarations. These declarations comprise +

Kind declarations (declaring the kind of a type (constructor)). +
Type definitions (data and struct types, implicit struct types and type synonyms). +
Type signatures. +
Function bindings. +
Definitions of instances of implicit struct types. +
Default declarations. +

Types and type declarations

Types and type constructors

+Values in Timber are classified into types. The integer value 7 has type Int, a fact that is expressed +in Timber as 7 :: Int, so :: is read "has type". One seldom adds such explicit type information to expressions +in Timber code, but it is allowed to do so. More common is to supply type signatures as documentation to +top-level definitions, but also these can be omitted, leaving to the Timber compiler to infer types. +

+Timber also has type constructors, which can be thought of as functions that take types as arguments and give a type as +result. An example is the primitive type constructor Request, which takes a type a as an argument and constructs +the type Request a of methods (in the object-oriented sense) returning a value of type a. + +

Kinds and kind declarations

+Timber types and type constructors are classified by their kind. All types have kind *, while +type constructors that expect one type argument (such as e.g. Request) have +kind * -> *. In general, a kind is either * or k1 -> k2 where k1 and +k2 are kinds. A type constructor of kind k1 -> k2 expects an argument of kind k1; +the result is then a type (constructor) of kind k2. +

+The programmer may declare the kind of a type constructor in a top-level kind declaration:

+con :: kind
+

+This is particularly useful when defining abstract data types; in the public part of a module one declares the kind of +an abstract type and the signatures of the operators; the actual type definition and equations are given in the private part. +

+ + + + + +
Examples + Comments
Stack :: * -> * Stacks with elements of arbitrary type
Dictionary :: * -> * -> * Dictionaries storing info about keys
+ + +

Examples +	Comments
`Stack :: * -> *`	Stacks with elements of arbitrary type
`Dictionary :: * -> * -> *`	Dictionaries storing info about keys

Primitive types

+We first describe the primitive types of Timber. In Timber code it is always clear from the context whether +an expression denotes a type or a value, so some types use the same syntax for type expressions as for +values, without confusion. (A beginner might disagree about the last two words.) + +

Primitive simple types

+As part of the language, the following primitive types are provided: +

The type Int of finite-precision integers.
The type Float of single-precision floating-point numbers.
The type Char of characters.
The type Time of time intervals.
The type Bool, with the two values True and False.
The type () (pronounced "unit"), containing the single value (). +
The type OID of object identities, which support test for identity between objects. +

+Literals of types Int and Float are as in most programming languages; integer constants can be +given in octal or hexadecimal formed if prefixed by 0o and 0x, respectively. +

+Time values are expressed using the primitive functions sec, millisec, microsec and nanosec, +which all take an integer argument and return a Time value. Of course, millisec 1000 and sec 1 denote +the same value. +

+Character literals are written within +single quoutes as in 'a' or '3'; common escaped characters are '\n' and '\t' for newline and tab, respectively. (Many other forms of +character literals omitted.) +

Primitive type constructors

+The following type constructors are also primitive in the language. +

Lists.
The type [a], for any type a, contains finite lists of values of type a. + The list [3, 6, 7, 1] has type [Int] and [[3, 2], [4, -1, 7]] has type [[Int]] + (however, see the overloading page for more general types of these lists). +
Tuples.
+For arbitrary types a1,a2,...an, we can form the tuple type (a1, a2, ..., an). +Values use the same notation so (True,'a') has type (Bool,Char). +
Arrays.
+For any type a, the type Array a consists of a sequence of a values, organized so that one can access +all values by index in constant time. Arrays are particularly useful as state variables in objects, where they may also be +updated in imperative style.
Functions.
For any two types a and b, a -> b is the type of functions from a to b. +-> associates to the right, so a -> b -> c parses as a -> (b -> c). +
Either.
+This type could be defined in Timber as +
```
+data Either a b = Left a | Right b
+
```
+
+It is only primitive because of its role in generating default instances.
Classes.
+For any type a, the type Class a contains templates from which one can instantiate objects +with interface of type a. Of particular +interest is the case where a is a struct type with a number of methods manipulating an internal state of the object.
Actions.
+Action is the type of asynhronous methods. An object may offer an Action in its interface; a client who +has access to this interface may send the object an action message with appropriate arguments. The message will, at an unspecified +later point in time, execute the action, with exclusive access to the object's state.
Requests.
+For any type a, Request a is the type of synchronous methods that return a value of type a. +An object may offer a Request in its interface; a client who has access to this interface may then send a +request message with appropriate arguments and wait for the result. Since all methods require exclusive access to the state of the +receiving object during execution, cycles of requests lead to deadlock. Deadlock is detected by the runtime system and an exception +is raised.
Commands.
For any two types s and a, Cmd s a is the type of procedures that can execute in a +state s and return a value of type a. +
Object references.
+For any type a, Ref a is the type of references to +objects with interface of type a. +
The struct type Timer, which is used as interface to the +primitive timers of the language; see the Time +constructs page for details. +

Polymorphic types

+We can now form complex types such as +

+ + + + + +
Examples +
Int -> Int -> Bool
[Int] -> Int
(a -> Bool) -> [a] -> [a]
+

Examples +
`Int -> Int -> Bool`
`[Int] -> Int`
`(a -> Bool) -> [a] -> [a]`

+The two first examples are monomorphic; they involve only known types and type constructors. The third is +polymorphic; it involves the type variable a (a type variable since it starts with a lower-case letter), +that stands for an arbitrary type. A function possessing this type can be used at any type obtained by substituting a type +for a. +

+The type variable a is implicitly bound in such a type expression; one should think of an implicit "for all a" +quantification prepended to the type expression. +

Data types

+The programmer may introduce new ways of constructing data by defining data types. The simplest case is +enumeration types like +

+data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
+

Day

+The constructors may have arguments, as in +

+data Temp = Fahrenheit Int | Celsius Int
+

+Values in type Temp are e.g., Fahrenheit 451 and Celsius 100. There may be one, two or +more alternatives and a constructor may have more than one argument. A data type for a web log entry might be +

+data Entry = Entry IPAddress Date URL Method Int
+

+where a value of type Entry might be +

+Entry "123.456.789.000" (May 29 2007) "http://www.abc.def"  GET 321
+

+given suitable type definitions for the other types involved. Note that the type and the constructor have the same name; +this is OK since types and constructors live in different namespaces. +

+We may also define parameterised data types: +

+data Tree a b = Nil | Branch (Tree a b) a b (Tree a b)
+

+Tree thus has kind * -> * -> * and a value of type Tree String Int is a binary tree with a +String and an Int stored in each internal node. +

+Two different data types may not use the same constructor name; with the above definition, no other data type +in the same module can use constructor Nil. For data types in imported modules there is no problem +if they use Nil; only that the qualified name must be used for the imported constructor. + +

Struct types

+Struct, or record, types collect values bound to named selectors. Declarations have the syntax +

+struct con var* where
+  sig+
+

+ + + + + + + +
Examples +
struct Point where
  x, y :: Int
struct Dictionary a b where
  insert :: a -> b -> Action
  lookup :: a -> Request (Maybe b)
+

Examples +
`struct Point where`
`x, y :: Int`
`struct Dictionary a b where`
`insert :: a -> b -> Action`
`lookup :: a -> Request (Maybe b)`

+An example value of type Point is Point {x=3, y=7}. The order between the fields is not significant, so +Point {y=7, x=3} is the same value. Similarly as for constructors, two different struct types in the +same module may not use the same selector name. +Thus a struct value is uniquely defined by the collection of selectors and the type name can be omitted from the value; +{x=3, y=7} is again the same value. +

+If p :: Point, the selectors are accessed using dot notation, so the two integer coordinates are +p.x and p.y, respectively. +

+A struct type may have any number of selectors and the types of selectors are arbitrary. A struct type may also be parameterised +as shown by Dictionary, a type suitable as an interface to an object that acts as a dictionary, storing information of +type b about keys +of type a. (The result type Maybe b for lookup is intended to capture the possibility that the given +key is not stored in the dictionary; the prelude defines data Maybe a = Nothing | Just a.) + +

Type synonyms

+The user may introduce new names for existing types: +

+type Age = Int
+type IPAddress = String
+type List a = [a]
+type Pair a b = (a,b)
+

+Such definitions do not introduce new types; they can only be helpful to improve program readability. They may not be recursive and +can not be partially applied (i.e., Pair Int is not a legal type constructor). The prelude introduces one type synonym: +

+type String = [Char]
+

Subtyping

Subtyping for struct types

+Struct types and data types may be defined in subtype hierarchies. As an example, we can extend Point: +

+struct Point3 < Point where
+  z :: Int
+

+We define Point3 to be a subtype of Point; for struct types this means that Point3 has all the selectors +of Point and possibly some more (in the example, one more: z). So we have {x=0, y=3, z=5} :: Point3. +A function that expects a Point as argument can be given a Point3 without problem, since all the function can do +with its argument is use the selectors x and y, which are present also in a Point3. +

+As another example we might split the dictionary type into two: +

+struct LookupDict a b where
+  lookup :: a -> Request (Maybe b)
+
+struct Dictionary a b < LookupDict a b where
+  insert :: a -> b -> Action
+

+In a program we may build a dictionary dict :: Dictionary a b and then send it to an unprivileged client typed as a +LookupDict; the client can then only lookup information, not insert new key/info pairs. +

+A struct type may have several supertypes; given a struct type +

+struct Object where
+  self :: OID
+

OID

+struct Dictionary a b < LookupDict a b, Object where
+  insert :: a -> b -> Action
+

+to get the same effect as before and, in addition, the possibility to test whether two dictionaries are the same (meaning same object, +not equivalent content). +

Subtyping for data types

+We can also define hierarchies of data types, but these are completely separate from any hierarchy of struct types; a data type +can never be a sub- or supertype of a struct type. For data types we may add new constructors to get a supertype: +

+data CEntry > Entry = Corrupt
+

+Type CEntry adds another constructor to the type Entry defined above; a CEntry is either a proper +entry as above or Corrupt. A function that is defined to take a Entry as argument cannot accept a CEntry; +it may stumble on a Corrupt entry. The converse is OK; newly defined functions on CEntry values can happily +take an Entry; they will not have to use their Corrupt case. + +

Subtyping among primitive types

+The following subtyping relations hold between primitive types:

+Request a < Cmd s a
+Action < Cmd s Msg
+Ref a < OID
+

Johan Nordlander	Björn von Sydow	Andy Gill
Per Lindgren	Magnus Carlsson	Pawel Pietrzak
Viktor Leijon	Peter A Jonsson	Andrey Kruglyak
Simon Aittamaa	Johan Ericsson	Jimmie Wiklander

Patterns and bindings

Patterns and pattern matching

Bindings

Default declarations

Expressions

Layout-sensitive syntax

Basic forms of expressions

Classes, actions and requests.

Further forms of expressions

Timber for Haskell programmers

Introduction

Timber for Java programmers

Lexical structure

Comments

Names

Simple names

Precedence and associativity

Qualified names

Language summary

The POSIX environment

Programs

Modules

Module names

Dependencies

Import and use of other modules

Exports

Statements

Type classes and qualified types

Subtyping constraints

Timber compiler

Time constructs

Absolute time

The type Time

Time constraints

The class timer

Scheduling

Top-level declarations

Types and type declarations

Types and type constructors

Kinds and kind declarations

Primitive types

Primitive simple types

Primitive type constructors

Polymorphic types

Data types

Struct types

Type synonyms

Subtyping

Subtyping for struct types

Subtyping for data types

Subtyping among primitive types

Counter

Variation

Echo2

Echo3

EchoServer2

EchoServer

Echo

MasterMind

MasterMind

Primes

Primes

Primes

Primes

Primes

Reflex

Timber examples

Timber examples

Counter

Variation

Echo2

Echo3

EchoServer2

EchoServer

Echo

MasterMind

Primes

Reflex

Advanced type system features

Patterns and bindings

The type `Time`

The class `timer`

The type `Time`

The class `timer`