(mac read-into (vars form)
    `(do
       ,@(map (fn (var) `(= ,var ,form)) vars)))

For some reason, I couldn't for the life of me get the [_] syntax to work. Anyways, to do what you were trying, you'd just call, with my macro defined:

  (read-into (a b c) (readb in)))

Adlai

EDIT:

Got it to work with the [] fn abbreviation, and it's the most hideous butchering of a beautiful thing that I've ever seen:

  (mac read-into (vars form)
    `(do
       ,@(map [quasiquote (= ,_ ,form)] vars)))

  [`(= ,_ ,form)]             ;expands into

  (fn (_) (`(= ,_ ,form)))    ;instead of

  (fn (_)  `(= ,_ ,form))     ;ugghh!!!

Another, possibly nicer, way to think about it is that [] just represents a delayed function call; you're trying to delay an object, and since [] is a function call, you're calling it instead. Either way, the point is that this is the consistent and desirable way for [] to work.

  (fn (_) `(= ,_ ,form))

What about a special syntax (for this one situation), where you can put the backquote thus: [` = ,_ ,form] which would read-macro-expand to (fn (_) `(= ,_ ,form))

Thanks for the code, that was exactly what I was thinking of. Too bad there isn't a macro or function that just returns the value of a variable in such a way that it can be assigned to. Can anyone think of how to implement such a thing?

i.e.:

  (= v 'a)
  (= (val v) 6) ;the variable a is now assigned the value 6.

'in is also a built-in macro in arc.arc. Since Arc is a Lisp-1 (grr...), you can't bind it to an input stream without potentially breaking some other code...

  (mac in (x . choices)
    (w/uniq g
      `(let ,g ,x
         (or ,@(map1 (fn (c) `(is ,g ,c)) choices)))))

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)))

However, a few comments about your version:

- You use an iterative 'while, rather than the tail-recursive approach that Paul Graham posted. Both end up eventually as tail-recursive code, however, I think that it's better, in this case, to write the tail-recursion directly. The reason for this is that in your version, you have to explicitly "break out" of the loop (by setting 'tries to 1), while in Paul's version, he just doesn't call the next "iteration".

- You should probably use 'prn for the last message -- when I run this, "nil" gets tacked on to the end of the message.

- This is more just a matter of convention, than an actual problem, but your indentation isn't completely standard. Usually, body code for macros is only indented by two spaces. Also, having several tokens on one line can get a bit confusing, and in a form like 'with, I think it helps to organize them. I think the start of your code could be more readable like this:

  (def guess ()
    (with (tries 10
           r (rand 100))
      (while (> tries 1)
        etc)))

  (each (k v) mytable
    (prn "my key is " k)
    (prn "and my value is " v))

  (copy (obj a 1)
    'b 2
    'c 3)

If the lines after the first line don't fall into their own group, then I'll line up the arguments:

  (+ '(a b c d)
     '(e f g h)
     '(i jk))

  (map (fn (x) ...)
       (generate-my-list ...))

Function calls are indented with all the arguments starting at the same column, for example:

  (calculate-fn-of arg1
                   arg2
                   arg3)

  (while (< x 10)
    (prn x)
    (++ x))

  (with (var1   val1
         thing2 val2
         var3   expr3)
    (do
      (stuff)
      (with-vars)))

  (if (test1)
       (response1)
      (test2)
       (response2)
      (response3))

  (if (test1) (response1)
      (test2) (response2)
              (response3))

  (if (test1)
      (response1)
      (test2)
      (response2)
      (response3))

  (if
    (test1)
      (response1)
    (test2)
      (response2)
    (response3))

  (if a b
      c d
        e)

  (if a
      b
      c
      d
      e)

arc code or scheme code?

However, in this case I agree with Adlai: pg had even planned on getting ppr to "properly indent long ifs". I presume that means to implement the wavy feature. It's also the convention for Anarki, according to the CONVENTIONS file.

So, here's what I'm thinking should be done for ifs:

1) If you only have three expressions, if-then-else, use:

  (if a
      b
      c)

  (if a b
      c d
      ...
        e)

  (if (a       )
        (b       )
      (c       )
        (d       )
      (e       ))

Another question:

How do people indent do, and, or, etc.:

a)

  (do abc
      bcd
      cde)

  (do
    abc
    bcd
    cde)

Should case be indented like 'if:

  (case
    a
      (b     )
    c
      (d     )
    (e      ))

  (case
     a (b    )
     c (d    )
     (e     ))

  (case
    a-short     (b ...)
    c-very-long (d ...)
                (e ...))

  (case
    a-short
      (b ...)
    c-very-long
      (d ...)
    ; else
      (e ...))

  (each type-frag types
    ; Assemble the ('type name) pairs into two lists, so that we can iterate
    ; through them.
    (case (type type-frag)
      ; If it's a symbol, then we're defining a new name; add a new set of
      ; values, and go.
      sym
        (do
          (zap [cons type-frag _] names)
          (zap [cons nil       _] values))
      ; Otherwise, we're adding a value to an existing variant.
      cons
        ; I changed my mind about the order (now it's (name pred?) instead of
        ; (pred? name)), so I'm reversing it here.
        (zap [cons (rev type-frag) _] (car values))
      ; else
        (err "Invalid member of tagged union declaration.")))

  (def macexn (n expr)
    " Macroexpand `expr' `n' times.  NB: `expr' *is* evaluated!
      See also [[macex1]] [[macex]] "
    (if (and (number n) (> n 0))
      (macexn (- n 1) (macex1 expr))
      expr))

  (cond ((condition1)
         (result-code1))
        ((condition2)
         (result-code2))
        (default-code))

That would make your code very confusing. Even in Lisp 2s, programmers avoid using the same names for functions and ordinary variables.

I think that since Arc is supposed to be designed towards flexibility and usability for the programmer, it should have few restrictions, and a common namespace is such a restriction.

   (mac mappair (x y expr args)
     (w/uniq arg
       `(map (fn (,arg)
               (let ,x ,(car  ,arg)
                    ,y ,(cadr ,arg) )
                 ,expr) )
             (pair ,args) ) ) )

  arc> ((fn ((x y)) (+ x y)) '(5 10))
  15

My Arc knowledge is essentially #f at the moment, but this

  ((hash-table? fn)
   (ar-nill (or (hash-table-get fn (car args) #f)
                (hash-table-get fn hash-table-default #f))))