This is probably the most intuitive approach, but since foreach is a macro, you don't need to quote in.

  arc> (mac foreach (var in expr . body)
         `(each ,var ,expr
            ,@body))
  #(tagged mac #<procedure: foreach>)

  arc> (foreach x in '(a b c)                ; in, not 'in
         (prn x))
  a
  b
  c
  nil

  arc> (foreach x fruitloops '(o o o)
         (prn "yum"))
  yum
  yum
  yum
  nil

For example:

(foreach x in seq (prn x)) -> call (each x seq (prn x))

(foreach x seq (prn x)) -> call (each x seq (prn x))

  (mac foreach (var . args)
    (if (is car.args 'in)
          `(each ,var ,(cadr args)
             ,@(cddr args))
         (is car.args 'fruitloops)
          `(each ,var ,(cadr args)
             (prn "yum"))
         (acons car.args)
           `(each ,var ,(car args)
              ,@(cdr args))))

  (mac foreach (var . args)
    `(each ,var ,(if (in car.args 'in 'fruitloops)
                      cadr.args
                     car.args)
       ,@(case car.args
           'in         cddr.args
           'fruitloops `((prn "yum"))
                       cdr.args)))

Upperdate: Aha! It's because in and fruitloops in the case statement should not be quoted:

  (mac foreach (var . args)
    `(each ,var ,(if (in car.args 'in 'fruitloops)
                      cadr.args
                     car.args)
       ,@(case car.args
           in         cddr.args                       ; in not quoted
           fruitloops `((prn "yum"))                  ; ditto fruitloops
                      cdr.args)))

  (mac foreach (var :in expr . body)
    ..

(foreach x in '(1 2 3)) vs (foreach x :in '(1 2 3)) ?

That was important because you could do things like keyword based arguments to functions, etc. i.e. if you had a function that was defined as

  (defun greet (&key (a "Hello") (b "World")) 
    (print a " " b))

  >(greet)
  Hello World
  >(greet :b "Bob")
  Hello Bob
  >(greet :b "Alice" :a "Yo")
  Yo Alice

  ; Composes in functional position are transformed away by ac.

  "'"   ->  '\'';
  "\'"  ->  '\'';

This is working well:

  "\\"
  '\\';

  '"foo"
  '\'foo\'';

  '"'"
  '\'\\\'\'';

  '"\\"
  '\'\\\'';

  '\'\\\\\'';

  [     :)     ]
    [   :|   ]
      [ :-o ]
        [:(]

No need to apologize. :)

> stuck because I don't have external libraries (smart time parser, sockets, mysql, etc.)

Well, I would consider html.arc, srv.arc, app.arc, strings.arc and even some of arc.arc to be libraries. And if you include Anarki's lib/ directory along with all the resources from places like http://awwx.ws/, http://github.com/rocketnia/lathe and this forum, I think we've got a sizable collection going. Granted a lot of it is scattered and not as developed as in some other languages, and we also don't have a standard module system yet. :P

> Is that what PG had in mind when he created Arc? To supply a minimal language but to be able to use external libraries in the underlying interpreter..?

You might be interested (if you haven't already read them) in what pg has written about arc at http://www.paulgraham.com/arc.html. My impression is he thinks it's too soon to get focused on libraries because he's still working on the core language. (http://arclanguage.org/item?id=12127 is a relevant exchange too.)

> a little bit more like I would use Django? I.e. a simple routing to functions and a built-in template engine instead of mixing arc code with html and javascript..?

Maybe you could elaborate on this a bit? If I understand correctly, then I'd respond that html.arc is not unlike Django's templating engine, and you're welcome to separate your code into different files if you prefer it that way. (You're just not forced to.)

> Thanks for your help, it's appreciated.

- Everything is written inside js.arc [1].

- js.arc has the axioms defined with defs and most of arc.arc's macros with js-mac;

- it also defops arc.js, which has most of arc.arc's functions defined in Javascript [2].

[1] http://evanrmurphy.com/js.arc, also defines some in-progress Javascript utilities (mostly DOM-manipulation) and the demo page itself toward the bottom.

- Harumph. Looking back, I notice my ssexpand-all doesn't strictly work right. Instead of considering the actual cases, I just special-cased quotes and quoted unquotes. Technically, these are wrong.

  arc> (ssexpand-all '`(a:b:c d))
  (quasiquote ((compose a b c) d))
  arc> (ssexpand-all '(fn (x:y) x:y))
  (fn ((compose x y)) (compose x y))
  arc> (ssexpand-all '(assign x:y z))
  (assign (compose x y) z)

  (def imap (f xs)
    (when xs
      (if (acons xs)
          (cons (f (car xs)) (imap f (cdr xs)))
          (f xs))))

  (def on-qq (f expr)
    (list 'quasiquote
          ((afn (level x)
             (if (is level 0)
                  (f x)
                 (atom x)
                  x
                 (is (car x) 'quasiquote)
                  (list car.x (self (+ level 1) cadr.x))
                 (in (car x) 'unquote 'unquote-splicing)
                  (list car.x (self (- level 1) cadr.x))
                  (imap [self level _] x)))
           1 (cadr expr))))

  (def ssexpand-all (expr)
    (if (ssyntax expr)
        (let expanded (ssexpand expr)
          (if (is expanded expr)
              expr
              (ssexpand-all expanded)))
        (check expr
               atom
               (case (car expr)
                 quasiquote (on-qq ssexpand-all expr)
                 fn         `(fn ,(cadr expr) ,@(imap ssexpand-all (cddr expr)))
                 assign     `(assign ,(expr 1) ,(ssexpand-all (expr 2)))
                 quote      expr
                            (imap ssexpand-all expr)))))

- I notice you wind up copy/pasting a lot of arc.arc definitions, particularly for macros. Couldn't it be more general? I.e., add a clause like

  (isa (car s) 'mac)   (js (macex1 s))

- Really, the point about macros expands into a broader one. My first inclination is to model the compiler on ac.scm; once that's working, you get arc.arc & libs.arc for free just by cranking the compiler over them. Keyword collisions could be mitigated as in ac.scm, which prepends underscores to variable names.

  arc> x
  Error: "reference to undefined identifier: _x"

There are more "overlap-y" examples like while. It's implemented as a macro in arc.arc, but you'd probably want to compile it down to Javascript's while instead of tail-recursive function calls. Also, some features don't line up quite right, like first-class continuations. Though you could compile them into Javascript (that'd be cool!), a big use for them is simply

  (catch
    (while t
      (throw)))

I'm curious if you've tried this approach at all and, if so, how it panned out (I've never tried anything like it myself, so I wouldn't know).

For a long time I didn't have js-mac and wasn't using js-def. Each macro got a handwritten js-<insert name> function and its own branch in js1's if; each function was handwritten in Javascript. [http://arclanguage.org/item?id=11918] I finally got smart enough to start using the partially bootstrapped compiler, and abstracting away the verbatim definitions should follow from that.

You could make js-macs take priority over regular macros by checking for them first in js1, and still reduce copy/paste work. Would anything break from this?

I do think that will be the way to do it, and it shouldn't break anything.

It's interesting because this project isn't just an Arc-to-Javascript compiler, but also a DSL for Javascript in Arc.

I knew this was true but hadn't yet found a way to articulate it. Thanks for the good choice of words.

There are more "overlap-y" examples like while. It's implemented as a macro in arc.arc, but you'd probably want to compile it down to Javascript's while instead of tail-recursive function calls.

Yes. Since resources are so precious in the browser and Javascript doesn't optimize tail calls, this will probably be an important refinement. As a bonus, it may make the compiled js more readable, since (while foo bar) would be generating something like while(foo){bar;}, rather than:

  (function(g3701){
    return g3701=(function(g3702){
      return (g3702?function(){bar;return g3701(foo);})['call'](this):nil);
    });
  })['call'](this,nil)(foo);

Your idea of compiling the common case to while/break sounds fine, but wouldn't try/catch be suitable as well? (I haven't made enough use of either first-class continuations or Javascript's try/catch to know yet.) There have been some cases I've dealt with already where the features didn't quite line up: rest/optional parms for functions, conses/lists vs. arrays and nil vs. false/null/undefined.

(evanrmurphy) I knew this was true but hadn't yet found a way to articulate it. Thanks for the good choice of words.

I was also impressed by that choice of words. XD

-

wouldn't try/catch be suitable as well?

  Arc->Javascript
  arc2js
  js.arc + arc.js
  JarcScript       ; if jazzdev doesn't mind :)

Function calls:

  (fncall x y) -> x(y);           ; verbose
  (x y)                           ; succinct
   x.y
  (fncall x 'y) -> x(y);          ; verbose quoted
  (x 'y)                          ; succinct quoted
   x!y

  (objref x y) -> x(y);             ; verbose
                                    ; no succinct form for no quotes
  (objref x 'y) -> x('y');          ; verbose quoted
  (x `y)                            ; succint quoted
   x.`y

  (listref x y)  -> car(nthcdr(y,x));    ; verbose
  (listref x 'y) -> car(nthcdr('y',x));  ; verbose quoted
                                         ; no succinct forms for listref

  (objref (array 'a 'b) 0)  -> ['a','b'][0];
  ((array 'a 'b) `0)                                ; same as above

  (let a (array 'a 'b)      -> (function(a){
    a.`0)                        return a[0];
                               })['call'](this,['a','b']);

  (.`0 (array 'a 'b))       -> (function(_){        ; using get ssyntax
                                 return _[0];
                               })(['a','b']);

  arc> (ssexpand '[_])
  (fn (_) (_))

  arc> '[_]
  (fn (_) (_))

  chmod +x racket