One thing I'm reasonably sure of is that this isn't a bug - this is how PG intended annotate (née tag), type, and rep to work. See http://www.paulgraham.com/ilc03.html, for example.

  arc> (= f (annotate 'x 1))
  #3(tagged x 1)
  arc> (+ f 1)
  Error: "+: expects type <number> as 1st argument, given: #3(tagged x 1); other arguments were: 1"

Re the "in-Arc" solution - the problem is trivially attaching a set of properties to an object. For example, an object might have an "assign" aspect, might have a "length" aspect, might have a "keys" aspect, might have "writeable-keys", etc. It's possible to do that using (annotate `(= ,setterfunction) readerfunction) or something, true, but this requires us to search through a possibly deeply nested annotate.

That said the add-attachment and get-attachment stuff (from lib/settable-fn.arc) can be rewritten to use annotate instead:

  (def add-attachment (k v s)
    (annotate `(,k ,v) s))
  (def get-attachment (k s)
    (if (is s (rep s)) ; is this relationship assured?
        nil
        (let ty (type s)
            (if (and (acons ty) (caris ty k))
                (cadr ty)
                (get-attachment k (rep s))))))

  (def add-attachment (k v s)
    (annotate 'settable-fn
      (list k v s)))

  (behave
    'foo
    (fn (self x y) (list (+ (self 0) x) (- (self 1) y)))

  (let obj (annotate 'foo '(42 2))
    (rep (obj 5 2)))

  (define (ar-behave type fn)
    (hash-table-put! ar-behaviours type fn))

  ((ar-tagged? fn) (ar-apply (ar-rep fn) args))

  ((ar-tagged? fn) (ar-apply (hash-table-get ar-behaviours (ar-type fn)) args))

The main reason my settable-fn works the way it does is so that attachments are orthogonal to annotations. An object might be tagged, or it might be attached, or it might be both tagged and attached.

This means that I could have defined a function, tagged it as 'table, and provided a '= attachment for a setterfunction and a 'keys attachment for a redef'ed 'maptable and 'keys. This way, I don't have to modify, say, 'each, which will simply see that it's a 'table and pass it to 'maptable, without ever realizing that it isn't a hash table.

With this system, everything that takes an attachment must be a settable-fn (or whatever). This means that I need to modify about a dozen existing macros so that it will work with my "table", so that they will also check for a 'keys attachment, and probably I want to do this for any new macros. Sure, I could redef 'type, but this gets more complicated (and potentially risky).

In any case, it seems un-Lispy to me in general to redefine behavior by attaching things to objects. I'd rather see us redefining and tweaking the verbs rather than adding information to the nouns. This is also, I think, how PG envisioned annotate and friends working. From http://www.paulgraham.com/ilc03.html :

"If you want to overload existing operators to do the right thing when given your new type, you don't need anything new in the core. As long as you have lexical scope, you can just wrap a new definition of the operator around the old one. So if you want to modify print to display objects of your new type foo in a special way, you write something like this:

  (let orig print
    (def print (x str)
      (if (is (type x) 'foo)
          ...new code...
          (orig x str))))"

  arc> (= test (annotate 'table (fn (x) x)))
  #3(tagged table <procedure>)
  arc> test!x
  Error: "Can't get reference"

The thing is, if we expect (annotate 'table (fn (x) x)) to act just like a table out of the box, we have a lot of work to do. Every table axiom has to check for an annotation and recurse if one exists.

This may not seem so bad for tables, but consider: if ((annotate 'table (fn (x) x)) 'foo) works, shouldn't ((annotate 'cons (fn (x) x)) 1)? What about (+ (annotate 'num (fn (x) x)) 2)? What does that even mean?

It seems to me that the easiest and most consistent way to mimic other types is to annotate with a new type but to redef functions like keys and defcall to work in functional position.

For example, we might want to build a reader which keeps track of line numbers. The reader's output is still 'cons and 'sym, etc., but with an attachment. Each 'cons cell has a 'linenumber attachment which we can use. For example, a macro whose syntax has been violated would be able to report the line number where this violation occurs. This is useful if the macro is used often enough and there is a need to locate the line number of the error, or if its syntax is like CL 'loop and you expect it to span several lines.

In all cases, the cons cell produced by this hypothetical reader is a cons cell. Its representation is a cons cell and is only a cons cell. However, we can extract additional data from it. After it passes through the evaluator and is discarded as trash, its attached data can be thrown away.

Anyway:

"Now this is the noble truth of the origin of suffering: it is this attachment which leads to renewed existence, accompanied by delight and lust, seeking delight here and there, that is, attachment to sensual pleasures, attachment to existence, attachment to extermination."

  (def add-attachments (atts obj)
    (if (no atts)
      obj
      (add-attachments (cdr:cdr atts) (add-attachment (car atts) (car:cdr atts) obj))))
  (= foo
     (with (...)
       ...
       (add-attachments
         (list 'keys key-getter-function
               '=    setter-function
               'len  len:key-getter-function)
         reader-function)))

  (annotate x y)

  (annotate 'point (cons x y))

  (def add-attachment (k v s)
    (if (isa s 'settable-fn)
        (do (= ((car (rep s)) k) v)
            s)
        (annotate 'settable-fn
            (cons (fill-table (table) (list k v)) s))))

  (def reptag (typ obj)
    (annotate typ (rep obj)))

Also, annotate obeys two useful identities:

  (type (annotate x y)) --> x
  (rep  (annotate x y)) --> y

  def                      --> #3(tagged mac #<procedure>)
  (rep (annotate 'fn def)) --> #3(tagged mac #<procedure>)
  (rep (reptag   'fn def)) --> #<procedure>

  (= y (annotate 'bar 'hmm))
  (annotate 'foo y)

  ; option1: current Arc
  arc> (annotate 'foo y)
  #3(tagged foo #3(tagged bar hmm))
  arc> y
  #3(tagged bar hmm)
  ;option2: my proposal
  arc> (annotate 'foo y)
  #3(tagged foo hmm)
  arc> y
  #3(tagged foo hmm)
  ;option3: something else entirely
  arc> (annotate 'foo y)
  #3(tagged foo hmm)
  arc> y
  #3(tagged bar hmm)