
Rark: A Racket language inspired by Arc - zeeshanm
https://github.com/kogir/rark
======
kogir
I wrote this when I started work on HN as a way to learn more about Racket and
Arc, and in an attempt to get more useful results from Racket's sampling
profiler.

I think I got about 80% of things working, but even then I had to make some
undesirable compromises. It became clear it was a dead end and would never
make sense to use for HN in production.

~~~
soegaard
That's interesting. Why was it a dead end?

Was it due to the (too dynamic) semantics of Arc?

Or perhaps you have too much code written in standard Arc to make infeasible
to port?

------
istvan__
Is there more information available on this one? I am not getting the concept
of it...

~~~
soegaard
Judging from the code, the main idea is to implement the Arc (or Arc-like)
language using the standard techniques used to implement new languages in
Racket. This approach will make it easy to use the tools/infrastructure of
Racket without any changes (correct highlighting, arrows between a variable
and its binding, scope aware renaming of variables, profiler, etc.). The new
language compiles via macro expansion to Racket which is then compiled and
jitted as normal.

If I recall correct the original implementation of Arc was written as an
interpreter - and thus the Racket set of tools are not available.

The main benefit is that the new language will run faster than standard Arc.

As a bonus it will be possible to use module written in Rark from Racket code
- and use modules written in Racket in Rark modules.

~~~
stijlist
If it's helpful, the original implementation of Arc was actually quite similar
to this - a bunch of macros that compiled down to MzScheme (which eventually
became PLT scheme, which eventually became Racket!).

~~~
soegaard
I found Arc version 3.1 on arclanguage.org. It does compile to (Mz)Scheme -
but it does not use the MzScheme macro expander. It reads Arc program as an
s-expression. Compiles the program and produces an mzscheme program also
represented as an s-expression. The "problem" is that s-expressions doesn't
track source location of identifiers. That made it impossible for the old Arc
implementation to reuse the MzScheme tools.

Some the libraries were written using Arc-macros that expanded into simpler
Arc constructs, but MzScheme macros weren't uses in that process.

Note: PLT Scheme was the names used when MzScheme, DrScheme and a few other
tools was distributed together.

------
fnord123
AFAIK, Arc is built on Racket already.

