perl: Abolish _assoc_BANG.

_hash_map and assoc both get simpler by not using it.

perl: Fold some simple core functions into %core::ns.

perl: Tidy up whitespace in table of core functions.

perl: Fold _dissoc_BANG into dissoc and simplify.

I particular, Perl allows for batch deletion of hash elements, so we can
delete all the unwanted keys at once.

perl: Use List::Util::pairs instead of "for (;;)" in 'let*' and 'assoc'.

basic: args file that doesn't rely on return value.

Instead, the file itself does the def of -*ARGS*-. The behavior that
the final value of a loaded file is returned is not necessarily
something we want to assume.

Merge pull request #430 from bjh21/bjh21-perl

perl: Idiomaticity improvements (and some bug fixes too)

perl: Clone functions before turning them into macros.

This ensures that the original function can still be used as a function
if need be (and fixes a soft test failure).

perl: Overload '@{}' and '%{}' on Nil.

This means that various core functions that used to special-case $nil
can now just treat it as a list or a hash-map and it will behave like
one.

perl: Take advantage of all mal values' being true to simplify code.

Where a function retrieves a mal value from a collection, use '||' to
provide the default case rather than checking the index or hash key in
advance.  This requires that all mal values (even $false) be true in
Perl, but EVAL already requires that.

perl: Replace 'scalar(@x) > 0' with simply '@x'.

Using an array in a boolean context to check if it's non-empty is a
common Perl idiom.

There are still explicit uses of 'scalar' to get the precise length of
arrays, because I think the implicit behaviour there might be confusing.

perl: Remove a completely useless use of 'scalar'.

perl: Don't use regexps in 'when' clauses to match fixed strings.

perl: Replace %core::core_ns with %core::ns.

This follows the naming scheme recommended by the guide, and seems
natural in Perl.

perl: Turn $core_ns into %core_ns.

I found myself assuming it was the latter, which is a pretty good sign
it's unidiomatic.

perl: Don't accidentally put a load of rubbish in $repl_env.

In Perl, iterating over a hash gets you both the keys and the values, so
you need to explicitly use 'keys' if you only want the keys.

perl: Stylistic cleanup of indirect function calls (apply, macroexpand, etc).

Generally use temporary arrays and "shift" rather than slicing, and
leave out braces on dereference operations where that's sensible.  I
haven't used the $f->{@args} syntax because I think &$f(@args) is
clearer.

perl: Clarify and slightly simplify 'conj' implementation.

It was confusing having $lst and $new_lst which could potentially be
vectors, so call them $seq and $new_seq instead.  Also use 'shift' to
pull the first argument off @_ and then re-use @_ rather than using an
additional variable.

perl: Simplify definition of 'apply'.

Rather than mucking about with slices, just use 'shift' and 'pop' to
extract the first and last argument.

perl: Unwrap many core functions.

The change of calling conventions meant that many of the core functions
were now trivial wrappers around their implementations.  Unwrap them,
reducing the number of layers of function call required.

perl: Change calling convention to use variadic functions.

Till now, the arguments to each function at the mal layer were passed to
the corresponding function at the perl layer as a single List argument.
This necessitated a lot of dereferencing in the core functions and was
also contrary to the process guide which recommends using variadic
functions.

Since perl functions are intrinsically variadic, this change makes the
code somewhat simpler, and enables further simplifications.

perl: Simplify dereference overloading of FunctionRef.

It now just pulls out the 'code' field rather than indirecting through
the 'apply' method, which in turn means that the 'apply' method can be
removed.

perl: Make HashMaps look like hashrefs by overloading '%{}'.

The fact that HashMaps actually are hashrefs necessitates a few "no
overloading" pragmas to allow access to the implementation, but this
fiddliness is outweighed by the improvements everywhere else in the
code.

perl: Make atoms look like scalar refs by overloading '${}'.

This reduces the number of things that need to know about '->{val}'.

perl: Fix a couple of lurking occurences of ->{val} on Sequences.

perl: Use constant string matches for matching symbols, not regexps.

perl: Remove unnecessary pragmata allowing use of given/when.

Some files no longer use them at all.

perl: Fix a lurking 'ref' that should have been 'isa'.

perl: Replace most remaining uses of "ref" with "isa".

The hold-outs are testing incoming Perl values from interop (fine),
checking if some things are a reference at all (also fine), and
comparing the types of objects in _equal_Q() (slightly iffy).

perl: Bless all coderefs used as mal values.

They're all blessed into a new class, CoreFunction, and everything that
used to look for CODE now looks for CoreFunction instead.

perl: Convert metadata access into a method.

This allows for having it work differently on core functions.

perl: Support (and use) '&{}' overloading on Function and FunctionRef.

This means that all kinds of function can be called as though they're
coderefs, whether or not they actually are, meaning fewer switches on
the internal types of functions.

perl: Use Perl's flexible quoting operators when embedding mal code.

This allows us to avoid the need to backslash embedded apostrophes
and quotation marks.

perl: Much less complicated implementations of 'cons' and 'concat'.

perl: In step 2, initialise $repl_env all at once.

That's what the guide suggests we should do, and is more idiomatic perl.

perl: Avoid using "ref" to check the type of objects.  Use "isa" instead.

This ensures that we handle subclassing correctly.  Unfortunately this
breaks a little in the area of core functions because they're passed
around as unblessed code references.  I think this will be best fixed by
blessing them.

perl: Explicitly detect empty lists before macro expansion.

A future change will mean that implicitly handling this case won't work.

perl: Take advantage of the overload of '@{}' on Sequences.

This is mostly replacing @{$X->{val}} with @$X.

perl: Overload '@{}' on mal sequences and thus remove Sequence::nth.

I think it's more idiomatic perl for mal sequences to look like listrefs
even if under the covers they're actually hashrefs.  It means that
indexing doesn't need an explicit method call, so A->nth(B) becomes
A->[B].

perl: Factor out common features of Vectors and Lists into a superclass.

The two classes are identical apart from their names.

guile: disable non-recursive test.

The non-recursive TCO test case specific to guile causes regress mode
to fail when using stepA to regress step5 because stepA does not have
the artificial stack size restriction contained in only step5. There
is no reason to artificially restrict implementation call stack in
order to pass the non-TCO calls so just remove that guile specific
test case.

Regress test of deferrables. Fix dart, factor.

Add a regression run to Travis that enables hard deferrables but
omits optionals so that we can test to make sure that all the
requirements are met for self-hosting in stepA.

Cleanup up some of the soft/deferrable/optional markings.
Deferrables are what will be needed eventually to self host but aren't
needed for the immediate next steps. Optional aren't even needed for
self-hosting but are nice things to have.

Also:
- Sync dart step9 and stepA with step8. Do not eval macroexpanded
  forms in macroexpand form.
- Fix stepA of factor which was missing some fixes from step9.
- Increase test timeouts in top-level Makefile for guile and io.

Merge pull request #427 from dubek/ocaml-fix-unterminated-string

ocaml: Fix reading of unterminated strings that happen to end with '"'.

Merge pull request #428 from dubek/io-fix-escape-slash

io: Fix unneeded escaping of forward slash

io: Fix unneeded escaping of forward slash

Instead of using Io's `asJson` method which escapes forward slashes,
implement our own string escaping code so it fits the Mal requirements.

The relevant step1 test was modified from soft to hard.

ocaml: Fix reading of unterminated strings that happen to end with '"'.

Issue #359

Merge pull request #426 from dubek/extra-step4-tests

tests: step4: Add optional list and vector equality tests

Merge pull request #425 from dubek/io-fixes

Io fixes

tests: Add optional list and vector eqaulity tests

io: Atoms can have meta

io: Don't mutate existing function when defining a macro

io: keyword and symbol accept a keyword/symbol argument

io: Fix list and vector equality

Previously we relied on Io's list equality, but this doesn't hold for
non-primitive elements in the list, so (= [:abc] [:abc]) returned false.

Merge pull request #424 from asarhaddon/typo-test-alias-hacks

tests/lib: fix path in test-alias-hacks, use load-file-once

tests/lib: fix path in test-alias-hacks, use load-file-once

Merge pull request #423 from asarhaddon/trivial-from-401

Trivial commits from 401

Merge pull request #361 from asarhaddon/exercise-native-implementations

Draft exercise, native implementations of some built-in functions.

scheme: allow keyword argument for keyword built-in

tests: non alphanumeric characters in input

Make: remove part of EVAL breaking # and $

step0: no MAL character must break the interpreter
       (soft) no printable ASCII character either

step1: no MAL character must break strings
       (soft) no printable ASCII character should break strings
       (soft) no character should break comments

step6: redo step1 tests for comments inside read-string, as new
       problem may occur with line breaks and escape characters of the host
       language.

elixir: add catch-all stanza in with-meta

tests: remove commented test for 10th Fibonnacci number

tests: soft-tests for keywords (instead of comments)

tests: soft-test metadata for atoms

make/readline (trivial): split the line containing 7 shell commands

lib/perf.mal (trivial): println instead of prn and str

ada.2: let keyword function accept a keyword argument

Merge pull request #420 from asarhaddon/load-file-once

lib/load-file-once: basic support for multiple imports

exercises: progressive solution for let*

Merge pull request #422 from bendudson/nasm-fix

NASM: Fix bug in str when appending empty arrays

Fix bug in str when appending empty arrays

The `slurp` function can produce strings which end with an empty
Array, if the input file is a multiple of the Array size. When
appending such a string, `string_append_string` would keep reading
past the end of the string, and continue until it ran out of
memory. This fix adds a check for empty Array.

Merge pull request #421 from sgtatham/eval-ast-vector-gc-fix

vala: avoid half-constructed vectors being garbage-collected.

vala: avoid half-constructed vectors being garbage-collected.

The clause in eval_ast() which evaluates each element of an input
vector into an output vector was holding the intermediate results in
an ordinary GLib.List, and putting them all into a vector at the end
of the evaluation. But that meant that nothing was preventing all
those values from being garbage-collected half way through.

Now we make an output Mal.Vector at the start of the process, and
point a GC.Root at it to ensure it stays around until we've finished
putting items in it.

This fixes the vala part of #418, I think.

lib/load-file-once: basic support for multiple imports

Merge pull request #419 from asarhaddon/vala-remove-redundant-parameter

vala: remove a redundant parameter

vala: remove a redundant parameter

Merge pull request #400 from asarhaddon/improve-mal-impl-macro-no-meta

Improve mal impl macro no meta

Merge remote-tracking branch 'remotes/kanaka/master' into improve-mal-impl-macro-no-meta

mal: implement macro? with contains? instead of list equality

This is more efficient, and avoids triggering some bugs (see #400).

Merge pull request #417 from asarhaddon/slurp-twice

check that slurp works twice in a row. Fix rexx

check that slurp works twice in a row. Fix rexx

r: add step deps on rdyncall lib install.

powershell: prn/println return explicit null.

This is needed for self-hosting to pass all tests.

Merge pull request #416 from bjh21/bjh21-equal-empty

step 4: Test that (= (list nil) (list)) returns false.

Implement macros with maps instead of vectors.

Output of macros will probably be more readable.

Inline _macro_wrap and _unwrap for efficiency (there are less
primitive operations for maps than for vectors).

Basic check of `map?` and `macro?`. Swap them in order to simplify the
diff with cb9b0654.

step 4: Test that (= (list nil) (list)) returns false.

Certain naïve implementations of '=' (like the one I just wrote) will
get this wrong.

mal: fix vector? sequential? and PRINT for new macro implementation

scheme: fix syntax error in 5e5d489

mal: implement macro without metadata

Support for metadata becomes optional.
Support for fn? becomes optional again, reverting 5e5d4892.

guile, scheme: fix fn? when metadata contains "ismacro"

Let `with-meta f m` create a function even if f is a macro, instead of
setting an "ismacro" metadata that is never used again (and breaks
self-hosting).

Also move the test for fn? from Optional to Deferrable, the function
is used for self-hosting.

mal: in step2, revert to reporting key error

Unlike the one in `env.mal`, the `get` built-in used during step2
returns `nil`, so the MAL implementation must throw an error.

mal: modify lib/ in order to hide bugs in make/ and guile/

Make: avoid # character.
Guile: avoid `unquote` inside a vector inside a list inside `quasiquote`.
The bug in scheme/ is most probably the same.

mal: rename macro? to _macro?. Also rename bool-and in lib/equality.mal.

Remove gensym, inc and or from step files.

* Move `gensym` and `inc` from step files to `lib/trivial.mal`.
* Move `or` from step files to `lib/test_cascade.mal`.
  Shorten it because `(first ())` returns `nil`
* Update process and tests accordingly (not the figures yet).

mal: improve MAL implementation.

Generally: remove variables used only once with generic names,
introduce a variable when the same result is computed twice.

core_rs: replace strings with symbols because it is more consistent with
 the public interface of `env.mal`
bind-env:
- compare with '& instead of "&", avoiding a conversion per iteration
- compute `first` once, store the result
env-find:
- move `if env` at start of recursion, avoiding to `get` in a row.
stepA_mal:
- eval-ast, eval: remove duplicate `do`
- LET: move `form` into the signature. The recursion does not change much,
  but the initial call is shorter and more intuitive.
- EVAL:
  - remove initial (not (list? ast)) test, which was redundant
    (MACROEXPAND would do nothing).
  - replace (nil? (first ast)) with (empty? ast), more explicit
    (also, `(nil 1)` is now reported as incorrect
  - `try*`: stop checking that first component of optional argument is
    `catch*`. No other user input is checked explicitly.
- repl-loop: a slight modification avoids to create a new environment
  depth for each new line.

Merge pull request #408 from asarhaddon/haskell-style

Haskell: make the code more readable and idiomatic

Merge pull request #414 from bjh21/bjh21-php-hashmap

php: Make sure that hashmap keys get returned as strings

haskell: remove the need for unsafePerformIO type forced conversion

haskell: shorten Reader with Applicative instead of Monad

haskell: drop redundant import, test empty repl line once

haskell: rewrite nth without old-style partial function