iris-script

An experiment in modern end-user language design, hybridizing [hopefully] the best aspects of Logo and AppleScript, with bits of Perl, Tcl, Lisp, Swift, etc thrown in as appropriate. Obvious anagram. Implemented in Swift.

Example

tell app “com.apple.TextEdit” to do
    make new: #document at: end of documents with_properties: {name: “Test”, text: “Hello again!”}
    get text of every document
done

➞ [“Hello again!”]

Build

Dependencies:

Ad-hoc tests are currently run under the iris-test target.

Try it

The iris-script project includes iris-talk, a basic interactive command-line interface (REPL) for demonstration use.

Example usage (✎ indicates input prompt):

✎ say "Hello World!"
☺︎ “Hello World!”

See iris-talk/README.txt for more information.

Features

Homoiconic, minimalist core language, with only two foundational concepts: values and commands. “Everything is a Command.” The core language and concepts must be quickly and easily learned; everything else should be discoverable if/as/when needed.

Readable, word-based syntax with basic English-like punctuation rules. Each built-in punctuation has a single, unambiguous meaning:

lists:

[…]

records:

{…}

grouping (of zero or more expressions):

(…)

string literals can be written using “typographer’s quotes” as well as traditional straight quotes:

“…”  
"…"

Commas, periods and/or linebreaks are used as expression delimiters.

Colons denote label: value pairs; semi-colons denote “pipes” (foo; bar {2} ➞ bar {foo, 2}).

Standard built-in value types: numbers, strings, symbols (“hashtags”), lists (both ordered and key-value; aka arrays and dictionaries), records (tuple-struct hybrid).

Syntactic support (via chainable lexers) for currencies, weights and measures, e.g. $12.02, 42kg, 97.5°C. Literal representations of dates and times should be achievable too: 2020-07-11, 06:40:55.

Identifiers use snake_case. This allows easy, unambiguous detection of word boundaries within multi-word names, and should allow tooling to fuzzily match space-separated words against known identifiers and replace spaces with underscores automatically. Pretty printers may also de-emphasize underscores (e.g. by reducing opacity) for a more “English-like” visual appearance without losing semantic clarity.

Commands and blocks (sequences of expressions) are also first-class values; thus iris code is also iris data.

Shift-reduce parser with some customizations to detect expression boundaries and to identify and reduce commands and operators using PEG-style pattern matching. Bottom-up parsing supports incremental/interactive use. Syntax errors are non-halting, enabling rough/unfinished code to be at least partially executed in debug mode, even with typos.

Ubiquitous use of parameterizable coercions (which are also first-class values) for automatic type conversion and constraint checking, e.g. list returns a basic (unspecialized) list coercion, whereas list {of: whole_number {from: 0, to: 100}, min: 4, max: 4} returns a list coercion with additional element type and length constraints. Code is untyped; however, handler interfaces can include coercion information to provide both auto-generated user documentation and run-time conversions and checks that handler arguments and results are suitable for use. Weak latent structural rather than strong nominal typing: “If a value looks acceptable, it [generally] is.”

No built-in behavior beyond evaluating values. All other behavior is provided by library-supplied handlers. This includes “standard” behaviors such as assignment and flow control. e.g. It is trivial to define a JSON-style data-transfer language and safely parse and render it: instantiate an Environment containing no commands or operators except those used to represent true/false/nothing and evaluate code in that. Similarly, the iris-glue code generator imports only a subset of stdlib functionality (coercions) and instead obtains its main behavior from gluelib.

Commands are effectively unary prefix operators with an arbitrary name and optional (record) operand, e.g.:

make {new: #document, at: end of documents, with_properties: {name: “Test”}}

For convenience, an argument’s record punctation can usually be omitted:

make new: #document at: end of documents with_properties: {name: “Test”}

Arguments are matched by label where given or by position where not, e.g. given a handler with interface foo {x as integer, y as integer}, foo x: 10 y: 20 and foo {10, 20} are both acceptable.

Unlike most imperative languages, command arguments are evaluated by the receiving handler, not at the call site. This allows for deferred evaluation of command arguments, where argument expressions are passed unevaluated and unbound (in a primitive handler), or automatically thunked with the command’s scope before being added to a native handler’s body scope, to be evaluated later only if/when needed. Flow control operations are thus implemented as ordinary handlers; the only difference is in the parameter type, e.g. if {test as boolean, action as expression, alternate_action as expression}.

Library-defined commands may be skinned with library-defined operator syntax. e.g. The above code, represented as commands only (single quotes escape names):

‘tell’ {‘app’ {"com.apple.TextEdit"}, (
    ‘make’ {new: #‘document’, at: ‘of’ {‘end’, ‘documents’}, with_properties: {name: "Test", text: "Hello again!"}}, 
    ‘get’ {‘of’ {‘text’, ‘every’ {‘document’}}}
)})

“No variables.” (Distinctions between values, variables, and types are confusing to novices.) Values stored under symbolic names are retrieved using commands of the same name. Immutable, bind-on-first-use behavior is default.

Separate operators for performing math vs non-math comparisons (similar to Perl where numbers and text are one type), e.g. 4 < 12, “Bob” is_before “Sue”, ensuring predictable behavior, e.g. “4” < 12 ➞ true. (Contrast e.g. AppleScript/JavaScript where mixed-type comparisons behave differently according to operand order.)

Coercion-based native⬌Swift bridging API for implementing primitive library functions, ensuring clean separation between Swift implementation and automatically generated native-to-Swift bridging glue code. Glue definitions are written in iris and evaluated via the gluelib library. e.g. The if…then…else… handler’s glue definition, including custom operator syntax:

to ‘if’ {test: condition as boolean, then: action as expression, 
         else: alternative_action as expression} returning anything requires {
    can_error: true
    use_scopes: #command
    swift_function: ifTest {condition, action, alternativeAction}
    operator: {[keyword “if”, expr “condition”, keyword “then”, expr “action”,
                optional sequence [keyword “else”, expr “alternative_action”]],
               precedence: 101}
}

and its underlying Swift implementation:

func ifTest(condition: Bool, action: Value, alternativeAction: Value, commandEnv: Scope) throws -> Value {
    return try asAnything.coerce(condition ? action : alternativeAction, in: commandEnv)
}

(Contrast the complexity and coupling of Python/Ruby’s C bridging APIs.)

Interpreter is implemented as slow (but very introspectable) AST walker. Rich native-language interface metadata and clean decoupling of underlying primitive functions should enable partial/full transpilation of native iris code to optimized Swift code, e.g. eliminating redundant native➞primitive➞native bridging coercions so that Swift functions can pass Swift values directly.

e.g. Consider the expression:

“HELLO, ” & uppercase my_name

Handler definitions:

to uppercase {text as string} returning string requires { }

to ‘&’ {left as string, right as string} returning string requires {
    can_error: true
    swift_function: joinValues
    operator: {form: #infix, precedence: 340}
}

Swift functions:

func uppercase(text: String) -> String { return text.uppercased() }

func joinValues(left: String, right: String) throws -> String { return left + right }

Generated Swift code, obviating the unnecessary String➞Text➞String bridging coercions between the uppercase and & (concatenation) commands:

let native_value  = try env.get("my_name")
let swift_value   = try asString.coerce(native_value, in: env)
let swift_result  = try joinValues(left: "HELLO, ", right: uppercase(text: swift_value))
let native_result = asString.wrap(swift_result, in: env)

Additional transpiling optimizations might include storing values directly in Swift variables rather than native Environment slots and replacing simple function calls with template-based Swift code:

let swift_result = "HELLO, \(swift_my_name.uppercased())"

TO DO