Re: Standard Haskell: More lexical/syntactic issues (from Alastair Reid)

[Einar Wolfgang Karlsen]

Frank A. Christoph wrote:

>If you want a functional scripting language with H-M type inference and
type
>classes and monads, that's great, but maybe it should be something separate
>from Haskell.

Haskell is, according to my experiences with tool integration, the
ultimate scripting language around, and for several reasons:

1) Can be compiled or interpreted (no reason to rewrite your glue
   to get a fast production system)

2) Computations as first class, strongly typed values with loads of
   combinators for scripting the world with less code.

3) Extensible with new computations and combinators (BYO computational
   model so to say, such as computations for constructing HTML docs
   using a combination of the IO monad and a state transformer monad,
   or an approach to concurrency like CML's implemented on top of
   Concurrent Haskell) 

4) Extensible through foreign language interfaces like Green Card

5) Excellent support for concurrency, e.g. in the style of CML, which
   makes the (multi-threaded) glue appear at a very high level of abstraction.

6) Excellent support for string manipulation (map,fold,filter,++ ..)

7) The parsing/unparsing plumbing can be hidden by instantiations of class Read and 
Show

8) Superb features for parsing messages and output generated
   by controlled tools (using Meurig Sages regexp library or Happy)

9) The type of local names do not need to be declared due to type inference.

10) Semicolons can be omitted by careful use of the layout rule

11) Parameters to a function call can be given without parenthesis.

(9) - (10) are typical "features" of a scripting language that we
get for free in Haskell. What is "missing" is things like unquoted strings
like in Tcl (they soon turn out to be a real pain in the neck) or functions
with variable number of arguments (i.e. default expressions as in Ada).
I remember to have seen type systems for ML providing the last feature.

Other features that can contribute according to my opinion: reflection
in the sense of e.g. APL, i.e. an

        eval :: String -> a

operator which could be useful when embedding Haskell logic in other
programs, i.e. by letting Hugs run as an execution enginee controlled
by a foreign tool. Existential types and extendable record types would
be great as well in setting up abstractions such as generic event
brokers and local name servers. They would also come in useful in
constructing user interfaces for collections of heterogeneous objects
(drag&drop areas for example).

Having spend the last 3 years of my professional (and to some extent
private) life integrating tools using Haskell, I'm (almost) perfectly
happy.

Einar

BTW: Moreover, I strongly promote to incorporate fully orthogonal
persistence. Sic!