type2/lib/plankton/plankton.d.ts

/**
 * @author fenris
 */
declare type int = number;
/**
 * @author fenris
 */
declare type float = number;
/**
 * @author fenris
 */
declare type type_time = {
    hours: int;
    minutes: int;
    seconds: int;
};
/**
 * @author fenris
 */
declare type type_pseudopointer<type_value> = {
    value: type_value;
};
/**
 * @author fenris
 */
declare function pseudopointer_null<type_value>(): type_pseudopointer<type_value>;
/**
 * @author fenris
 */
declare function pseudopointer_make<type_value>(value: type_value): type_pseudopointer<type_value>;
/**
 * @author fenris
 */
declare function pseudopointer_isset<type_value>(pseudopointer: type_pseudopointer<type_value>): boolean;
/**
 * @author fenris
 */
declare function pseudopointer_read<type_value>(pseudopointer: type_pseudopointer<type_value>): type_value;
/**
 * @author fenris
 */
declare function pseudopointer_write<type_value>(pseudopointer: type_pseudopointer<type_value>, value: type_value): void;
declare var process: any;
declare var require: any;
declare class Buffer {
    constructor(x: string, modifier?: string);
    toString(modifier?: string): string;
}
declare var java: any;
declare module lib_base {
    /**
     * @author fenris
     */
    function environment(): string;
}
/**
 * @author fenris
 */
declare var instance_verbosity: int;
/**
 * @desc the ability to check for equality with another element of the same domain
 * @author fenris
 */
interface interface_collatable<type_value> {
    /**
     * @author fenris
     */
    _collate(value: type_value): boolean;
}
/**
 * @author fenris
 */
declare function instance_collate<type_value>(value1: type_value, value2: type_value): boolean;
/**
 * @desc the ability to compare with another element of the same domain for determining if the first is "smaller than or equal to" the latter
 * @author fenris
 */
interface interface_comparable<type_value> {
    /**
     * @author fenris
     */
    _compare(value: type_value): boolean;
}
/**
 * @author fenris
 */
declare function instance_compare<type_value>(value1: type_value, value2: type_value): boolean;
/**
 * @desc the ability to create an exact copy
 * @author fenris
 */
interface interface_cloneable<type_value> {
    /**
     * @author fenris
     */
    _clone(): type_value;
}
/**
 * @author fenris
 */
declare function instance_clone<type_value>(value: type_value): type_value;
/**
 * @author fenris
 */
interface interface_hashable {
    /**
     * @author fenris
     */
    _hash(): string;
}
/**
 * @desc the ability to generate a string out of the element, which identifies it to a high degree
 * @author fenris
 */
declare function instance_hash<type_value>(value: type_value): string;
/**
 * @author fenris
 */
interface interface_showable {
    /**
     * @author fenris
     */
    _show(): string;
}
/**
 * @desc the ability to map the element to a textual representation (most likely not injective)
 * @author fenris
 */
declare function instance_show<type_value>(value: type_value): string;
/**
 * @todo outsource to dedicated plankton-lib
 */
declare module lib_log {
    /**
     * @author fenris
     */
    function log(...args: Array<any>): void;
    /**
     * @author fenris
     */
    function info(...args: Array<any>): void;
    /**
     * @author fenris
     */
    function warn(...args: Array<any>): void;
    /**
     * @author fenris
     */
    function error(...args: Array<any>): void;
}
/**
 * @author frac
 */
interface interface_decorator<type_core> {
    /**
     * @author frac
     */
    core: type_core;
}
/**
 * @author frac
 */
declare class class_observer {
    /**
     * @author frac
     */
    protected counter: int;
    /**
     * @author frac
     */
    protected actions: {
        [id: string]: (information: Object) => void;
    };
    /**
     * @author frac
     */
    protected buffer: Array<Object>;
    /**
     * @author frac
     */
    constructor();
    /**
     * @author frac
     */
    empty(): boolean;
    /**
     * @author frac
     */
    flush(): void;
    /**
     * @author frac
     */
    set(id: string, action: (information: Object) => void): void;
    /**
     * @author frac
     */
    del(id: string): void;
    /**
     * @author frac
     */
    add(action: (information: Object) => void): void;
    /**
     * @author frac
     */
    notify(information?: Object, delayed?: boolean): void;
    /**
     * @author frac
     */
    rollout(): void;
}
/**
 * @author frac
 */
/**
 * @author frac
 */
declare module lib_maybe {
    /**
     * @author fenris
     */
    type type_maybe<type_value> = {
        kind: string;
        parameters: Object;
    };
    /**
     * @author fenris
     */
    function make_nothing<type_value>(): type_maybe<type_value>;
    /**
     * @author fenris
     */
    function make_just<type_value>(value: type_value): type_maybe<type_value>;
    /**
     * @author fenris
     */
    function is_nothing<type_value>(maybe: type_maybe<type_value>): boolean;
    /**
     * @author fenris
     */
    function is_just<type_value>(maybe: type_maybe<type_value>): boolean;
    /**
     * @author fenris
     */
    function cull<type_value>(maybe: type_maybe<type_value>): type_value;
    /**
     * @author fenris
     */
    function propagate<type_value, type_value_>(maybe: type_maybe<type_value>, function_: (value: type_value) => type_maybe<type_value_>): type_maybe<type_value_>;
}
/**
 * @author fenris
 */
declare class class_maybe<type_value> implements interface_showable {
    /**
     * @desc whether the wrapper is nothing
     * @author fenris
     */
    is_nothing(): boolean;
    /**
     * @desc whether the wrapper is just
     * @author fenris
     */
    is_just(): boolean;
    /**
     * @desc return the value, stored in the maybe-wrapper
     * @author fenris
     */
    cull(): type_value;
    /**
     * @author fenris
     */
    toString(): string;
    /**
     * @author fenris
     */
    distinguish(action_just: (value?: type_value) => void, action_nothing?: (reason?: string) => void): void;
    /**
     * @author fenris
     */
    propagate<type_value_>(action: (value: type_value) => class_maybe<type_value_>): class_maybe<type_value_>;
    /**
     * @desc [implementation]
     * @author fenris
     */
    _show(): string;
}
/**
 * @author fenris
 */
declare class class_nothing<type_value> extends class_maybe<type_value> {
    /**
     * @author fenris
     */
    private reason;
    /**
     * @author fenris
     */
    constructor(reason?: string);
    /**
     * @author fenris
     */
    is_nothing(): boolean;
    /**
     * @author fenris
     */
    is_just(): boolean;
    /**
     * @author fenris
     */
    cull(): type_value;
    /**
     * @author fenris
     */
    toString(): string;
    /**
     * @author fenris
     */
    reason_get(): string;
    /**
     * @author fenris
     */
    distinguish(action_just: (value?: type_value) => void, action_nothing?: (reason?: string) => void): void;
    /**
     * @author fenris
     */
    propagate<type_value_>(action: (value: type_value) => class_maybe<type_value_>): class_maybe<type_value_>;
}
/**
 * @author fenris
 */
declare class class_just<type_value> extends class_maybe<type_value> {
    /**
     * @author fenris
     */
    private value;
    /**
     * @author fenris
     */
    constructor(value: type_value);
    /**
     * @author fenris
     */
    is_nothing(): boolean;
    /**
     * @author fenris
     */
    is_just(): boolean;
    /**
     * @author fenris
     */
    cull(): type_value;
    /**
     * @author fenris
     */
    toString(): string;
    /**
     * @author fenris
     */
    distinguish(action_just: (value?: type_value) => void, action_nothing?: (reason?: string) => void): void;
    /**
     * @author fenris
     */
    propagate<type_value_>(action: (value: type_value) => class_maybe<type_value_>): class_maybe<type_value_>;
}
/**
 * @author frac
 */
declare class class_error extends Error {
    /**
     * @author frac
     */
    protected suberrors: Array<Error>;
    /**
     * @author frac
     */
    protected mess: string;
    /**
     * @author frac
     */
    constructor(message: string, suberrors?: Array<Error>);
    /**
     * @override
     * @author frac
     */
    toString(): string;
}
declare namespace lib_plankton.log {
    /**
     */
    enum enum_level {
        debug = 0,
        info = 1,
        notice = 2,
        warning = 3,
        error = 4
    }
    /**
     */
    function level_order(level1: enum_level, level2: enum_level): boolean;
    /**
     */
    function level_show(level: enum_level): string;
    /**
     */
    type type_entry = {
        level: enum_level;
        incident: string;
        details: {
            [name: string]: any;
        };
    };
}
/**
 * @deprecated
 * @todo remove
 */
declare module lib_log {
    function level_push(level: int): void;
    function level_pop(): void;
    function indent_push(indent: int): void;
    function indent_pop(): void;
    function indent_inc(): void;
    function indent_dec(): void;
    /**
     * @author fenris
     */
    function write({ "message": message, "type": type, "prefix": prefix, "level": level, "indent": indent, }: {
        message?: string;
        type?: string;
        prefix?: string;
        level?: int;
        indent?: int;
    }): void;
}
declare namespace lib_plankton.log {
    /**
     */
    abstract class class_channel {
        /**
         */
        abstract add(entry: type_entry): void;
    }
}
declare namespace lib_plankton.log {
    /**
     */
    class class_channel_console extends class_channel {
        /**
         */
        add(entry: type_entry): void;
    }
}
declare namespace lib_plankton.log {
    /**
     */
    class class_channel_notify extends class_channel {
        /**
         */
        add(entry: type_entry): void;
    }
}
declare namespace lib_plankton.log {
    /**
     */
    class class_channel_minlevel extends class_channel {
        /**
         */
        private core;
        /**
         */
        private threshold;
        /**
         */
        constructor(core: class_channel, threshold: enum_level);
        /**
         */
        add(entry: type_entry): void;
    }
}
declare namespace lib_plankton.log {
    /**
     */
    function channel_make(description: {
        kind: string;
        data?: {
            [key: string]: any;
        };
    }): class_channel;
}
declare namespace lib_plankton.log {
    /**
     */
    function conf_default(): Array<class_channel>;
    /**
     */
    function conf_push(channels: Array<class_channel>): void;
    /**
     */
    function conf_pop(): void;
    /**
     */
    function setup(): void;
    /**
     */
    function add(entry: type_entry): void;
    /**
     */
    function debug(incident: string, details?: {
        [name: string]: any;
    }): void;
    /**
     */
    function info(incident: string, details?: {
        [name: string]: any;
    }): void;
    /**
     */
    function notice(incident: string, details?: {
        [name: string]: any;
    }): void;
    /**
     */
    function warning(incident: string, details?: {
        [name: string]: any;
    }): void;
    /**
     */
    function error(incident: string, details?: {
        [name: string]: any;
    }): void;
}
declare namespace lib_args {
    /**
     */
    enum enum_environment {
        cli = "cli",
        url = "url"
    }
    /**
     */
    enum enum_kind {
        positional = "positional",
        volatile = "volatile"
    }
    /**
     */
    enum enum_type {
        boolean = "boolean",
        integer = "int",
        float = "float",
        string = "string"
    }
    /**
     */
    enum enum_mode {
        replace = "replace",
        accumulate = "accumulate"
    }
}
declare module lib_args {
    /**
     * @author fenris
     */
    class class_argument {
        /**
         * @author fenris
         */
        protected name: string;
        /**
         * @author fenris
         */
        protected kind: enum_kind;
        /**
         * @author fenris
         */
        protected type: enum_type;
        /**
         * @author fenris
         */
        protected mode: enum_mode;
        /**
         * @author fenris
         */
        protected default_: any;
        /**
         * @author fenris
         */
        protected info: string;
        /**
         * @author fenris
         */
        protected parameters: Object;
        /**
         * @author fenris
         */
        protected hidden: boolean;
        /**
         * @author fenris
         */
        constructor({ "name": name, "type": type, "kind": kind, "mode": mode, "default": default_, "info": info, "parameters": parameters, "hidden": hidden, }: {
            name: string;
            type?: enum_type;
            kind?: enum_kind;
            mode?: enum_mode;
            default?: any;
            info?: string;
            parameters?: Object;
            hidden?: boolean;
        });
        /**
         * @author fenris
         */
        static positional({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "index": index, }: {
            name: string;
            type?: enum_type;
            mode?: enum_mode;
            default?: any;
            info?: string;
            hidden?: boolean;
            index: int;
        }): class_argument;
        /**
         * @author fenris
         */
        static volatile({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "indicators_short": indicators_short, "indicators_long": indicators_long, }: {
            name: string;
            type?: enum_type;
            mode?: enum_mode;
            default?: any;
            info?: string;
            hidden?: boolean;
            indicators_short: Array<string>;
            indicators_long: Array<string>;
        }): class_argument;
        /**
         * @author fenris
         */
        check(): boolean;
        /**
         * @author fenris
         */
        name_get(): string;
        /**
         * @author fenris
         */
        kind_get(): enum_kind;
        /**
         * @author fenris
         */
        type_get(): enum_type;
        /**
         * @author fenris
         */
        mode_get(): enum_mode;
        /**
         * @author fenris
         */
        default_get(): any;
        /**
         * @author fenris
         */
        parameters_get(): Object;
        /**
         * @author fenris
         */
        hidden_get(): boolean;
        /**
         * @author fenris
         */
        toString(): string;
        /**
         * @author fenris
         */
        indicator_main(): string;
        /**
         * @author fenris
         */
        pattern_value(): string;
        /**
         * @author fenris
         */
        extract(raw: string): any;
        /**
         * @author fenris
         */
        assign(data: Object, target: string, raw: string): void;
        /**
         * @author fenris
         */
        make(data: Object, target: string): string;
        /**
         * @author fenris
         */
        generate_help(): string;
    }
}
declare module lib_args {
    /**
     * @author fenris
     */
    var verbosity: int;
    /**
     * @author fenris
     * @todo check validity
     */
    class class_handler {
        /**
         * @author fenris
         */
        protected arguments_: {
            [name: string]: class_argument;
        };
        /**
         * @author fenris
         */
        constructor(arguments_: {
            [name: string]: class_argument;
        });
        /**
         * @author fenris
         */
        filter(kind: enum_kind): {
            [name: string]: class_argument;
        };
        /**
         * @author fenris
         */
        read(environment: enum_environment, input: string, data?: {
            [name: string]: any;
        }): {
            [name: string]: any;
        };
        /**
         * @author fenris
         * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
         */
        write(environment: enum_environment, data: {
            [name: string]: any;
        }): string;
        /**
         * @desc manpage-like info-sheet
         * @author fenris
         */
        generate_help({ "programname": programname, "author": author, "description": description, "executable": executable, }: {
            programname?: string;
            author?: string;
            description?: string;
            executable?: string;
        }): string;
    }
}
declare namespace lib_plankton.file {
    /**
     * @author fenris
     */
    function read(path: string): Promise<string>;
    /**
     * @author fenris
     */
    function read_stdin(): Promise<string>;
    /**
     * @author fenris
     */
    function write(path: string, content: string): Promise<void>;
}
declare module lib_observer {
    /**
     * @author fenris
     */
    type type_eventname = string;
    /**
     * @author fenris
     */
    type type_data = any;
    /**
     * @author fenris
     */
    type type_action = (data: type_data) => void;
    /**
     * @author fenris
     */
    type type_observer = {
        actions: {
            [eventname: string]: Array<type_action>;
        };
        force_registration: boolean;
        no_attendants_warn_do: boolean;
        no_attendants_warn_action: (eventname: type_eventname) => void;
    };
    /**
     * @author fenris
     */
    function make({ "force_registration": force_registration, "no_attendants_warn_do": no_attendants_warn_do, "no_attendants_warn_action": no_attendants_warn_action, }?: {
        force_registration?: boolean;
        no_attendants_warn_do?: boolean;
        no_attendants_warn_action?: (eventname: type_eventname) => void;
    }): type_observer;
    /**
     * @author fenris
     */
    function register(observer: type_observer, eventname: type_eventname): void;
    /**
     * @author fenris
     */
    function attend(observer: type_observer, eventname: type_eventname, action: type_action): void;
    /**
     * @author fenris
     */
    function notify(observer: type_observer, eventname: type_eventname, data: type_data): void;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    type char = string;
    /**
     * @author fenris
     */
    type type_terminal_default = {
        id: string;
        data?: Object;
    };
    /**
     * @author fenris
     */
    function find<type_x, type_y>(word: Array<type_x>, part: Array<type_y>, equality: (x: type_x, y: type_y) => boolean, /*= instance_collate*/ right_to_left?: boolean): int;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    interface interface_symbol<type_terminal, type_variable, type_meaning> {
        /**
         * @author fenris
         */
        equals(symbol: interface_symbol<type_terminal, type_variable, type_meaning>): boolean;
        /**
         * @author fenris
         */
        toString(): string;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    class class_symbol_terminal<type_terminal, type_variable, type_meaning> implements interface_symbol<type_terminal, type_variable, type_meaning> {
        /**
         * @author fenris
         */
        protected terminal: type_terminal;
        /**
         * @author fenris
         */
        protected equality_terminal: (x: type_terminal, y: type_terminal) => boolean;
        /**
         * @desc [constructor]
         * @author fenris
         */
        constructor(terminal: type_terminal, equality_terminal?: (x: type_terminal, y: type_terminal) => boolean);
        /**
         * @author fenris
         */
        terminal_get(): type_terminal;
        /**
         * @override
         * @author fenris
         */
        equals(symbol: interface_symbol<type_terminal, type_variable, type_meaning>): boolean;
        /**
         * @override
         * @author fenris
         */
        toString(): string;
        /**
         * @author fenris
         */
        static tree_generic<type_terminal, type_variable>(terminal: type_terminal): class_symbol_terminal<type_terminal, type_variable, type_tree<type_terminal>>;
        /**
         * @author fenris
         */
        static tree_default(terminal: type_terminal_default): class_symbol_terminal<type_terminal_default, string, type_tree<type_terminal_default>>;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    class class_symbol_variable<type_terminal, type_variable, type_meaning> implements interface_symbol<type_terminal, type_variable, type_meaning> {
        /**
         * @author fenris
         */
        protected variable: type_variable;
        /**
         * @author fenris
         */
        protected meaning: type_meaning;
        /**
         * @desc [constructor]
         * @author fenris
         */
        constructor(variable: type_variable, meaning?: type_meaning);
        /**
         * @desc [accessor] [getter]
         * @author fenris
         */
        variable_get(): type_variable;
        /**
         * @desc [accessor] [getter]
         * @author fenris
         */
        meaning_get(): type_meaning;
        /**
         * @override
         * @author fenris
         */
        equals(symbol: interface_symbol<type_terminal, type_variable, type_meaning>): boolean;
        /**
         * @override
         * @author fenris
         */
        toString(): string;
        /**
         * @author fenris
         */
        static tree_generic<type_terminal, type_variable>(variable: type_variable): class_symbol_variable<type_terminal, type_variable, type_tree<type_terminal>>;
        /**
         * @author fenris
         */
        static tree_default(variable: string): class_symbol_variable<type_terminal_default, string, type_tree<type_terminal_default>>;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    interface interface_lexer<type_character, type_terminal> {
        /**
         * @author fenris
         */
        run(input: Array<type_character>): Array<type_terminal>;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    type type_token<type_character, type_terminal> = {
        sequence: Array<type_character>;
        terminal: class_maybe<type_terminal>;
    };
    /**
     * @author fenris
     */
    type type_lexerrule<type_character, type_terminal> = {
        search: (part: Array<type_character>) => {
            found: boolean;
            data?: {
                position?: int;
                length?: int;
            };
        };
        construct: (part: Array<type_character>) => Array<type_terminal>;
        observer: lib_observer.type_observer;
    };
    /**
     * @author fenris
     */
    function lexerrule_make<type_character, type_terminal>(search: (part: Array<type_character>) => {
        found: boolean;
        data?: {
            position?: int;
            length?: int;
        };
    }, construct: (part: Array<type_character>) => Array<type_terminal>): type_lexerrule<type_character, type_terminal>;
    /**
     * @author fenris
     * @todo schön machen? is aber vermutlich gar nicht möglich :/
     */
    function lexerrule_show<type_character, type_terminal>(rule: type_lexerrule<type_character, type_terminal>): string;
    /**
     * @author fenris
     */
    function lexerrule_apply<type_character, type_terminal>(rule: type_lexerrule<type_character, type_terminal>, tokens: Array<type_token<type_character, type_terminal>>): Array<type_token<type_character, type_terminal>>;
    /**
     * @author fenris
     */
    function lexerrule_pass<type_character>(): type_lexerrule<type_character, type_character>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_generic(rule_raw: {
        pattern: string;
        construct: (part: Array<char>) => Array<type_terminal_default>;
    }): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_ignore(pattern: string): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_void(pattern: string, id: string): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_boolean(pattern: string, id: string, value: boolean): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_int(pattern: string, id: string): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_float(pattern: string, id: string): type_lexerrule<char, type_terminal_default>;
    /**
     * @author fenris
     */
    function lexerrule_pattern_string(pattern: string, id: string): type_lexerrule<char, type_terminal_default>;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     * @todo warn on prefix-detection
     * @todo after rule application don't start from the beginning but from the last position
     */
    type type_lexer_dumb<type_character, type_terminal> = {
        rules: Array<type_lexerrule<type_character, type_terminal>>;
        observer: lib_observer.type_observer;
    };
    /**
     * @author fenris
     */
    function lexer_dumb_make<type_character, type_terminal>(rules: Array<type_lexerrule<type_character, type_terminal>>): type_lexer_dumb<type_character, type_terminal>;
    /**
     * @author fenris
     */
    function lexer_dumb_run<type_character, type_terminal>(subject: type_lexer_dumb<type_character, type_terminal>, input: Array<type_character>, configuration?: {
        use_reduce?: boolean;
    }): Array<type_terminal>;
    /**
     * @author fenris
     */
    function lexer_dumb_pass<type_character>(): type_lexer_dumb<type_character, type_character>;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    class class_lexerrule<type_character, type_terminal> {
        /**
         * @author fenris
         */
        protected subject: type_lexerrule<type_character, type_terminal>;
        /**
         * @author fenris
         */
        constructor(subject: type_lexerrule<type_character, type_terminal>);
        /**
         * @author fenris
         */
        static construct<type_character, type_terminal>({ "search": search, "construct": construct, }: {
            search: (part: Array<type_character>) => {
                found: boolean;
                data?: {
                    position?: int;
                    length?: int;
                };
            };
            construct: (part: Array<type_character>) => Array<type_terminal>;
        }): class_lexerrule<type_character, type_terminal>;
        /**
         * @author fenris
         */
        subject_get(): type_lexerrule<type_character, type_terminal>;
        /**
         * @author fenris
         */
        search(part: Array<type_character>): {
            found: boolean;
            data?: {
                position?: int;
                length?: int;
            };
        };
        /**
         * @author fenris
         */
        construct(part: Array<type_character>): Array<type_terminal>;
        /**
         * @author fenris
         */
        static pass<type_character>(): class_lexerrule<type_character, type_character>;
        /**
         * @author fenris
         */
        static pattern_generic(rule_raw: {
            pattern: string;
            construct: (part: Array<char>) => Array<type_terminal_default>;
        }): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_ignore(pattern: string): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_void(pattern: string, id: string): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_boolean(pattern: string, id: string, value: boolean): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_int(pattern: string, id: string): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_float(pattern: string, id: string): class_lexerrule<char, type_terminal_default>;
        /**
         * @author fenris
         */
        static pattern_string(pattern: string, id: string): class_lexerrule<char, type_terminal_default>;
    }
    /**
     * @author fenris
     */
    class class_lexer_dumb<type_character, type_terminal> implements interface_lexer<type_character, type_terminal> {
        /**
         * @author fenris
         */
        protected subject: type_lexer_dumb<type_character, type_terminal>;
        /**
         * @author fenris
         */
        constructor(subject: type_lexer_dumb<type_character, type_terminal>);
        /**
         * @author fenris
         */
        static construct<type_character, type_terminal>(rules: Array<class_lexerrule<type_character, type_terminal>>): class_lexer_dumb<type_character, type_terminal>;
        /**
         * @author fenris
         */
        run(input: Array<type_character>): Array<type_terminal>;
        /**
         * @author fenris
         */
        static pass<type_character>(): class_lexer_dumb<type_character, type_character>;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    interface interface_parser<type_terminal, type_variable, type_meaning> {
        /**
         * @param input the input sequence to parse
         * @param target_variable if not passed, this value should fall back to the start symbol of the grammar
         * @author fenris
         */
        run(input: Array<type_terminal>, target_variable?: type_variable): type_meaning;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    type type_tree<type_terminal> = {
        label?: string;
        value: Array<type_terminal>;
        children: Array<type_tree<type_terminal>>;
    };
    /**
     * @author fenris
     */
    type type_parserrule<type_terminal, type_variable, type_meaning> = {
        premise: type_variable;
        conclusion: Array<interface_symbol<type_terminal, type_variable, type_meaning>>;
        construct: (args: Array<type_meaning>, terminals: Array<type_terminal>) => type_meaning;
        right_to_left: boolean;
    };
    /**
     * @desc [constructor]
     * @author fenris
     */
    function parserrule_make<type_terminal, type_variable, type_meaning>({ "premise": premise, "conclusion": conclusion, "construct": construct, "right_to_left": right_to_left, }: {
        premise: type_variable;
        conclusion: Array<interface_symbol<type_terminal, type_variable, type_meaning>>;
        construct: (args: Array<type_meaning>, terminals: Array<type_terminal>) => type_meaning;
        right_to_left?: boolean;
    }): {
        premise: type_variable;
        conclusion: interface_symbol<type_terminal, type_variable, type_meaning>[];
        construct: (args: type_meaning[], terminals: type_terminal[]) => type_meaning;
        right_to_left: boolean;
    };
    /**
     * @author fenris
     */
    function parserrule_check<type_terminal, type_variable, type_meaning>(parserrule: type_parserrule<type_terminal, type_variable, type_meaning>, sequence: Array<interface_symbol<type_terminal, type_variable, type_meaning>>): int;
    /**
     * @author fenris
     */
    function parserrule_construct<type_terminal, type_variable, type_meaning>(parserrule: type_parserrule<type_terminal, type_variable, type_meaning>, args: Array<type_meaning>, terminals: Array<type_terminal>): type_meaning;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     * @todo fatal error on empty conclusion
     */
    type type_parser_dumb<type_terminal, type_variable, type_meaning> = {
        start: type_variable;
        rules: Array<type_parserrule<type_terminal, type_variable, type_meaning>>;
        equality_terminal: (x: type_terminal, y: type_terminal) => boolean;
        observer: lib_observer.type_observer;
    };
    /**
     * @author fenris
     */
    function parser_dumb_make<type_terminal, type_variable, type_meaning>(start: type_variable, rules: Array<type_parserrule<type_terminal, type_variable, type_meaning>>, equality_terminal?: (x: type_terminal, y: type_terminal) => boolean): type_parser_dumb<type_terminal, type_variable, type_meaning>;
    /**
     * @override
     * @author fenris
     */
    function parser_dumb_run<type_terminal, type_variable, type_meaning>(parser_dumb: type_parser_dumb<type_terminal, type_variable, type_meaning>, input: Array<type_terminal>, target_variable?: type_variable): type_meaning;
    /**
     * @author fenris
     */
    function parser_dumb_tree<type_terminal, type_variable>(start: type_variable, rules_raw: Array<{
        premise: type_variable;
        conclusion: Array<interface_symbol<type_terminal, type_variable, type_tree<type_terminal>>>;
        label?: string;
        right_to_left?: boolean;
    }>, equality_terminal?: (x: type_terminal, y: type_terminal) => boolean): type_parser_dumb<type_terminal, type_variable, type_tree<type_terminal>>;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    class class_parserrule<type_terminal, type_variable, type_meaning> {
        /**
         * @author fenris
         */
        protected subject: type_parserrule<type_terminal, type_variable, type_meaning>;
        /**
         * @desc [constructor]
         * @author fenris
         */
        private constructor();
        /**
         * @desc [constructor]
         * @author fenris
         */
        static construct<type_terminal, type_variable, type_meaning>({ "premise": premise, "conclusion": conclusion, "construct": construct, "right_to_left": right_to_left, }: {
            premise: type_variable;
            conclusion: Array<interface_symbol<type_terminal, type_variable, type_meaning>>;
            construct: (args: Array<type_meaning>, terminals: Array<type_terminal>) => type_meaning;
            right_to_left?: boolean;
        }): class_parserrule<type_terminal, type_variable, type_meaning>;
        /**
         * @desc [accessor] [getter]
         * @author fenris
         */
        subject_get(): type_parserrule<type_terminal, type_variable, type_meaning>;
        /**
         * @desc [accessor] [getter]
         * @author fenris
         */
        premise_get(): type_variable;
        /**
         * @desc [accessor] [getter]
         * @author fenris
         */
        conclusion_get(): Array<interface_symbol<type_terminal, type_variable, type_meaning>>;
        /**
         * @desc [accessor]
         * @author fenris
         */
        check(sequence: Array<interface_symbol<type_terminal, type_variable, type_meaning>>): int;
        /**
         * @desc [accessor]
         * @author fenris
         */
        construct(args: Array<type_meaning>, terminals: Array<type_terminal>): type_meaning;
    }
    /**
     * @author fenris
     * @todo fatal error on empty conclusion
     */
    class class_parser_dumb<type_terminal, type_variable, type_meaning> implements interface_parser<type_terminal, type_variable, type_meaning> {
        /**
         * @author fenris
         */
        protected subject: type_parser_dumb<type_terminal, type_variable, type_meaning>;
        /**
         * @author fenris
         */
        private constructor();
        /**
         * @author fenris
         */
        static construct<type_terminal, type_variable, type_meaning>(start: type_variable, rules: Array<class_parserrule<type_terminal, type_variable, type_meaning>>, equality_terminal?: (x: type_terminal, y: type_terminal) => boolean): class_parser_dumb<type_terminal, type_variable, type_meaning>;
        /**
         * @override
         * @author fenris
         */
        run(input: Array<type_terminal>, target_variable?: type_variable): type_meaning;
        /**
         * @author fenris
         */
        static tree<type_terminal, type_variable>(start: type_variable, rules_raw: Array<{
            premise: type_variable;
            conclusion: Array<interface_symbol<type_terminal, type_variable, type_tree<type_terminal>>>;
            label?: string;
            right_to_left?: boolean;
        }>, equality_terminal?: (x: type_terminal, y: type_terminal) => boolean): class_parser_dumb<type_terminal, type_variable, type_tree<type_terminal>>;
    }
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    function reader_run<type_character, type_terminal, type_variable, type_meaning>(lexer_run: (input: Array<type_character>) => Array<type_terminal>, parser_run: (input: Array<type_terminal>, target_variable?: type_variable) => type_meaning, input: Array<type_character>, target_variable?: type_variable): type_meaning;
    /**
     * @author fenris
     */
    type type_parser_rule_default = {
        premise: string;
        conclusion: Array<interface_symbol<type_terminal_default, string, type_tree<type_terminal_default>>>;
        label?: string;
        right_to_left?: boolean;
    };
    /**
     * @author fenris
     */
    function reader_default({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }: {
        lexer_rules: Array<class_lexerrule<char, type_terminal_default>>;
        parser_start: string;
        parser_rules: Array<type_parser_rule_default>;
    }): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
    /**
     * @author fenris
     */
    type type_raw_parser_rule = {
        premise: string;
        conclusion: Array<{
            type: string;
            parameters?: Object;
        }>;
        label?: string;
        right_to_left?: boolean;
    };
    /**
     * @author fenris
     */
    function default_raw(input: any): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
}
declare namespace lib_plankton.lang {
    /**
     * @author fenris
     */
    class class_reader<type_character, type_terminal, type_variable, type_result> {
        /**
         * @author fenris
         */
        protected lexer: interface_lexer<type_character, type_terminal>;
        /**
         * @author fenris
         */
        protected parser: interface_parser<type_terminal, type_variable, type_result>;
        /**
         * @author fenris
         */
        constructor(lexer: interface_lexer<type_character, type_terminal>, parser: interface_parser<type_terminal, type_variable, type_result>);
        /**
         * @desc [accessor] yes, it's really just lexing and parsing
         * @author fenris
         */
        run(input: Array<type_character>, target_variable?: type_variable): type_result;
        /**
         * @author fenris
         */
        static default({ "lexer_rules": lexer_rules, "parser_start": parser_start, "parser_rules": parser_rules, }: {
            lexer_rules: Array<class_lexerrule<char, type_terminal_default>>;
            parser_start: string;
            parser_rules: Array<{
                premise: string;
                conclusion: Array<interface_symbol<type_terminal_default, string, type_tree<type_terminal_default>>>;
                label?: string;
                right_to_left?: boolean;
            }>;
        }): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
        /**
         * @author fenris
         */
        static default_raw(input: any): class_reader<char, type_terminal_default, string, type_tree<type_terminal_default>>;
    }
}