Displaying 1 to 20 from 53 results

nom - Rust parser combinator framework

  •    Rust

nom is a parser combinators library written in Rust. Its goal is to provide tools to build safe parsers without compromising the speed or memory consumption. To that end, it uses extensively Rust's strong typing and memory safety to produce fast and correct parsers, and provides macros and traits to abstract most of the error prone plumbing. If you need any help developing your parsers, please ping geal on IRC (mozilla, freenode, geeknode, oftc), go to #nom on Mozilla IRC, or on the Gitter chat room.

combine - A parser combinator library for Rust

  •    Rust

An implementation of parser combinators for Rust, inspired by the Haskell library Parsec. As in Parsec the parsers are LL(1) by default but they can opt-in to arbitrary lookahead using the try combinator. Larger examples can be found in the examples, tests and benches folders.

parsimmon - A monadic LL(infinity) parser combinator library for javascript

  •    Javascript

Parsimmon is a small library for writing big parsers made up of lots of little parsers. The API is inspired by parsec and Promises/A+. Parsimmon supports IE7 and newer browsers, along with Node.js. It can be used as a standard Node module through npm (named parsimmon), or directly in the browser through a script tag, where it exports a global variable called Parsimmon. To download the latest browser build, use the unpkg version. For more information on how to use unpkg, see the unpkg homepage.




scala-parser-combinators - simple combinator-based parsing for Scala

  •    Scala

This library is now community-maintained. If you are interested in helping please contact @gourlaysama or mention it on Gitter. As of Scala 2.11, this library is a separate jar that can be omitted from Scala projects that do not use Parser Combinators.

yay - Yay is a high level PHP preprocessor

  •    PHP

This means that language features could be distributed as composer packages (as long as the macro based implementations can be expressed in pure PHP code, and the implementation is fast enough). Roadmap.

pyparsing

  •    Python

The pyparsing module is an alternative approach to creating and executing simple grammars, vs. the traditional lex/yacc approach, or the use of regular expressions. The pyparsing module provides a library of classes that client code uses to construct the grammar directly in Python code. The Python representation of the grammar is quite readable, owing to the self-explanatory class names, and the use of '+', '|' and '^' operator definitions.

parsekt - Parser Combinator library for Kotlin

  •    Kotlin

Parser combinator library for Kotlin which makes writing parsers easier


parseback - A Scala implementation of parsing with derivatives

  •    Scala

Parsing with derivatives may be viewed as a form of breadth-first recursive descent. Breadth-first search is orthogonal to depth-first search, and two lines which are orthogonal in two-dimensional Euclidean space may also be said to be perpendicular. Thus, an appropriate name for this library might be "parsper", as a shortening of "parse perpendicular". Such a name is eminently googleable and implies a wealth of potential Star Trek puns. Unfortunately, it looks far too much like a typo. Thus, "parseback" serves both as a faux shortening of "parse backwards" and a reference to "logback", for no particular reason. Parseback is a Scala implementation of parsing with derivatives (Might, Darais, Spiewak; 2011) taking into account the significant refinements of described by Adams, Hollenbeck and Might. It is designed to be an idiomatic, convenient and safe parser combinator library for formal general context-free grammars with production-viable performance.

Toody - A two-dimensional parser combinator library.

  •    Haskell

Toody is a comonadic parser combinator library for parsing two-dimensional data, such as ASCII art diagrams and 2D programming languages. Whereas most parsing libraries are concerned with one-dimensional streams, Toody works on 2D grids of cells, extracting data based on spatial relationships. It is presented primarily as a proof of concept, and has not been designed for efficiency.

leftry - Leftry - A left-recursion enabled recursive-descent parser combinator library for Lua.

  •    Lua

This library is for creating and composing parsers. This creates a parser B that can parse the string "111122222".

FootlessParser - A simple parser combinator written in Swift

  •    Swift

FootlessParser is a simple and pretty naive implementation of a parser combinator in Swift. It enables infinite lookahead, non-ambiguous parsing with error reporting. There is a series of blog posts about the development and documentation from the source code.

typescript-parser-combinators - Turns out writing recursive descent parsers by hand is annoying so I wrote some combinators

  •    TypeScript

Some basic parser combinators. Not as pretty as in a language that supports operator overloading but still pretty good. Looking at the example grammar and parsing some s-expressions with Grammar.parse is a pretty good way to get a handle on it. The example grammar demonstrates pretty much all the combinators and how to handle recursion with Parser.delay. Everything is documented below. Just plop combinators.ts in some convenient location and reference it with ///<reference path=...>. The entry point into the library is the Parser class which serves as the top of the hierarchy for the parsers and provides two entry points for creating the base parsers. The first entry point is Parser.m (m is for match) and the second one is Parser.delay. Parser.m takes a predicate function that tests a "character" in the input stream and Parser.delay takes a function that will generate a parser on demand at an appropriate point in the parsing process.

combine - A parser combinator library for Elixir projects

  •    Elixir

A parser combinator library for Elixir projects. Documentation is located here.

parsec.el - A parser combinator library for Emacs Lisp, similar to Haskell's Parsec library.

  •    Emacs

A parser combinator library for Emacs Lisp similar to Haskell’s Parsec library. So I decided to make a new library on top of it. This library, however, contains most of the parser combinators in Text.Parsec.Combinator, which should be enough in most use cases. Of course more combinators can be added if necessary! Most of the parser combinators have the same behavior as their Haskell counterparts. parsec.el also comes with a simple error handling mechanism so that it can display an error message showing how the parser fails.

feel-scala - FEEL parser and interpreter written in Scala

  •    Scala

A community extension for Camunda BPM which replaces the built-in FEEL engine of the Camunda DMN engine. FEEL (Friendly Enough Expression Language) is a part of the DMN specification of the OMG. It is designed to write expressions for decision tables and literal expressions in a simple way what can easily understand by business professionals and developers.

jasentaa - A parser combinator library for Clojure and ClojureScript

  •    Clojure

A parser-combinator library for Clojure and ClojureScript. You will need Leiningen 2.8.1 or above installed.

combine-language - A crate which defines parsers for common programming language constructs using https://github

  •    Rust

This a crate providing an easy way of constructing parsers which can easily parse various programming languages. It has much of the same API as Text.Parsec.Token but are otherwise a bit different to fit in to the ownership model of rust. The crate is an extension of the combine crate.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.