parser-combinator/build/lib/parsec/flow-bundle.js

Parser combinators

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _unit = require('../data/unit.js');

var _unit2 = _interopRequireDefault(_unit);

var _parser = require('./parser');

var _parser2 = _interopRequireDefault(_parser);

var _response = require('./response');

var _response2 = _interopRequireDefault(_response);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// (Stream 'c -> number -> Response 'a 'c) -> Parser 'a 'c
function parse(p) {
    return new _parser2.default(p);
}

// (('b -> Parser 'a 'c) * 'b)-> Parser 'a 'c
/*
 * Parsec
 * https://github.com/d-plaindoux/parsec
 *
 * Copyright (c) 2016 Didier Plaindoux
 * Licensed under the LGPL2 license.
 */

function lazy(p, parameters) {
    // equivalent of p(...parameters), but would fail if parameters are undefined
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return p.apply(p.prototype, parameters).parse(input, index);
    });
}

// 'a -> Parser 'a 'c
function returns(v) {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return _response2.default.accept(v, input, index, false);
    });
}

// unit -> Parser 'a 'c
function error() {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return _response2.default.reject(input.location(index), false);
    });
}

// unit -> Parser unit 'c
function eos() {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;

        if (input.endOfStream(index)) {
            return _response2.default.accept(_unit2.default, input, index, false);
        } else {
            return _response2.default.reject(input.location(index), false);
        }
    });
}

// ('a -> boolean) -> Parser a 'c
function satisfy(predicate) {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return input.get(index).filter(predicate).map(function (value) {
            return _response2.default.accept(value, input, index + 1, true);
        }).lazyRecoverWith(function () {
            return _response2.default.reject(input.location(index), false);
        });
    });
}

// Parser 'a 'c -> Parser 'a 'c
function doTry(p) {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return p.parse(input, index).fold(function (accept) {
            return accept;
        }, function (reject) {
            return _response2.default.reject(input.location(reject.offset), false);
        });
    });
}

// unit -> Parser 'a 'c
function any() {
    return satisfy(function () {
        return true;
    });
}

// unit -> Parser 'a 'c
function nop() {
    return new _parser2.default(function (input) {
        var index = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        return _response2.default.accept([], input, index, true);
    });
}

// Parser 'a ? -> Parser 'a 'a
function not(p) {
    return doTry(p).then(error()).or(any());
}

// int -> Parser (List 'a') a'
function subStream(length) {
    return any().occurrence(length);
}

function sequence() {
    var current = nop();
    for (var v in arguments) {
        current = current.then(arguments[v]);
    }
    return current;
}

exports.default = {
    parse: parse,
    try: doTry,
    any: any(),
    subStream: subStream,
    not: not,
    lazy: lazy,
    returns: returns,
    error: error(),
    eos: eos(),
    satisfy: satisfy,
    sequence: sequence
};
//# sourceMappingURL=flow-bundle.js.map