(define (composer fl fr)
    (vector 'composer fl fr))
  (define (composer? fn)
    (and (vector? fn) (eq? 'composer (vector-ref fn 0))))
  (define (composer-fl fn) (vector-ref fn 1))
  (define (composer-fr fn) (vector-ref fn 2))

  ; 'compose is now a reduction on '<base>compose
  (xdef '<base>compose composer)

  ; this is where the speedup comes from!
  (define (ar-funcall0 fn)
    (cond
      ((composer? fn)
        (let ((fl (composer-fl fn))
              (fr (composer-fr fn)))
          (ar-funcall1 fl (ar-funcall0 fr))))
      ...))

  ;etc. for ar-funcall1 to 4 and ar-apply.

What I would really like to see is currying with partial function application and dispatch on every function argument, so that (my-curried-fun (annotate 'foo val)) is evaluated to a curried function for the type foo. Otherwise the (types|patterns) would have to be compared everytime this function is applied, which may be inefficient, e.g in

  (map (my-curried-fun (annotate 'foo val)) my-large-list)

but the user never sees any of that. if you want an array or tuple you type

  local blah = { 1, "two", function return 3 end }

  local blah = { bleh = "yep", bleagh = "whatever" }

  -- both of the following are valid
  print( blah["bleh"] )
  print( blah.bleh )

  local blah = { "my", "name", "is", [12] = "slim", [888] = "shady" }

  local blah = { "element 1", "element 2", name = "son", lastname = "goku" }

  local blah = { { "star", "bucks" }, { "apple", "sauce" } }

  local blah = { [{ 1, 3, 5 }] = "odd", [{ 2, 4 }] = "even" }

and keep in mind that Lua is likely the fastest interpreted language... or at least it was before the Javascript optimization race started. i think one of the Javascript engines has features inspired by the Lua VM

and then there's metatables, which are properties that can be set to control the behavior of values in different situations. for example, one of the properties is __index, which is referred to when a table doesn't have a value for a given key. this enables straightforward memoization, inheritance, hidden data management, infinite data structures, etc

other metatable properties determine the operation of the value under addition, comparison, etc

you could, for example, implement complex numbers as if they were part of the language, simply by creating a seed table called i. when an expression such as 1 + 2 * i is reached, the __mul property would perform the complex multiplication, then return a new Complex table which would in turn perform the addition. along each step it would be a normal table, so you could do, for example:

  print( (1 + 2 * i).polar_form )

  print( 8 * i^5 + 2 * i )

i've been thinking of making an APL-like DSL (would be nice to be able to implicitly map and whatnot) in this sort of manner. i haven't looked deep into Ruby but i believe it has things of this nature

here's a description of metatables:

http://www.lua.org/manual/5.1/manual.html#2.8

the fact that tables are used everywhere is unoverstatable. environments are tables, therefore you can do powerful things with environments. like writing your own import/include function, reading and writing global state in a file, anaphora and implicits... pretty much a bunch of crazy shit

along with this some very well-chosen features such as coroutines, closures, the implementation of most language features as modules (eg file.open, coroutine.wrap) to keep the syntax clean, etc

  (mac w/collect body
    `(accum collect ,@body))

  (def observe (x y r)
    (w/collect:for i (- x r) (+ x r)
      (for j (- y r) (+ y r)
        (awhen (showpos i j)
          (collect it)))))

  (map (fn (_) (cut _ (- row 1) (+ col 2))) (cut world (- row 1) (+ col 2)))

  (map [cut _ (- row r) (+ row r)] (cut world (- col r) (+ col r)))

   (if (find X (flat:map [join (errsafe (world _))] (list (- row 1) (+ row 1) (- col 1) (+ col 1))))
    ; do stuff
    )

  (flat:map [join (errsafe (world _))] (list (- row 1) (+ row 1) (- col 1) (+ col 1)))

    (= foo '((key1 . val1) (key2 . val2)))
    (= bar (cons '(key2 . different-val2) foo))
    bar
    => ((key2 . different-val2) (key1 . val1) (key2 . val2))

Probably means we want to have some sort of "source" slot too, so that we can display shadowed values. Hmm. The association sublists e.g. '(key1 . val1) can probably be directly shared, but lists also imply an ordered set, so we need to store that info too. Hmm.

>As for strings and symbols, I don't really know how they are actually implemented, but as far as I know, the idea is that 'foo and 'foo are the same memory location, while "foo" and "foo" are not necessarily the same object(thus allowing string mutation)

This is correct. And when you really look at it, changing strings as if they were arrays of characters is hardly ever done in Arc; usually what's done is we just read them off as an array of characters and build a new string.

> In any case, characters just seem useless...

  >  => ((key2 . different-val2) (key1 . val1) (key2 . val2))

Native Arc as in ArcN?

For porting into Anarki, I suggest you use the new 'thread-local types for global variables:

  wipe.re-text*
  wipe.re-paths*
  wipe.re-fail

  (= re-text*  (thread-local)) (wipe (re-text*))
  (= re-paths* (thread-local)) (wipe (re-paths*))
  (= re-fail   (thread-local)) (wipe (re-fail))