@masala/parser/src/test/genlex/genlex-operation.js

Masala Parser

import {getMathGenLex} from '../../lib/genlex/genlex';
import {F} from '../../lib/parsec/index';
import stream from '../../lib/stream/index';

/*
 Implementing general solution :
 E -> T E'
 E' -> + TE'  |  eps
 T -> F T'
 T' -> * FT'  |  eps
 F -> NUMBER | ( E )   (https://en.wikipedia.org/wiki/Operator-precedence_parser)



 * Expr -> SubExpr then OptYieldExpr
 * OptYieldExpr -> YieldExpr.opt()
 * YieldExpr ->  + then SubExpr then YieldExpr
 * PriorExpr -> Terminal then OptPriorExpr
 * OptPriorExpr -> PriorExpr.opt()
 * PriorExpr ->  * then Terminal then OptPriorExpr
 * Terminal -> (Expr)| Number | -Terminal | Expr  // care of priority !

 */


// tokens
const genlex = getMathGenLex();
const {number, plus, minus, mult, div, open, close} = genlex.tokens();

const priorToken = () => mult.or(div);
const yieldToken = () => plus.or(minus);

function terminal() {
    return parenthesis()
        .or(number)
        .or(negative())
        .or(F.lazy(expression))
}

function negative() {
    return minus.drop().then(F.lazy(terminal)).single().map(x => -x);
}

function parenthesis() {
    return open.drop().then(F.lazy(expression)).then(close.drop()).single()
}

function expression() {
    return priorExpr().flatMap(optYieldExpr);
}


function optYieldExpr(left) {

    return yieldExpr(left).opt()
        .map(opt => opt.isPresent() ? opt.get() : left)
}

function yieldExpr(left) {
    return yieldToken()
        .then(priorExpr())
        .array()
        .map(([token, right]) =>
            token === '+' ? left + right : left - right)
        .flatMap(optYieldExpr);
}


function priorExpr() {
    return terminal().flatMap(optSubPriorExp);
}

function optSubPriorExp(priorValue) {
    return subPriorExpr(priorValue).opt()
        .map(opt => opt.isPresent() ? opt.get() : priorValue);
}


function subPriorExpr(priorValue) {

    return priorToken().then(terminal())
        .array()
        .map(([token, left]) => token === '*' ? priorValue * left : priorValue / left)
        .flatMap(optSubPriorExp)
}


function multParser() {

    const parser = expression();

    return genlex.use(parser.then(F.eos().drop()).single());
}

export default {
    setUp: function (done) {
        done();
    },

    'expect multExpr to make mults': function (test) {
        let parsing = multParser().parse(stream.ofString('3 * 4'));
        test.equal(parsing.value, 12, 'simple multiplication');

        parsing = multParser().parse(stream.ofString('14 / 4'));

        test.equal(parsing.value, 3.5, 'simple division');

        parsing = multParser().parse(stream.ofString('14 / 4*3 '));

        test.equal(parsing.value, 10.5, 'combine mult and div');

        parsing = multParser().parse(stream.ofString('14 / 4*3 /2*  2 '));

        test.equal(parsing.value, 10.5, 'combine more mult and div');

        test.done();
    },
    'expect multExpr to make negative priorities': function (test) {
        let parsing = multParser().parse(stream.ofString('3 * -4'));
        test.equal(parsing.value, -12, 'negative multiplication');

        test.done();
    },
    'expect Expr to be inside parenthesis': function (test) {

        let parsing = multParser().parse(stream.ofString('3 * (4)'));
        test.equal(parsing.value, 12, 'simple parenthesis expr');

        parsing = multParser().parse(stream.ofString('3 * (2*4)'));
        test.equal(parsing.value, 24, 'more complexe parenthesis expr');

        parsing = multParser().parse(stream.ofString('3 * (2*(4))'));
        test.equal(parsing.value, 24, 'deep parenthesis expr');

        test.done();
    },
    'expect + and * to respect priorities': function (test) {

        let parsing = multParser().parse(stream.ofString('3 +2*4 '));
        test.equal(parsing.value, 11, 'simple multiplication');

        test.done();
    },

    'expect - and / to respect priorities': function (test) {

        let parsing = multParser().parse(stream.ofString('3 + -4/2*5 '));
        test.equal(parsing.value, -7, 'bad priorities');

        test.done();
    },

}