Oh Haskell

O'Haskell is a concurrent, pure ObjectFunctional variant of HaskellLanguage. It appears to be a good example of a MultiParadigmProgrammingLanguage.

Home page: http://www.math.chalmers.se/~nordland/ohaskell/

Based on http://www.math.chalmers.se/~nordland/ohaskell/rationale.html , its concurrency model seems to be similar to the ActorsModel. Its most interesting feature seems to be the approach to state, which is an extension of the normal use of monads:

Monads have been successfully utilized to incorporate a quite diverse set of classically imperative features in Haskell, including traditional I/O [20], graphical user interfaces [24, 25], first-class pointers [20], concurrent processes and synchronization variables [13], and exceptions [26]. The common denominator in all these proposals is the unifying property of a stratified semantics, that limits the effect of imperative commands to the top-level of a program, while leaving the purely declarative semantics of expression evaluation unaffected. This means that a monadic command under execution may very well request the evaluation of an expression, but an expression being evaluated can never trigger the execution of a command.

O'Haskell brings the world of object-based concurrency into the realm of monadic FunctionalProgramming. Compared to other monad-based Haskell extensions, O'Haskell represents a higher level of abstraction, by its use of objects instead of pointers, and methods instead of peeks and pokes as the basic imperative building blocks. The high-level flavour of O'Haskell is also evident in its syntax for MonadicProgramming, that improves on Haskell by also taking the need for unconvoluted use of assignable state variables into account.

The essence of the monadic approach is the insight that doing something and merely thinking about doing something are radically different activities. Translated into programming terms, this means that an imperative command is also considered to be a first-class declarative value, although a value of an abstract type (the monad) that just represents the hypothetical effect of a command, should it ever be executed. Command values can thus be declaratively combined, named, parameterized, and calculated with just like any other value, since the evaluation of a command expression is kept entirely distinct from the actual realization of the effect it represents.

All commands in O'Haskell, including those that refer or assign to state variables, enjoy the status of FirstClass values. Furthermore, since any command can be individually named, the name of a method invocation may equally well be considered the name of the actual method it invokes, just as the name of an object creation command may be identified with the class of objects it instantiates. Hence we are able to promote even methods, as well as object templates, to full-blown value status in O'Haskell (O'Haskell actually uses the term template instead of class to avoid confusion with the established Haskell concept of type classes).

O'Haskell has not seen a release since 2001 (and the link at the top of this page is now defunct). The Timber language is a direct descendant of O'Haskell that has dropped non-strict evaluation and focuses on event-driven systems.

WayBackMachine? linkhttp://web.archive.org/web/20090517021445/http://www.cs.chalmers.se/~nordland/ohaskell/ Timberhttp://www.timber-lang.org/

CategoryProgrammingLanguage CategoryConcurrency MessagePassingConcurrency CategoryHaskell DeadLanguage