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 type classes.
- 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.