(mac helper (foo)
    `(do ,foo))
  (mac real-macro (bar)
    `(helper ,bar))

  (let helper
       (fn (x) (+ x 1))
    (real-macro (helper 1)))

Pointers are dereferenced by (ptr), so you use (ptr) to get the contents and (= (ptr) v) to assign.

  (in-package pointer)
  (using <arc>v3) ; replace with <hl>v1
  (interface v1
    pointer)
  ; replace with (mac (pointer e) ...)
  (mac pointer (e)
    (if (acons e)
        (let vars (map [uniq] e)
          `(with ,(mappend (fn (var val) `(,var ,val)) vars e)
             ; replace with (tag...)
             (annotate 'pointer
               (cons (fn () ,vars)
                     (fn (v) (= ,vars v))))))
        (w/uniq v
          `(annotate 'pointer
             (cons (fn () ,e)
                   (fn (,v) (= ,e ,v)))))))
  ; replace with (defm (sref (t p pointer)... ) ...)
  (defm sref ((t p pointer) v)
    ((cdr:rep p) v))
  (defcall pointer (p)
    ((car:rep p)))

  (= stuff (list (pointer a)
                 (pointer (car b))
                 (pointer c!x)))
  (each p stuff
    (pr (p))
    (= (p) (something)))

It's possible to make the contexting system be less aggressive about putting symbols in packages.

As an explanation, contexting performs the following transform:

  ; Arc-F code!
  (in-package foo)
  (using <arc>v3)
  (interface v1 public)
  
  (def private (x)
    x)
  (def public (y)
    (private y))
  
  ; equivalent transform!
  t
  t
  t
  
  (<arc>def <foo>private (<foo>x)
    <foo>x)
  (<arc>def <foo>public (<foo>y)
    (<foo>private <foo>y))

However, you can reduce the aggression instead, at the cost of declaring private functions:

  ; Anarki-on-arc3 code!
  (in-package foo)
  (using <arc>v3)
  (internal private)
  (interface v1 public)
  
  (def private (x)
    x)
  (def public (y)
    (private y))
  
  ; equivalent code!
  t
  t
  t
  t
  
  (def <foo>private (x)
    x)
  (def <foo>public (y)
    (<foo>private x))

However you still need to force contexting in your REPL/load, i.e. RCEPL, read-contextify-eval-print loop.

Since I'm not touching Arc, here's a sketch of what I believe is the problem:

http://news.ycombinator.com/item?id=519521

In the above link, pg describes the problem as being in the fact that he was using "a four variable list to destructure on a five value description of the field."

http://github.com/nex3/arc/blob/8112c99e0cd6f41850910e7c359e...

The above bit of code appears to be the "five value description". It's a function creating a data structure specifically for the particular user and post, making some data showable/not showable and modifiable/not modifiable.

The only time that this particular variable is used is in calls to a 'vars-form function. This function is in app.arc <insert snarky comment about badly disorganized code here>:

http://github.com/nex3/arc/blob/8112c99e0cd6f41850910e7c359e...

The specific "four variable list" appears to be the following line:

http://github.com/nex3/arc/blob/8112c99e0cd6f41850910e7c359e...

Here's the modified code I used on hnacademic.com:

                         (let (typ id val view mod) it

Arc's server doesn't actually use continuations - it uses functions that serve as continuatinos. There's no call to 'ccc or any of the wrapping forms in srv.arc (at least none that I remember)

> The concurrency story is particularly interesting given the proliferation of cores and slowing of GHz.

This is true and I think the "extra-cycles-to-waste" property expected by PG isn't going to put out in a hundred years.

> state of the art VM/JIT technology

the primary goal was not to build a language but to get an avalanche of new lisp implementations started.

  (= f (table))
  (= k 1)

  (= (f k) (+ k 1))

  (def set-the-table (k)
    (= (tb k) (+ k 1)))

  (= tb (table))

file1.arc:

  ; throwaway file I'm playing around with

  ; define some temporary function
  (= (foo x)
     (+ x 1))

  ; throwaway file I'm playing around with
  (= foo (table))
  (for i 0 3
    (= (foo i) i))

  (load "file2.arc")
  (load "file1.arc")

LOL! ^^ ^_^ >.< ^_^ ROFL!

Uh, yes. That's how it's already done. That's why arc.arc is itself a package. In fact, when you say '(in-package foo), the only thing that the contexter will add to the newly-defined package foo are the Arc axioms: '<axiom>fn, '<axiom>if, '<axiom>quote etc. That's why you have to declare '(using <arc>v3) for each package - because otherwise the language doesn't actually import arc.arc

Edit: Ultimately (and this is another disagreement with PG) arc.arc is a library, not part of the language. It's like the libc in this respect. Because you see, we already had the 150-year language 50 years ago.

Edit2: as an aside, the package system even lets you export a binding for 'quote, 'quasiquote, etc. In fact, once we have defined a formal method to add ssyntaxes, it would be possible to add support for `(let foo# ,foo (something foo#)) in a library, not in the language. How? By defining an export for 'quasiquote, say (interface v1 <auto-uniq>quasiquote), where <auto-uniq>quasiquote is a macro that expands to <axiom>quasiquote

> In my opinion the grain should be as fine as possible, so that you can use embedded DSLs whenever possible (like w/html or LINQ).

!!