Data.Sparse

Lightweight parsing library based on partial functions.

Sparse

data SparseT a b

Instances

Monad (SparseT a)

Functor (SparseT a)

MonadPlus (SparseT a)

Applicative (SparseT a)

Alternative (SparseT a)

IsString (SparseT String String)

Monoid (SparseT a b)

Semigroup (SparseT a b)

type Sparse = SparseT String

asSparse :: Sparse a -> Sparse a

Running

runSparseT :: SparseT a b -> a -> Maybe b

runSparseT' :: SparseT a b -> a -> Maybe (a, b)

runSparse :: Sparse a -> String -> Maybe a

runSparse' :: Sparse a -> String -> Maybe (String, a)

Primitives

headP :: (b -> Bool) -> SparseT [b] b

Consumes one input element.

Fails if the predicate fails, or if there is no more input.

splitP :: ([a] -> Int) -> SparseT [a] [a]

Consume one or more input elements.

The given function receives the entire remaining input, and must return the number of consumed elements.

Fails if the predicate return 0 or less, or if there is no more input.

Basic parsers

char :: Char -> Sparse Char

charIs :: (Char -> Bool) -> Sparse Char

string :: String -> Sparse String

stringIs :: Int -> (String -> Bool) -> Sparse String

Combinators

optionally :: (Monad f, Alternative f) => a -> f a -> f a

optionallyMaybe :: (Monad f, Alternative f) => f a -> f (Maybe a)

optional :: (Monad f, Alternative f) => f a -> f ()

between :: Monad m => m a -> m a1 -> m b -> m b

skipMany1 :: (Monad m, Alternative m) => m a -> m ()

skipMany :: (Monad f, Alternative f) => f a -> f ()

many1 :: (Monad m, Alternative m) => m a -> m [a]

sepBy :: (Monad f, Alternative f) => f a1 -> f a -> f [a1]

sepBy1 :: (Monad m, Alternative m) => m a1 -> m a -> m [a1]

sepEndBy1 :: (Monad m, Alternative m) => m a1 -> m a -> m [a1]

sepEndBy :: (Monad m, Alternative m) => m a1 -> m a -> m [a1]

endBy1 :: (Monad m, Alternative m) => m a -> m a1 -> m [a]

endBy :: (Monad f, Alternative f) => f a -> f a1 -> f [a]

count :: Monad m => Int -> m a -> m [a]