The Zia project aims to develop a programming language that can be used to program itself.
Instead of storing the source code as plain text and editing the raw text (which can easily break
the program), the runtime environment of the interpreter (the Context) can be saved to disk and
used in other programs. All the programming is done using an interactive shell such as
IZia or via an online IDE.
The commands sent are interpreted based on the Context. They are used to incrementally modify, test
and debug the Context.
Expressions for Zia commands represent a binary tree where parentheses group a pair of expressions
and a space separates a pair of expressions. For example "(ll lr) (rl rr)" represents a perfect
binary tree of height 2 with leaves "ll", "lr", "rl", "rr" going from left to right.
The leaves of the tree can be any unicode string without spaces or parentheses. These symbols may be recognised by the intepreter as concepts or if not used to label new concepts.
Currently, only the lowest-level functionality has been implemented. It's important that programs
are represented consistently and transparently within the Context in order to achieve a
self-describing system. The syntax shown below may appear awkward but more convenient syntax will
be possible once more functionality is added. For example, the need to group pairs of expressions
in parentheses will be alleviated by functionality to set the relative precedence and associativity
of concepts.
So far there are 10 built-in concepts. A new Context labels these with the symbols, "label_of",
"->", ":=", "let", "true", "false", "assoc", "right", "left", "prec", "deafult", ">" but the labels
can be changed to different symbols for different languages or disciplines.
```rust extern crate zia; use zia::{Context, ZiaError};
// Construct a new Context using the new method
let mut context = Context::new();
// Specify operator precedence for let and ->.
asserteq!(context.execute("let default > prec ->"), "");
asserteq!(context.execute("let (prec ->) > prec let"), "");
// Cannot yet infer partial order. Requires implication to express transitive property
assert_eq!(context.execute("let default > prec let"), "");
// Specify the rule that the concept "a b" reduces to concept "c" asserteq!(context.execute("let a b -> c"), ""); asserteq!(context.execute("a b"), "c");
// Change the rule so that concept "a b" instead reduces to concept "d" asserteq!(context.execute("let a b -> d"), ""); asserteq!(context.execute("a b"), "d");
// Change the rule so "a b" doesn't reduce any further asserteq!(context.execute("let a b -> a b"), ""); asserteq!(context.execute("a b"), "a b");
// Try to specify a rule that already exists asserteq!(context.execute("let a b -> a b"), ZiaError::RedundantReduction.tostring()); asserteq!(context.execute("let a b -> c"), ""); asserteq!(context.execute("let a b -> c"), ZiaError::RedundantReduction.to_string());
// Relabel "labelof" to "표시" asserteq!(context.execute("let 표시 := labelof"), ""); asserteq!(context.execute("표시 a b"), "\'c\'");
// You can reduce a labelled concept assert_eq!(context.execute("let a -> d"), "");
// Try to specify the composition of a concept in terms of itself asserteq!(context.execute("let b := a b"), ZiaError::InfiniteDefinition.tostring());
// Try to specify the reduction of concept in terms of itself asserteq!(context.execute("let c d -> (c d) e"), ZiaError::ExpandingReduction.tostring());
// Determine the truth of a reduction asserteq!(context.execute("a -> d"), "true"); asserteq!(context.execute("d -> a"), "false");
// A concept never reduces to itself assert_eq!(context.execute("a -> a"), "false");
// Cannot reduce a reduction expression between unrelated concepts assert_eq!(context.execute("d -> f"), "d -> f");
// Can ask whether a reduction is true or false asserteq!(context.execute("(a -> d) -> true"), "true"); asserteq!(context.execute("(d -> a) -> false"), "true");
// Let an arbitary symbol be true asserteq!(context.execute("let g"), ""); asserteq!(context.execute("g"), "true");
// Let an arbitary expression be true asserteq!(context.execute("let h i j"), ""); asserteq!(context.execute("h i j"), "true");
// Determine associativity of symbol assert_eq!(context.execute("assoc a"), "right");
// Define patterns asserteq!(context.execute("let _x and false -> false"), ""); assert_eq!(context.execute("foo and false"), "false"); ```
License: GPL-3.0