gram:scope

> ./README.md

Lenses
(coming soon!)

# Scope(s)

> a many-use grammar, parser, and linking engine; [due:2025]. 

Scope is an early grammar describing a programming language.
Such grammar should someday be able to reproduce the `nix` language,
enabling coders to re-compose some older, superb nix recipes,
in a more modern and dynamic manner of programming.

Remember `neovim`?
No one imagined how ambitious the program had been.
Aside from the basics of remaking the core command-line app,
`vim` has a rich array of plug-in hooks,
and innumerable public add-on bundles,
and no one had the energy to keep up any more.

So the problem had no good openings.
Neovim began, as I recall the phrasing, "an aggressive refactoring";
in essence this embodied a migration of the code from `vimscript` to `lua`.

Once the core program had been re-arranged as a `lua` program,
suddenly so much of the landscape became so much simpler.
You could load in `lua` code you made locally,
plugins could choose from both languages,
and the idea changed shape to embrace many newly-possible directions.

- - -

NixOS and ancillary programs are in a real bind these days,
based on [public dialogue][1].
A serious break has already occurred;
[Auxolotl][2] hopes to replace the original program and brand.

Scope is designed as a malleable language, moldable enough to replace `nix`,
and exceeding the precursor's demands in many original directions.
Such a large aim can be approached simply by choosing sensible markup
 to represent a usually-obscured programming paradigm,
"scope", and focusing on such as the core ideological and organizational piece.

In any common programming language, "scope" has a common meaning;
and in some sense this is based on an analogy to an engineering idea around for millenia.

A sailor may describe the "scope" of an anchored ship as the full range of places
the ship may occupy, so long as the anchor is presumed secure in place. 
This marine usage of the phrase,
in practice a dependency of the length of rope or chain deployed,
has a clear relationship to programming usage;
in a sea of endless memory, "scope" holds all of the possible places you can reach. 

[1]: https://save-nix-together.org/
[2]: https://auxolotl.org

- - -

In such an early phase, please see a couple special places:

* [src/main.rs](scope/src/main.rs) has some language samples, and checks the parser.
* [src/grammar/sample.pest](scope/src/grammar/sample.pest) is an early language grammar.

Any remaining code measures are simply exercises;
numerous parser libraries are popular enough in Rust,
so experimentation has been necessary.

Scope uses a grammar based on [pest](https://pest.rs/),
emphasizing readable expressions, quick operation, and clear errors.
This underlying grammar-building library is also to blame
for much of [Nushell](https://www.nushell.sh/)'s success.

[due:2025]: /chronicle/2024-payload