arc> (obj a 1 b 2)
  #hash((b . 2) (a . 1))
  arc> (table)
  #hash()

  arc> (table [= _!a 1 _!b 2])
  #hash((b . 2) (a . 1))

Next question: I'm no Scheme expert, but the definition of table in ac.scm doesn't seem to allow for any optional arguments:

(xdef table (lambda args (let ((h (make-hash-table 'equal))) (if (pair? args) ((car args) h)) h)))

So how does the optional initialiser get used?

The initialiser can fill the table.

  arc> (table [for i 0 5 (= _.i (* i i))])
  #hash((3 . 9) (4 . 16) (5 . 25) (0 . 0) (1 . 1) (2 . 4))

> (xdef table (lambda args (let ((h (make-hash-table 'equal))) (if (pair? args) ((car args) h)) h)))

Scheme (lambda args ...) is equivalent to Arc (fn args ...).

It allows to get the raw list of arguments, which may be empty (i.e: no arguments are passed).

So (if (pair? args) ((car args) h)) h) tests if args is a non-empty list (with pair?). If so, it uses the car of this list as the initialiser. It calls it (((car args) h)) with the freshly created table, h, as parameter.

(An example of the "raw arguments list" behaviour in Arc:

   arc> (def prnargs args  ; /!\ no parents around "args"
          (forlen i args (prn "arg n°" i ": " (args i))))
   arc> (prnargs)
   nil
   arc> (prnargs 'a 'b)
   arg n°0: a
   arg n°1: b
   nil

> ... removing table / obj > table ...

I believe 'obj is less used than 'table. 'table is more simple in that everyone knows what a (hash)table is, but an "object" is a fuzzy concept, as you pointed it out.

> but all kind of things are objects

Yep, and what most people call objects are more/less just a more/less "special" hashtable. That's why, I suppose, obj is called like that: just a synonym for table (although the function 'obj is != from 'table).

You can do a lot with an hashtable, and it's cool. Where is the problem?

(For info, Arc's templates also uses hashtables behind the hood, if I remember well. See also: Javascript objects.)

> I suppose what I'm saying is that it doesn't seem very useful to have table visible in Arc and in general

I agree with you that maybe having both 'obj and 'table is a bit confusing, and maybe too much. People may expect they are totally different things. And they are in a way redundant.

  (mac amphi-table args
    (cons (if (<= (len args) 1) 'table 'obj) args))

Then let's do it :-)

In ac.scm, we change the xdef of 'table, and the def of 'fill-table (which doesn't seem to be used anymore) to work with a normal list (and not an alist).

   (xdef table (lambda args
	         (let ((h (make-hash-table 'equal)))
		   (if (pair? args)
		       (if (pair? (cdr args))
			   (fill-table h args)
			   ((car args) h)))
		   h)))

   (define (fill-table h lst)
     (if (pair? lst)
         (begin (hash-table-put! h (car lst) (cadr lst))
	        (fill-table h (cddr lst)))
         h))

  arc> (table)
  #hash()
  arc> (table [for i 0 3 (= _.i 42)])
  #hash((3 . 42) (0 . 42) (1 . 42) (2 . 42))
  arc> (table 'a 2 'b 42)
  #hash((b . 42) (a . 2))

> Thanks much for your detailed and informative reply.

Thanks go to you for having a fresh view on the data structures of Arc, and questioning them. I was just "quoting the manual" and this is not hard.

----

To absz: thanks for mentioning "DWIM", I didn't know this acronym but this is exactly what I expect from a (programming) language. It is what differenciates a language from a (formal) notation IMO. Funny point, the (french) wikipedia article uses Perl as a DWIM-oriented language example :-)

Interesting that Thaddeus (http://www.arclanguage.org/item?id=10533) makes a mistake using 'obj / wants 'inst to work w/ 'obj. This comforts me in the idea that 'obj is confusing. People expects an "object" to do magic (inheritance, instanciation, etc), to be high-level, where they just expect an (hash)"table" to be a simple key/value store.

Maybe (xdef new-table (lambda () (make-hash-table 'equal)), and then use the raw 'new-table and 'fill-table, 'listtab, 'tablist and co. to define a DWIM 'table in Arc.

Or maybe it's crap because DWIM is crap by nature and it's better to have (to know) 'table, 'obj, 'fill-table, etc.

I like "obj". After all in OOP isn't an object simply a property list of key/value pairs with initial values set to define the object?

   i.e.

   (= vampire (obj teeth "fangs" hair "black" food "blood"))

   (= Dracula vampire)

 So now we have an instance named "Dracula" of a "vampire" object....  

  (= conanite vampire)

  (= Dracula!hair 'blue) ; *not tested*

  (deftem vampire name nil fangs 2 hair 'black requires 'blood) ; sorry, my vampire is defined a little differently

  (= Dracula (inst 'vampire 'name "Dracula"))
  (= conanite (inst 'vampire 'hair 'gray))

Too bad the following doesn't work:

   arc> (= vampire (obj teeth "fangs" hair "black" food "blood"))
   #hash((hair . "black") (food . "blood") (teeth . "fangs"))
   arc> (= Dracula (inst 'vampire))
   #hash()