Nylon Pendulum Movement

    prsc
    TypeScript icon, indicating that this package has built-in type declarations

    4.0.0 • Public • Published

    prsc

    NPM version CI

    Tiny parser combinators library for JavaScript and TypeScript. Heavily inspired by nom.

    Installation

    The prsc library can be installed using npm or yarn:

    npm install --save prsc

    or

    yarn add prsc

    The package includes both a UMD bundle (dist/prsc.js), compatible with Node.js, and an ES6 module (dist/prsc.mjs). TypeScript typings are included (dist/prsc.d.ts) and should work automatically in most cases.

    Usage

    This library exports a number of functions that make it easy to build parsers for input represented as a string. Start from primitive parsers such as token or your own functions matching the Parser type, transform results using map and filter and combine them using the other functions such as then and star.

    Example

    The following parser accepts a simple arithmetic language consisting of the + and * operators:

    // Create a primitive parser that accepts a single digit
    const digit = (input, offset) => {
    	if (/^[0-9]$/.test(input[offset])) {
    		return ok(offset + 1);
    	}
    	return error(offset, ['digit']);
    };
    
    // Use that to accept a string of one or more digits
    const digits = plus(digit);
    
    // Then use recognize to get the matching string and use map to parse that into a number
    const number = map(recognize(digits), (str) => parseInt(str, 10));
    
    // Multiplication
    const term = then(
    	number,
    	star(preceded(token('*'), number)),
    	// Multiply everything together
    	(num, factors) => factors.reduce((product, factor) => product * factor, num)
    );
    
    // Addition
    const expression = then(term, star(preceded(token('+'), term)), (num, terms) =>
    	terms.reduce((sum, term) => sum + term, num)
    );
    
    // Parsing some input
    console.log(expression('2*3+4*5', 0));
    // > { success: true, offset: 7, value: 26 }

    Tips

    Use functions to provide a layer of indirection for recursive definitions:

    const term = then(number, optional(preceded(token('*'), termIndirect)), ...);
    function termIndirect(input, offset) {
    	return term(input, offset);
    }

    Use the typings when working in TypeScript for strongly-typed parsers:

    const digit: Parser<string> = ...;
    const digits = plus(digit); // Parser<string[]>
    const number = map(
    	digits,
    	strs => parseInt(strs.join(''), 10)
    ); // Parser<number>

    Install

    npm i prsc

    DownloadsWeekly Downloads

    11,263

    Version

    4.0.0

    License

    MIT

    Unpacked Size

    105 kB

    Total Files

    9

    Last publish

    Collaborators

    • bwrrp