~~~

- The change to macros doesn't extend to ssyntax. Forms like some-macro!foo and some-macro.foo still don't use the compile-time global binding of 'some-macro. At first I thought this just affected macro!foo, but I should have known better, and the prospect of changing over a hundred instances of my.var-name into (my var-name) throughout the code, only to change them back as soon as you fixed this, was daunting enough that it's what finally burned me out.

- Saying (fn () in) errors out. The 'in macro can be replaced with the name of any macro in lexical scope (!) that requires at least one argument. As far as I can tell, the Jarc compiler compiles (fn () a b c) by compiling the expression (a b c), discarding the result, and then compiling a, b, and c as it should. Anyway, I got around this using the idiom (fn () idfn.in).

- Saying (fn ()) errors out, rather than being equivalent to (fn () nil). I actually noticed this last time, but I forgot to mention it, and the (fn () in) case reminded me.

- For whatever reason, you're calling 'quasiquote 'backquote. This didn't cause me any trouble on its own, but it did get in my way as I was "fixing" some nested quasiquotes I missed last time.

- I'm sure you know about this, but Jarc is missing a bunch of Arc 3.1 utilities. In particular, I had trouble with each's different treatment of tables and split's non-treatment of strings. I also miss arc.arc's 'down as well as strings.arc's 'tokens and 'subst. For the most part, I just copied those into the REPL as I tested and pretended they weren't a problem, but I thought I'd mention it anyway.

- Jarc doesn't recognize the space literal character when it's written as "#\ " without the quotes. (On the plus side, it does recognize "#\space". Nice!) I don't know if I like seeing "#\ " in code, but this nevertheless prevented me from simply loading Arc 3.1's strings.arc to get the functions I wanted.

~~~

The following don't actually have much to do with Lathe. They're only corner cases that came to mind just now:

~~~

- The expressions (is (obj a 1) (obj a 1)) and (iso (obj a 1) (obj a 1)) return t in Jarc even though they return nil in Arc 3.1. The first is a bug, but the second is arguably a feature, and it's consistent with Anarki.

- The result of (odd:len:copy (table) (annotate t t) t (annotate t t) t) is nil in Jarc even though it's t in Arc 3.1 (since Scheme's vectors have special 'equals? behavior).

~~~

- ssyntax is now expanded at closure time (I noticed this yesterday too, bad...) - can now parse "#\ " - fixed (fn () in) - fixed (fn ())

quasiquote is called backquote for historical reasons. I'll change this when I update Jarc to Arc 3.1

'(is (obj a 1) (obj a 1)) and (iso (obj a 1) (obj a 1))'

Yeah, the latter is useful. They both return t because they share the same code, I can't see any simple, elegant way to have the former fail and latter work.

And I wish I didn't have to choose between Arc behavior and Anarki behavior. I'll probably go with Arc semantics. Yeah, Anarki arc.arc can always be used to get Anarki semantics.

In the process of getting to that point, I did find a few more things:

- The some-macro.arg case was only partially fixed. In particular, some-macro.arg.another-arg slipped through the cracks, as well as the case where some-macro.arg is in function parameter position. All these give 2 when they should give 1:

  (mac foo (_) '[do 1])
  (def bar () foo.baz.0)
  (mac foo (_) '[do 2])
  (bar)
  
  (mac foo (_) 1)
  (def bar () (idfn foo.baz))
  (mac foo (_) 2)
  (bar)
  
  (mac foo (_) t)
  (def bar () (if foo.baz 1 2))
  (mac foo (_) nil)
  (bar)

- On the other hand, when I changed some of my some-macro.arg.another-arg forms to (some-macro.arg another-arg), I got errors. That's because they were expressions sent to 'setforms, and I'm not quite sure of the nature of this problem, but apparently 'setforms checks the car of the expression, sees that the 'metafn function returns t for it (since 'some-macro.arg has ssyntax), and then tries to 'expand-metafn-call the form even though it isn't really a metafn call. I wasn't able to reproduce this on other versions of Arc, but I didn't try much. The workaround was just to put my code back the way it was, 'cause in (= some-macro.arg.another-arg foo), the ssyntax will expand all in a single step.

- Setting a table entry to nil doesn't remove it. This didn't actually get in my way, and I'm not a big fan of this part of Arc's behavior, but it makes me wonder whether Jarc has any way at all to remove table entries.

- Jarc gensyms are of the form "g1234" rather than "gs1234." This should almost never come up as a problem, but it is a difference.

- Jarc doesn't define 'sref on lists. This means you can't do (++ (q 2)), where q is a list. Since this is an example taken right out of 'enq, queues don't work either. I worked around this by redefining 'enq using (++ (car:cddr q)).

- The type of 0 is num rather than int. In order to check whether something was really an integer, I ended up doing a Java call.

- More aspects of Arc 2 popped up, like 'trunc being absent and 'accum returning its list in reverse order. I won't bother trying to make a list.

That's it for the moment. The next steps, when I get around to them, will probably be reverting Lathe's workarounds that are no longer necessary.