Thanks a lot, for taking care of the anarchy I caused in the Anarki!

From now on I'll commit to my fork and if there was any thing of general interest you can pull it to master later.

I noticed you mentioned "it would be better if matrix was its own type" I agree with that. Is there any way to communicate this with pg (or anybody else who has a say on such basic matters) and see if matrix could be implemented as its own type?

As you know I am an absolute newbie in arc/lisp but I find it quite refreshing to solve (or re-solve) problems the arc/lisp way.

A growing set of files in lib/ doesn't really hurt anyone, and if someone really hates your or my code, they're free to rewrite it, or just not load that library.

It's pretty obvious that people like aw, shader, and fallintothis (off the top of my head) are much better scheme hackers than I am, but I don't think I've stepped on their toes too much, and if I think I'm going to, I'll ask the forum about pushing something.

Regarding implementing matrix and vectors as their own types, if you can do it and have the time to do so, you don't need to wait for PG's permission. For my needs at least, Anarki is the more useful tool and PG, while he is the original creator, is just a periodic contributor like the rest of us (although he doesn't push to github - one of us ends up merging his stuff).

Hehehe. Well, it has to be something with an animal! :) I think you mean camelCase.

I'll push to Anarki, I like the idea of sharing the same code pool when people are free to load a library or not.

My free time is a random variable with large variance but this seems to me a small but lively community which boosts the motivation.

From: http://awwx.ws/extend0

  For example, here is an extension to + to combine tables:
  
  (extend + args (isa (car args) 'table)
    (listtab (apply + (rev:map tablist args))))
  arc> (+ (obj a 1) (obj b 2) (obj a 3 c 4))
  #hash((b . 2) (c . 4) (a . 1))

(Thanks for the pointer to coerce, rocketnia)

My experience since then has been that the efficiency of a hash-table lookup is irrelevant. But I really like the conciseness and readability of being able to say:

  (defmethod foo(arg1 arg2) type-of-arg1
    ...)

"you have something in arc.arc which throws me redefinition messages whenever I start up arc"

Ack, guilty as charged; I should fix that..

  (= a (vec 1 2 3))
  type.a => 'vector
  (a 0) => 1

  (defcall vector (vec i)
    rep.vec.i)

Since then, it's been redefined in terms of [coerce _ 'fn] and an extensible implementation of 'coerce. http://arclanguage.org/item?id=9828 (Here you go, akkartik!)

Looks like garply is putting together a library which deals with matrices and vectors and wants to be able to say (isa x 'vector). The 'annotate and 'rep functions make that happen. Anarki also defines 'defcall so that new types like these can be given special behavior when used as functions.

In one sense, garply's defining a matrix type for every Anarki user to use. In another sense, it's only a matrix type specific to the purposes of that library. But in any case, if this type doesn't look good to someone, they can just follow the same process to define their own type and forget this one exists at all. :-p

For an automated startup, you might try something like this shell script (after modifying libs.arc to load your code):

  #!/bin/sh
  cd /location/of/arc/directory
  nohup mzscheme -f as.scm >log 2>&1 &

  (expr1 expr2 expr3 ...)

  arc> (+ 1 2 3)
  6

  ((if (> 1 2) - +) 1 2 3)

  (if (> 1 2) - +)

  (+ 1 2 3)

To fix your code immediately, you'd just need to get rid of the extra parens. Expressions in the body of a function evaluate one after the other, returning the value of the last expression, so given

  (def f (x)
    (+ x 1)
    (+ x 2))

But you should (generally) only use = for global variables. For local ones, you'll want with or let.

  arc> (let x 1 (+ x 1))
  2
  arc> (with (x 1 y 2) (+ x y))
  3

  (def s (x y)
    (with (mx (avg x) my (avg y))
      (reduce + (map *
                     (map [- _ mx] x)
                     (map [- _ my] y)))))

  (map f (map g xs))

  (map [f (g _)] xs)

  (def s (xs ys)
    (with (mx (avg xs) my (avg ys))
      (reduce + (map (fn (x y) (* (- x mx) (- y my)))
                     xs
                     ys))))

You can also write the same "destructive" style of code in Arc, though it's normally frowned upon.

  (def s (x y)
    (let xy 0
      (for i 0 (- (min (len x) (len y)) 1)
        (++ xy (* (- (x i) (avg x))
                  (- (y i) (avg y)))))
      xy))

  put a blank line, then at least two spaces before the line of code
  (similarly for subsequent lines)