Hi! I've been working on a Lisp interpreter in Ruby that is fully
integrated (I mean -- fully. The aim is to have basically nothing
specific to the interpreter and use Ruby for everything. Basic rule of
thumb: you should be able to use it to write a Rails app with no extra
pain than in Ruby.)

Some examples:

  '(1 2 3) => (1 2 3)
  [1 2 3] => [1 2 3]
  ([] empty?) => true
  (puts (if ([] empty?) "hello world" "oh no")) => hello world

Now, I hope to have some code released Real Soon Now (it really isn't
usable enough yet; needs some reworking). But I'd like the Ruby
community's opinion on some few things, to try and make it as Ruby-ish
as possible. So, dump of things I've thought about:

- should # be used as a comment marker (instead of ;)? it might get in
the way of *something*, lisp dialects tend to use it a lot, but #\c
will probably be ?c, #t/#f is true/false, and #(...) is [...] so I'm
not sure.

- should 'a be ruby's :a? that could mess up pretty printing, e.g.:
    '(a b c) => (:a :b :c)
  if 'a is something other than :a, what should
  it be? a subclass of Symbol that just overrides pretty-printing, i
  guess. and then :a would be ruby's :a.

- syntax for dicts? if we take the above idea, I think something like:
    {:a 2 :b 3} => {:a => 2, :b => 3}
  would be nice, but again there's the problem that pretty-printing loses out.
  however I don't think that Ruby's syntax should be re-used directly, because
  it's not lisp-like.

- how to call out to ruby. what happens if you pass a list to a ruby function?
  I could recursively translate them to arrays, but that's expensive and
  if you're calling out to something that wants to directly use the object
  or is one of the functions that doesn't care what type its object is,
  it might not even be expected behaviour. also, should i translate a_b to a-b?
  vise-versa?

- on a similar note, what class is (lambda (x) x)? if a Proc I have to
  have a trampoline in the Proc, which isn't nice. a subclass of Proc?

- how to handle blocks. some ideas:
    ([1 2 3] map (lambda (x) (+ x 1)))
  that means I have to do arity stuff, and presents a problem -- what if
  'map' there was variadic? are we passing a function, or a block?
    ([1 2 3] map (do (x) (+ x 1)))
  here 'do' creates something internally treated as a block. again the
  variadic problem, relating to my "what if the func/method doesn't care
  about the type it gets"?
    ([1 2 3] map do (x) (+ x 1))
  this is a little bit hard to read, but unambigious. of course, now you
  can't use "do" in most places. a multiline example of this:
    ([0 1 2 3 4 5] map do (x)
      (if (= (% x 2) 0)
          (+ x 5)
          (- x 4)))
  this is my preferred syntax at the moment, actually. maybe i could hijack
  {...} somehow (don't really like that idea).

- (def (func ...) ...) or (def func (...) ...)? the former seems more rubyish
  to me, i guess. (def (foo) ...) instead of (def foo () ...).

- this thing:
    >> foo = 3
    => 3
    >> def foo; 4 end
    => nil
    >> foo
    => 3
    >> method(:foo).call
    => 4
  since this thing will emulate a Lisp-1 (basically), how should this be
  handled? maybe in the same way.

- and closely linked to that: since a 0-arg function is used often in Ruby
  in place of a variable (but -- mostly in a method, where this would be
  (obj foo) so it wouldn't be a problem). you'd have to do (foo) currently,
  which would differenciate it from foo.

- also related: watch this imaginary session in the Lisp REPL
    >> (def foo 3)
    => 3
    >> (def (foo) 4)
    => #<LProc:0xF00BAR00@(lisp):2>
    >> foo
    => 3 or #<LProc:0xF00BAR00@(lisp):2>?!
    >> (foo)
    => "you can't call a Fixnum!" or 4?

this clashes with Lisp-1-ness, certainly.

Anyway, that's the end of this long post for now. Feel free to ignore
my ramblings, but to leave, here's a few code examples that don't actually work
right now and may look completely different when they do :-)

  ;; Output "I love Ruby"
  (def say "I love Ruby")
  (puts say)

  ;; Output "I *LOVE* RUBY"
  (set! (say "love") "*love*") ;; set! name?
  (puts (say upcase))

  ;; Output "I *love* Ruby" five times
  (5 times do (puts say))

and the second:

  (class Numeric
    (def (plus x)
      (self + x)
      ;; or (the same, but variadic)
      (+ self x)))

Well, OK. Have a third.

  (def search-engines
    (%w[Google Yahoo MSN] map do (engine)
      (+ "http://www." (engine downcase) ".com")))

-ehird