So which some existing syntax to start with:
BETA ? SELF ? CECIL ? Dylan ? LISP ? Haskell ? CAML ? SML ?
C ? Perl ? Python ? Icon ? Oberon ? FORTH ?
Esperanto ? Latin ? French ? English ?
HLL-
The HLL- will be the initial implementation for the HLL,
written as s-exps interpreted by a program written in Scheme.
The HLL- will basically have all Scheme constructs,
with ones like car and cdr being deprecated,
and support for the number type tower being postponed,
while some extensions will be added:
annotations,
first-class environments,
a reflective interpreter,
a CPS macro system,
a pattern matching system,
a module system.
Features of the full HLL it won't have are
arbitrary syntax (arbitrary s-exp syntax only),
weak pointers (R4RS Scheme doesn't support them) with finalizers,
modules to define LLL types, etc.
But the compiler ought to eventually support them.
- Objects
- Attributes
- Context
- Active annotations
- Access rights
- Typing
- Proofs
- Security
- Compactness
Standard Basic constructors
- Applying Functions
- Abstracting terms
- Defining typed constructors
- Evaluation strategy
- .....
Standard Library of language extensions
That's worth a whole subproject...
Syntactic Difficulties
- The most difficult here is to agree.
- We must keep the syntax as simple as possible.
- It must also be compact, with no unneeded redundances.
- redundances are allowed to verify structure matching as in
- begin ... end
- if ... then ... elif ... elseif ... else ... {endif}
- for ... in ... do ...
- the sources must be human-writable and human-readable.
- What about having a mode where indentation is a structure indicator ?
- We may embed any syntax in any other with standard tools.
- What syntax for macros and reflexivity ?
- Particularly, how to export/import modules without importing the
higher-order parts of the module (defining words)
- Now, when there is some higher-order rewrite (say, some object
being redefined), how determine simply what objects get
rewritten, and which use the old version ?
Particularly when it's some extension...
- There should be some clear yet quick way to differentiate the
refinement of some existing object from the defition of a new one.
- I propose we define some generic way to define and use higher-order
modules (i.e. you can define objects, but also
meta-objects/grammar rules/defining words, etc).
Then we can have some simple languages (FORTH, Scheme, SELF, Haskell)
implemented as simple modules.
To Do on this page
Make first proposals.
Allow meaningful indentation on any syntax
Think about how to embed syntaxes in each other
Settle full HLL syntax.
Be faithful to the semantics.
Wait for feedback, as usual.
See the Tunes HLL Semantics.
Back to the Tunes
HLL Subproject.
Page Maintainer:
Faré
-- rideau@clipper.ens.fr