0.1.0 docs





    Jun 1, 2018

    Lucas Saldyt
    Arizona State University @fargonauts
    Tempe, Arizona


    Index of all namespaces

    « Project + dependencies

    Ari is a continued investigation into computational linguistics. Basically, ari is a framework for doing programming language research. Right now, it is a parser-generator, but eventually it will become a capable translator, based on glossa (

    General lexing module. Converts a raw text file into a list of tagged words based on defined lexical rules
    Ari's parsing module:
    The core of ari's input: this module allows for the EBNF/pyBNF grammars to be specified, so that other grammars can be read in by ari.
    Other grammars are then converted to this set of parser-functions.
    Parser structure
    [tokens log] -> [{tree}, [remaining tokens log]]
    If the parser is unsuccessful, then {tree} will actually be nil, signifying error.
    The log argument is a dictionary, usually with the keys :all and :head defined as a subdictionary and key-list respectively.
    Parse technique:
    Given multiple parsers:
    While tokens are available for input..
    For each available parser, try its first element
    If this matches, keep the parser in the group of possible parsers
    If it does not match, remove the parser from the current possible set
    If there are no parsers left, throw an error.
    TODO: Once there is no input left, create a parse tree with the longest parser. If two syntax elements are ambiguous, throw an error.
    The README below is fetched from the published project artifact. Some relative links may be broken.


    Ari is a rewrite of glossa written in Clojure. Ari has several goals:

    • The parsing of any language specified in Backus-Naur form into a recursive dictionary structure.
    • Then, a backend will be created that converts certain AST features into a low-level language.
    • Then, the Ari software will be used to do research in language translation.
    • Specifically, Ari will be used to research things like extensions to existing logic languages, simple semantic translation in a microdomain, and creation of more fluid programming languages.

    These are just some basic ideas about what to do with ari. First, though, I’ll be building ari up to the point that glossa left off. I found that C++, while efficient, was not semantically capable of handling abstract translations. The existing Clojure solution uses about 10x less code, if not less.