# Lyn

Old swedish for maple.

## Scheme is cool

...but has too many parentheses.

## TCL is cool (yes, it really is)

...but littering `$` all over the place is annoying.

## Can we build something in-between?

Maybe. `lyn` is effectively a pre-processor for GNU Guile, adopting TCL's
'everything is a command' attitude while keeping Scheme semantics.

Let's start with an example, `examples/guile.lyn`:

```
define-syntax-rule (for init condition post body) {
	expand init
	do () ((not (expand condition))) {
		expand body
		expand post
	}
}

define (sum n) {
	define s 0
	for (define i 0) (< i n) (set! i (1+ i)) {
		set! s (+ s i)
	}
	get s
}

display (sum 1000000)
newline
```

If you're familiar with Scheme, this should look eerily familiar.
Effectively, a command starts with a thing to apply, follows with some arguments
and ends with a newline or `;`. `()` applies a command to be used as an
argument, and `{}` specifies a list of commands. The top-level can also be
thought of as a block of commands.

When encountering a `{`, a matching `}` must be found before the command can be
finished. `{}` can itself contain newlines just fine.

A command can also be continued over multiple lines by using `\`, as in
`examples/multiline.lyn`:
```
if (< 10 20) \
        {display "math works"; newline} \
        {display "what"; newline}
```

There are two 'builtins' beyond what GNU Guile provides (all GNU Guile functions
can be called as commands), namely `get` and `expand`. They're effectively the
identity commands, i.e. `get` returns the value that was passed into it, and
`expand` expands a macro as if `expand` weren't there. These are useful because,
again, *literally* everythin is a command, so if you want to return a value you
can't just write `arg` as the last element of a `(begin ...)` or whatever,
because that value will be interpreted as a command. Same thing with macros.
Note that `values` is effectively the same thing as `get`, but I think `get` has
a nicer symmetry with `let`/`set`. `macroexpand` is (maybe somewhat
surprisingly) not equivalent to `expand`, as `macroexpand` can't handle
`(define ...)`.

Since `;` ends commands, `#` is used for comments instead.

The current implementation just outputs all code into `/tmp/output.scm`.
Terrible, I know, but good enough to start playing around with it.
Have a look at that file to see just how closely this syntax matches Scheme,
while (IMO) being easier to read. In particular I find this style to be easier
to write, as I sometimes find that I have to count how many parentheses deep
some expression is. I'm aware that there are tools that help with this, but I
tend to want to have as little between me and my code.

## Drawbacks

+ Code generation is arguably not as trivial as with S-expressions. Ideally
  traditional Scheme functions could be interleaved with this syntax, though I
  haven't really looked into this option.

+ Certain coding styles (like placing `{` on a new line) are more clumsy to use

+ The current implementation parses `()` with multiple commands but produces
  incorrect Scheme. I'm not sure whether to fix the outputting or disallow
  multiple commands within `()` (that's what `{}` is for)

## Isn't this all a bit silly?

Yes.

Schemers are presumably used to the parentheses and would prefer them over this,
while the TCL crowd likely don't like the shift away from user interfaces. I
don't expect anyone to really have any interest in this thing, but if I'd get to
choose I would probably want to use a scripting language like this over any
other current alternatives, of which there are many excellent ones.

## Building and running

`make`, after which `./lyn examples/guile.scm` for example. REPL not supported
at the moment, though it probably could be added.