parser-combinator
Version:
Parser combinators
194 lines (144 loc) • 9.18 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*
* Parsec
* https://github.com/d-plaindoux/parsec
*
* Copyright (c) 2016 Didier Plaindoux
* Licensed under the LGPL2 license.
*/
var _try = require('../data/try.js');
var _try2 = _interopRequireDefault(_try);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
/**
* Response basic type
* fold() is an abstract method implemented in Accept and Reject
*/
var Response = function () {
function Response() {
_classCallCheck(this, Response);
}
_createClass(Response, [{
key: 'isAccepted',
// Response 'a 'c => unit -> bool
value: function isAccepted() {
return this.fold(function () {
return true;
}, function () {
return false;
});
}
// Response 'a 'c => unit -> bool
}, {
key: 'toTry',
value: function toTry() {
return this.fold(function (accept) {
return _try2.default.success(accept.value);
}, function (reject) {
return _try2.default.failure(new Error('parser error at ' + reject.offset));
});
}
}]);
return Response;
}();
/**
* Reject response class
*/
var Reject = function (_Response) {
_inherits(Reject, _Response);
function Reject(offset, consumed) {
_classCallCheck(this, Reject);
var _this = _possibleConstructorReturn(this, (Reject.__proto__ || Object.getPrototypeOf(Reject)).call(this));
_this.offset = offset;
_this.consumed = consumed;
return _this;
}
// Response 'a 'c => (Accept 'a 'c -> 'a) -> (Reject 'a 'c -> 'a) -> 'a
_createClass(Reject, [{
key: 'fold',
value: function fold(_, reject) {
return reject(this);
}
// Response 'a 'c => ('a -> 'b) -> Response 'b 'c
}, {
key: 'map',
value: function map() {
return this;
}
// Response 'a 'c => ('a -> Response 'b 'c) -> Response 'b 'c
}, {
key: 'flatmap',
value: function flatmap() {
return this;
}
// Response 'a 'c => ('a -> bool) -> Response 'b 'c
}, {
key: 'filter',
value: function filter() {
return new Reject(this.offset, false);
}
}]);
return Reject;
}(Response);
/**
* Accept response class
*/
var Accept = function (_Response2) {
_inherits(Accept, _Response2);
function Accept(value, input, offset, consumed) {
_classCallCheck(this, Accept);
var _this2 = _possibleConstructorReturn(this, (Accept.__proto__ || Object.getPrototypeOf(Accept)).call(this));
_this2.offset = offset;
_this2.consumed = consumed;
_this2.value = value;
_this2.input = input;
return _this2;
}
// Response 'a 'c => (Accept 'a 'c -> 'a) -> (Reject 'a 'c -> 'a) -> 'a
_createClass(Accept, [{
key: 'fold',
value: function fold(accept) {
return accept(this);
}
// Response 'a 'c => ('a -> 'b) -> Response 'b 'c
}, {
key: 'map',
value: function map(callback) {
return new Accept(callback(this.value), this.input, this.offset, this.consumed);
}
// Response 'a 'c => ('a -> Response 'b 'c) -> Response 'b 'c
}, {
key: 'flatmap',
value: function flatmap(callback) {
return callback(this.value);
}
// Response 'a 'c => ('a -> bool) -> Response 'b 'c
}, {
key: 'filter',
value: function filter(predicate) {
if (predicate(this.value)) {
return this;
} else {
return new Reject(this.offset, false);
}
}
}]);
return Accept;
}(Response);
/**
* Constructors
*/
var accept = function accept(value, sequence, offset, consumed) {
return new Accept(value, sequence, offset, consumed);
};
var reject = function reject(offset, consumed) {
return new Reject(offset, consumed);
};
var response = { accept: accept, reject: reject };
exports.default = response;
//# sourceMappingURL=response.js.map