Convenience shortcut for the identifier type. Currently an alias for Text (creating Idents is thus quite easy with -XOverloadedStrings or similar tools.

(Using Ident instead of Text may help preserve compatibility with future versions.)

Convert Ident to String.

Convert String to Ident.

Herbrandt universum, consisting of atoms and n-ary structures.

Serialize a Herb structure as Text. The output can be parsed by parseHerb.

Shortcut for directly producing a serializable string from the data.

Equivalent to formatHerb . toHerb.

Should this character be escaped in quoted identifiers?

Can the character be used in unquoted identifiers?

Helper for escaping the atoms for Herb.

>>> escAtom "hello"
"hello"
>>> escAtom "hello!"
"hello!"
>>> escAtom "hello world"
"'hello world'"
>>> escAtom "''\\''"
"'\\'\\'\\\\\\'\\''"

Newtype wrapper for deriving simple atom-only instances for ToHerb and FromHerb from existing Show and Read (respectively) for serialization.

>>> toHerb $ ShowAtom [LT .. GT]
Atom "[LT,EQ,GT]"
>>> getShowAtom <$> fromHerb (Atom "[LT,EQ,GT]") :: Either String [Ordering]
Right [LT,EQ,GT]
>>> deriving via ShowAtom Integer instance ToHerb Integer
>>> toHerb (5::Integer)
Atom "5"

Newtype wrapper for parsing out "plain Herb", without actually converting it to another datatype via FromHerb.

>>> getPlainHerb <$> decodeHerb "foo(bar,qux)"
Right (Struct "foo" [Atom "bar",Atom "qux"])

Class of everything that can be converted to Herb. Can be derived from Generic.

Class of single-parameter constructors that can be converted to Herb. Can be derived from Generic1.

Parser for Herb-like objects of type h into a. Used in FromHerb.

Class of everything that can be parsed from Herb structure. If available, the method defaults from Generic instance for a. The simplest way to use the class is via fromHerb.

Class of single-parameter constructors that can be parsed from Herb. Can be derived from Generic1.

Simple front-end for FromHerb's parseHerb.

Return the current parser input as processed by a given function.

Return the current parser input (identical to gets id).

Set the current parser input.

Change the current parser using a function.

Run a parser with temporarily changed input specified by l.

Run a parser with temporarily changed input, created from the current input using the first parameter.

Parse out an Atom where the identifier satisfies a predicate.

Parse out an Atom with an exact identifier.

Parse out an Atom if the given function converts the identifier to Just x, and return the x.

Convert a to an Atom using its Show instance.

>>> atomShow (123::Int)
Atom "123"

Parse an Atom to a using its Read instance. Produces a parser failure if the atom's identifier can not be read.

atomRead :: Parser Herb Int

Parse out a structure identified by an exact name. The second argument is a parser for the structure arguments that works on the argument list; individual arguments can be obtained via popArg and related functions.

exactStruct "pair" $ (,) <$> popArg' <*> popArg' <* endOfArgs
  :: (FromHerb a1, FromHerb a2) => Parser Herb (a1, a2)

Run a parser on the next argument, popping the argument from the argument list.

Parse the next argument to type a (removing it from the current argument list), pass it through a given function to obtain b, and return it.

Like popArg but without the conversion; equivalent to popArg id.

Succeed if all arguments have been already removed by parseArg, popArg or similar.

Shortcut for parsing out exactly one argument of a structure, failing if there are more.

parseMaybe :: FromHerb a => Parser Herb (Maybe a)
parseMaybe = Nothing <$ exactAtom "Nothing" <|> exactStruct "Just" (singleArg Just)