HAO - A Programming Language

(Named for Hao Wang, a notable 20th Century logician.)

Design criteria:

An imperative language with strong, static, implicit typing.

From Lars Wirzenius:


  I'd like to find a new programming language for general purpose
  programming. Currently I use Python and I like it quite a lot, but
  I'm not entirely happy about its performance, and I'd also like
  static typing. It is good for your mind to experiment with other
  languages, even if you don't adopt them into your permanent
  toolbox. Each new language brings with it new ways of thinking about
  programming and that alone makes learning them worthwhile, and
  except for Hedgehog Lisp I haven't learned any in quite a long time.

  To make the search more concrete, I thought I'd write down a
  wishlist. Some wishes for the language itself:

    * Static typing with type inference (if inference is the word I'm
      looking for). I don't want to declare the type of local
      variables, since the compiler should easily be able to figure
      those out by itself. Declaring types of functions or methods
      should be enough. Preferably even those should be optional,
      since small quick-and-dirty programs do fine without any
      declarations at all.

    * Small, simple, beautiful, orthogonal. Few special cases in
      syntax or semantics.

    * Powerful, meaning that it is possible to express complicated
      processing with fairly little code. A very high level language,
      in other words: more like Lisp than like C.

    * Low level detail available on request. When I do want to
      manipulate single bits in memory, I want to be able to do it.

    * Functional or object oriented. I currently prefer the functional
      paradigm, but I could live with the object oriented one.

    * A module system that scales up to very large programs and also
      easily allows huge number of third party libraries. Python has
      this, with its configurable search paths for modules and
      hierarchical module name space. C has a flat name space and
      doesn't scale up anywhere near as well.


Design ideas:

  - An "imperative" type integrated with Pascal-like statements,
    modelled after Haskell IO monad.

  -