Show HN: `diff arc0 arc3.1`

Re:Show HN: `diff arc0 arc3.1` by skissane on Friday October 16, 2015 @12:08AM (#10397416)

Given we already have so many dialects of Lisp, what value does Arc offer that they do not? Why should I choose to learn/use Arc, as opposed to (say) Scheme or Common Lisp or Clojure?

[ Parent | on HN ]

Re:Show HN: `diff arc0 arc3.1` by laarc on Friday October 16, 2015 @01:10AM (#10397572)

A brief laundry list:

- Arc embraces macros.

- You can redefine anything. (assign + -) (+ 3 4) evaluates to -1. Not only are you an equal partner to the language, but the language is short enough to carry in your head.

- Green threads. Here's a snippet from Laarc which does hot code reloading:

  (thread
    (on-err autoerr (fn ()
                      (while autoload*
                        (sleep 0.25)
                        (autoreload)))))

It says "When an error happens, call the 'autoerr' function. Every 0.25 sec, check whether any source has changed, and reload it if so."

But green threads make it so easy to do that in parallel. I never once had to worry about synchronization issues in the case of the autoreloader.

- There's no FFI for Arc. However, I'm in the process of porting Arc from Racket to Lumen, which has a very interesting FFI thanks to LuaJIT: https://github.com/sctb/motor/blob/master/motor.l

It's literally "copy-paste these C declarations. Now you can call those C functions." It quite simply rocks.

If you're interested in Arc, consider Lumen as well. https://github.com/sctb/lumen

It has many similarities to Arc, like a powerful macro system, and has some interesting distinctions, like keyword arguments and the FFI facilities.

[ Parent | on HN ]

Re:Show HN: `diff arc0 arc3.1` by mveety on Friday October 16, 2015 @02:24AM (#10397756)

Yeah lumen's ffi is fantastic. It's really simple and clear compared to like CFFI or so. Seeing that ported to/implemented on CL would be really cool.

[ Parent | on HN ]