Forth Convert `not` from native to built-in.

C++ Convert `< > >= list` from native to built-in.

Converting `map` is less trivial.

Merge pull request #357 from bjh21/bjh21-minor-fixes

Another round of minor doc/test fixes

step 7 test: Correct a heading to match contents.

'first' and 'rest' applied to vectors are now tested in step 8, not step 7.

guide.md: Move description of 'sequential?' to a more logical place.

It's still a deferrable part of step 9, but now it's listed with the
other vector-related functions rather than after the hash-map-related
ones.

step9: Don't use vectors in a non-deferrable test.

According to the guide, vectors are deferrable until step A, so use
(nth () 1) in place of (nth [] 1) as a form that will generate an error.

step9: Make test of throwing a hash-map deferrable.

According to the guide, hash-maps are deferrable until step A.

Merge pull request #354 from asarhaddon/simplify-core-mal

Trivial simplifications in core.mal.

Merge pull request #356 from asarhaddon/swift4-duplicate-lines

swift4: remove duplicate definition of load-file

swift4: remove duplicate definition of load-file

Trivial simplifications in core.mal.

Replace many (= (count xs) 0) with (empty? x).

Stop definining 'not', 'or' and 'cond' in core.mal, they are defined
in the process steps.

In 'some', avoid computing the same result twice.

Explain the final nil evaluation.

Merge pull request #355 from asarhaddon/improve-ada.2

Clarify and optimize ada.2.

Clarify and optimize ada.2.

Makefile:
Drop OPT and -gnat2020, not used anymore.
Simplify file list now that each unit has a body.

README:
Remove obsolete items.

Global:
Restrict most pointers to a provable non-null value.

Types: merge intermediate Types.Mal into the Types package.  (the
intermediate package was created in order to prevent a circular
dependency, but is not needed anymore).
Most of the noise in the diff is caused by this change.
This allows to remove most Elaboration pragmas.
Declare most types abstract in the visible part,
enforcing the use of the constructor outside the declaring package.

Envs:
Replace the Get recursion with a more efficient loop.
Use MAL objects as key, string pointers do not change speed.
This delegates some checks from the step files.
Split the constructor and Set_Binds, so that an existing environment
can be reused during TCO.

Err:
Attempt to group the calls.
Avoid computing the message when the assertion holds.

Fns:
Declare and use the eval callback only here.
Separate function and macro interfaces.
Keep a reference to the provided parameter list instead of copying them.

Garbage_Collected:
Make explicit that Keep is not inherited.

Printer:
Remove obsolete inline indications and redundant Print_Function helper.

Maps:
Provide a cleaner interface copied from standard library.

Sequences: stop encapsulating the implementation because of the
performance hit.

Steps:
Move map and vector evaluations into separate functions for readability.
Replace return blocks with normal blocks (MAL values are not finalized
anymore).
Rename standard arrays instead of sequence_ptr when possible.
Remove some duplication and indentation from the apply phase.
Move the frequent special forms in front of the test cascade.
When an environment has been created in the same Eval, reuse it.

Strings:
Use the same garbage-collected storage model for all strings.
This seems faster than the default (mutable) string types.
Hide most of the implementation to avoid leaks.

Symbols: stop ensuring unique allocation of symbols. The reduced
garbage collection and comparison time was compensed by the
maintainance of a global hash.

Merge pull request #353 from bjh21/bjh21-minor-fixes

Minor doc/test fixes

Guide: when introducing read_atom, don't mention complex types.

Vectors, hash-maps, and atoms wouldn't be read by read_atom anyway.
Atoms don't even have a read syntax.  While I'm there, also correct
which step keywords turn up in (step A, not step 9).

Step 6: Make tests of '*ARGV*' deferrable.

The Guide says that '*ARGV*' is deferrable at step 6.

wasm: wax runtime. Use WASI preopen process.

Add wasi-sdk to Dockerfile to be able to compile C code to wasm that
uses WASI API calls.

README: add webassembly embeddings/runtimes.

wasm: Support/add wasmtime runtime. WASI platform.

wasm: use wam-1.0.8 which supports new binaryen.

New binaryen doesn't allow data section to contain multiple strings to
be concatenated together any more. So wamp-1.0.8 does the
concatenating for it.

wasm: direct platform, wam memory

- Rename platform_os.wam to platform_direct.wam and update the direct
  interface to use printline instead of fputs/stdout.
- Update to wamp 1.0.7 and new memory/memoryBase semantics: in
  platform_direct and platform_libc, import memory and memoryBase
  rather than relying on wamp to add it because wamp add direct memory
  and memoryBase defintions (not imports) if the program doesn't
  already define or import memory/memoryBase.
- Simplify entry point logic by moving it into the platform files.

README: reorganize slightly.

Move external implementations and other mal projects above the long
implementation details section. The implementation details are linked
to from the overview section so it's fine to have that lower on the
page.

guide.md: In step 1, correctly state how long strings can be deferred.

guide.md: Properly escape a '<'.

Merge pull request #352 from bjh21/bjh21-defer-strings

Mark step 4 tests that use strings as deferrable.

Mark step 4 tests that use strings as deferrable.

Strings are deferrable until step 6, so tests of string functionality at
step 4 should be marked as deferrable.  A couple of tests just use
strings as convenient constants to return or print.  In those cases,
replace the strings with integers rather than deferring the whole test.

Merge pull request #351 from bjh21/bjh21-no-vectors

guide.md: Don't use vectors in step 4 when they're still deferrable.

guide.md: Don't use vectors in step 4 when they're still deferrable.

Vectors are deferrable until step A, so the manual tests in step 4
shouldn't use them.  Replacing them with lists works.

FAQ: answer bang/star question. Misc cleanup/updates.

graph: update collected data with ada.2 updates.

graph: remove unnecessary popup line breaks.

guide.md: fix cheatsheet and language rank links.

Merge pull request #348 from asarhaddon/ada.2

ada.2: fix memory leaks with garbage collection. Various simplifications.

ada.2: fix memory leaks with garbage collection. Various simplifications.

Cyclic references were never deallocated by reference conuting.
Symbols cannot create cyclic structures and are less frequent (one
allocation per symbol), keep reference counting for them.

This slightly improves performances even though many previous
optimizations are removed (environment stack, reuse of memory).

Step caching hash of symbols. This does not seem to improve
performances. Hashing them instead of ordering them does.

Define Repl in the step file instead of globally. Move the eval
built-in function from core into the step file.

When possible, pass Ada records instead of explicit pointers.

In the reader, construct more objects directly as described in the MAL
process, reserve the buffer for sequences and maps

In eval, iterate on vectors without delegation. The increased
complexity was not improving performances.  Keep demonstrating Ada
type-safe genericity for maps, where iterating outside Types.Maps
would be less easy and/or efficient.

In quasiquote_list, concatenate in one buffer instead of allocating a
list for each element. The buffer may be reallocated behind the
curtain, but not once per element anymore.

In environments, illustrate tail call optimization when recursion is
more readable than a loop.

graph: add ada.2, update perf numbers.

README: fix anchor to ada.2

README: add ada.2

Merge pull request #345 from asarhaddon/ada.2

Ada.2 distinct Ada implementation

README: link to malcc blog post.

ada.2: fix reference count for envs and IO error propagation for slurp.

First fix also allows -gnatp compiler option.

Add assertions and improve dumps in environments.

graph/README: fix code quoting.

graph: sync notes with code updates.

Graph: change X-axis default to GH pushes.

This is the option with the most languages that have data.

Add GH Pull/Push, StackOverflow tags, README.

- Add GitHub/GitHut pull requests and pushes.
- Add StackOverflow tag counts (this also involves some hard-coded
  rollup of certain tags).
- Add README with update instructions.
- Move graph specific data mangling from collect code to graph
  rendering code.

Ada: fix accidental build breakage.

Move web files into docs/. Build docs/web/mal.js

To update the docs/web/mal.js script run `make -C js web/mal.js` from the
top-level (js/web is a symlink to docs/web).

Popup caveats/notes. Dynamically generate controls.

Stats collection script, dynamic scatter plot page

README: order and names updates.

Convert to loccount based stats calculation.

ada.2: remove -gnatp optimization, which crashes the perf test.

ada.2: add Dockerfile from kanaka

ada.2: spring cleaning before final pull request.

Two changes require approval.

* The 'do' special becomes a built-in function similar to first. This
  small change reduces the complexity of eval.  The last evaluation
  cannot benefit from TCO, but the performance change seems invisible.

* read/eval/print acts on each item found in the input string, as if
  they were enclosed with (do ..). The guide does not specify what
  should happen to text following the first AST, and this change actually
  simplifies some things (like dealing with zero AST).
  The read-string built-in function only returns the first AST,
  as changing this would be much more intrusive.

Other changes seem straightforward.

Global:
* Ada 2020 target assignments (like +=, but more general).
* Use Constant_Indexing aspect for sequences, so that they can be
  indexed in source code like native arrays.
* consistency renamings.
  'fn' does not include built-in functions, 'function' does.
  'list' does not include vectors, 'sequence' does.

Move error handling to a separate package.
* This simplifies code everywhere else.
* Uncaught expressions now report a stack trace.

Types:
* Count allocations and deallocations, check that counts match.
* Share more code between functions and macros.

Core:
* Replace the Core.Ns function returning an array with a procedure
  (The intermediate object was preventing the reference counting code
  from deallocating some unused objects).
* Implement Prn with Pr_Str.

Printer:
* Change the profile so that the caller spares some allocations.

Reader:
* Share a single buffer of mal values between all recursions.
  This significantly reduces the stack footprint.

Steps:
* Fix implementation name (ada.2) in the startup script.
* Let environment variables trigger debugging information.

rexx, ruby: remove extraneous mal files.

ada.2: add to .travis.yml

ada2: rename to ada.2

ada2: give an explicit prefix to fields in record invariants.

This hopefully fixes the build with gnat-4.9.

ada.2: rewrite the reader, for readability and efficiency.

Use character sets and other language tools to delimit tokens.
When possible, only test each input character once.
Give verbose descriptions to subprograms.
Simplify with one global variable instead of two.
Improve reporting of ignored trailing items in input.

ada2: replace a tail call with a jump in macroexpansion.

ada2: fix formatting and typos, add comments, check more errors.

Only attempt to spare a recursion after step5, this is more consistent
with the process.

Improve conformity with the MAL process, performance and readability.

Conformity:
Move readline to readline.ads and drop the Interactive_Loop subprogram.
Let the main Read and Print functions do input/output.
Rename environments.ads to envs.ads (the name of the eval parameter
seems more important).
Move association of formal and actual parameters to the env "constructor".
Use the documentation names whenever possible (especially, make calls
to Eval where they are expected and explicit the parameters).
Iterate on a NS structure provided by Core, as per the process.
Use similar method names for Envs.Ptr and Envs.Closure_Ptr,
as the difference is an implementation detail.

Performance:
Move Map into list methods, swap into atom methods.
Pass formal parameters as an array of symbols on the stack,
instead of a MAL list.

Readability:
Replace some one-letter names.
Use renamings when the lines become too long.
Split Pr_Str in small subprograms.
Declare the access to built-in functions in Types.Mal.
Consistent names.
Move redundant comments into README.

Various cosmetic improvements inspired by adacontrol.

In Printer, Reader and Quasiquote: move subsubprogram into the
subprogram calling it: this improves the readability and spares some
adjust/finalizations.

Force elaboration of Environments and Symbols before Core.
Move some use clauses to the minimal scope requiring them.
Remove some name clashes.
Format more consistently.
Add comments to distant 'begin' keywords.
Give explicit list of remaining choices in crucial case statements.
Remove unneeded parenthesis.
Avoid unneeded exceptions.
Explicit some initial values.

Major rewrite, improving style and improving performances.

Another Ada implementation.

Merge pull request #344 from LispLY/add-swift4

Add swift4 implement

clean-up

Update readme and .travis.yml to add swift 4.

remove auto-generated copyright declarations.

Update Makefile

add swift4 impliment.

Merge pull request #343 from bendudson/nasm-catchless-try

NASM: Add catchless try to step 9 and step A

Push and pop environment in catchless try

Need to remember to save and restore R15 with the
environment pointer.

Add catchless try to step 9 and step A

(try* A) evaluates A without setting an error handler.

elixir, elm, erlang: Support catchless try*.

cpp, racket: Support catchless try*

objpascal, r: Support catchless try*.

crystal, kotlin, mal, scala: Support catchless try*

basic: support catchless try*

Ignore step5 excludes during REGRESS too.

elisp: A list of cadr is its cdr

elisp: Avoid conflict by loading libs from mal/

forth: Support catchless try*

awk: Support catchless try*

rexx: Support catchless try*

logo: Support catchless try*

d: Support catchless try*

fantom: Support catchless try*

skew: Support catchless try*

tcl: Support catchless try*

vhdl: Support catchless try*

README: language list to table with anchor links

elisp: Get rid of load-relative hack

elisp: Relax version RE check

elisp: Disable curved quotes to fix test rig fails

elisp: Get rid of newline hack in printer

elisp: Drop unused type definition

elisp: Reraise error correctly in try*

README: add Tim Morgan (malcc) github user.

README: better title "Other mal projects"

README: link to Tim Morgan's malcc project.

Resolves https://github.com/kanaka/mal/issues/342