incremental-parser: Generic parser library capable of providing partial results from partial input.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain]

Warnings:

This package defines yet another parser combinator library. This one is implemented using the concept of Brzozowski derivatives, tweaked and optimized to work with any monoidal input type. Lists, ByteString, and Text are supported out of the box, as well as any other data type for which the monoid-subclasses package defines instances. If the parser result is also a monoid, its chunks can be extracted incrementally, before the complete input is parsed.


[Skip to ReadMe]

Properties

Versions0.1, 0.2, 0.2.1, 0.2.2, 0.2.3, 0.2.3.1, 0.2.3.2, 0.2.3.3, 0.2.3.4, 0.2.4, 0.2.4.1, 0.2.5, 0.2.5.1, 0.2.5.2, 0.2.5.2, 0.2.5.3, 0.2.5.4, 0.3, 0.3.1, 0.3.1.1, 0.3.2
Change logNone available
Dependenciesbase (<5), monoid-subclasses (<0.5) [details]
LicenseLicenseRef-GPL
Copyright(c) 2011-2017 Mario Blazevic
AuthorMario Blazevic
Maintainerblamario@yahoo.com
CategoryParsing
Home pagehttps://github.com/blamario/incremental-parser
Source repositoryhead: git clone https://github.com/blamario/incremental-parser
UploadedFri Nov 3 11:52:36 UTC 2017 by MarioBlazevic

Modules

[Index]

Downloads

Maintainers' corner

For package maintainers and hackage trustees


Readme for incremental-parser-0.2.5.2

[back to package description]

The incremental-parser library is yet another parser combinator library, providing the usual set of Applicative, Alternative, and Monad combinators. Apart from this, it has three twists that make it unique.

Parsing incrementally

First, the parser is incremental. Not only can it be fed its input in chunks, but in proper circumstances it can also provide its output in parsed chunks. For this to be possible the result type must be a Monoid. The complete parsing result is then a concatenation of the partial results.

In order to make the incremental parsing easier, the combinator set is optimized for monoidal results. Apart from the usual combinators many and some, for example, there are concatMany and concatSome operators.

    many :: Parser s r -> Parser s [r]
    concatMany :: (Monoid s, Monoid r) => Parser s r -> Parser s r

Arbitrary monoidal inputs

The second weirdness, this one shared with Picoparsec, is that the the parser is generic in its input stream type, but this type is parameterized in a holistic way. There is no separate token type. Primitive parsers that need to peek into the input require its type to be an instance of a monoid subclass, from the monoid-subclasses package.

In Parsec:

    string :: Stream s m Char => String -> ParsecT s u m String
    char :: Stream s m Char => Char -> ParsecT s u m Char
    anyToken :: (Stream s m t, Show t) => ParsecT s u m t

In Attoparsec:

    string :: ByteString -> Parser ByteString
    word8 :: Word8 -> Parser Word8
    anyWord8 :: Parser Word8

In incremental-parser and Picoparsec:

    string :: (LeftCancellativeMonoid s, MonoidNull s) => s -> Parser s s
    token :: (Eq s, FactorialMonoid s) => s -> Parser s s
    anyToken :: FactorialMonoid s => Parser s s

Two Alternative alternatives

Finally, the library being implemented on the basis of Brzozowski derivatives, it can provide both the symmetric and the left-biased choice, <||> and <<|>. This is the same design choice made by Text.ParserCombinators.ReadP and uu-parsinglib. Parsec and its progeny on the other hand provide only the faster left-biased choice, at some cost to the expressiveness of the combinator language. The standard <|> operator from the Alternative class acts as one or the other of the above, depending on whether the first type parameter of Parser is Symmetric or LeftBiasedLocal.