Zafu/Text/Parse/Types

`Zafu/Text/Parse/Types`

source code:

src/Zafu/Text/Parse/Types.bosatsu

public dependencies: Zafu/Collection/NonEmptyList, Zafu/Control/Result, Zafu/Text/Parse/Error

Index

Types: Parser, Parser0
Values: any_char, as, backtrack, backtrack0, between, between0, caret, chain_left1, chain_right1, char, char_in, char_where, collect, defer, defer0, end, fail, fail_with, filter, flat_map, flat_map0, ignore_case_char, ignore_case_string, index, keep_left, keep_left0, keep_right, keep_right0, label, label0, map, map0, map_filter, matched, not, not_then, one_of, one_of0, optional, or_else, parse, parse_offset, parse_prefix, peek, product, product0, product01, product10, pure0, rep, rep0, rep0_max, rep_exactly, rep_min, rep_min_max, rep_sep, rep_sep0, rep_until, rep_until0, soft_product0, soft_product01, soft_product10, start, string, string0, surrounded_by, surrounded_by0, void, with_context, with_context0, with_string

Types

`Parser[a]`

type Parser[a: +*]

`Parser0[a]`

type Parser0[a: +*]

Values

`any_char`

references: Char, Parser

any_char: Parser[Char]

`as`

references: Parser0

def as[a, b](parser: Parser0[a], value: b) -> Parser0[b]

`backtrack`

references: Parser

def backtrack[a](parser: Parser[a]) -> Parser[a]

`backtrack0`

references: Parser0

def backtrack0[a](parser: Parser0[a]) -> Parser0[a]

`between`

references: Parser, Parser0

def between[a, b, c](open: Parser0[a], inner: Parser[b], close: Parser0[c]) -> Parser[b]

`between0`

references: Parser0

def between0[a, b, c](open: Parser0[a], inner: Parser0[b], close: Parser0[c]) -> Parser0[b]

`caret`

references: Parser0, Zafu/Text/Parse/Error::Caret

caret: Parser0[Zafu/Text/Parse/Error::Caret]

`chain_left1`

references: Parser

def chain_left1[a](term: Parser[a], op: Parser[(a, a) -> a]) -> Parser[a]

`chain_right1`

references: Parser

def chain_right1[a](term: Parser[a], op: Parser[(a, a) -> a]) -> Parser[a]

`char`

references: Char, Parser, Unit

def char(ch: Char) -> Parser[()]

`char_in`

references: Char, List, Parser

def char_in(chars: List[Char]) -> Parser[Char]

`char_where`

references: Bool, Char, Parser, String

def char_where(pred: Char -> Bool, label_text: String) -> Parser[Char]

`collect`

references: Option, Parser0, String

def collect[a, b](parser: Parser0[a], fn: a -> Option[b], label_text: String) -> Parser0[b]

`defer`

references: Parser, Unit

def defer[a](mk: () -> Parser[a]) -> Parser[a]

`defer0`

references: Parser0, Unit

def defer0[a](mk: () -> Parser0[a]) -> Parser0[a]

`end`

references: Parser, Unit

end: Parser[()]

`fail`

references: Parser

fail: forall a: *. Parser[a]

`fail_with`

references: Parser, String

def fail_with[a](message: String) -> Parser[a]

`filter`

references: Bool, Parser0, String

def filter[a](parser: Parser0[a], pred: a -> Bool, label_text: String) -> Parser0[a]

`flat_map`

references: Parser

def flat_map[a, b](parser: Parser[a], fn: a -> Parser[b]) -> Parser[b]

`flat_map0`

references: Parser0

def flat_map0[a, b](parser: Parser0[a], fn: a -> Parser0[b]) -> Parser0[b]

`ignore_case_char`

references: Char, Parser, Unit

def ignore_case_char(ch: Char) -> Parser[()]

`ignore_case_string`

references: Parser, String, Unit

def ignore_case_string(value: String) -> Parser[()]

`index`

references: Int, Parser0

index: Parser0[Int]

`keep_left`

references: Parser, Parser0

def keep_left[a, b](left: Parser[a], right: Parser0[b]) -> Parser[a]

`keep_left0`

references: Parser0

def keep_left0[a, b](left: Parser0[a], right: Parser0[b]) -> Parser0[a]

`keep_right`

references: Parser, Parser0

def keep_right[a, b](left: Parser0[a], right: Parser[b]) -> Parser[b]

`keep_right0`

references: Parser0

def keep_right0[a, b](left: Parser0[a], right: Parser0[b]) -> Parser0[b]

`label`

references: Parser, String

def label[a](parser: Parser[a], expected_label: String) -> Parser[a]

`label0`

references: Parser0, String

def label0[a](parser: Parser0[a], expected_label: String) -> Parser0[a]

`map`

references: Parser

def map[a, b](parser: Parser[a], fn: a -> b) -> Parser[b]

`map0`

references: Parser0

def map0[a, b](parser: Parser0[a], fn: a -> b) -> Parser0[b]

`map_filter`

references: Option, Parser0

def map_filter[a, b](parser: Parser0[a], fn: a -> Option[b]) -> Parser0[b]

`matched`

references: Parser0, String

def matched[a](parser: Parser0[a]) -> Parser0[String]

`not`

references: Parser0, Unit

def not[a](parser: Parser0[a]) -> Parser0[()]

`not_then`

references: Parser, Parser0

def not_then[a, b](forbidden: Parser0[a], then_parse: Parser[b]) -> Parser[b]

`one_of`

references: List, Parser

def one_of[a](choices: List[Parser[a]]) -> Parser[a]

`one_of0`

references: List, Parser0

def one_of0[a](choices: List[Parser0[a]]) -> Parser0[a]

`optional`

references: Option, Parser, Parser0

def optional[a](parser: Parser[a]) -> Parser0[Option[a]]

`or_else`

references: Parser0

def or_else[a](left: Parser0[a], right: Parser0[a]) -> Parser0[a]

`parse`

references: Parser, String, Zafu/Control/Result::Result, Zafu/Text/Parse/Error::Error

def parse[a
](parser: Parser[a], text: String) -> Zafu/Control/Result::Result[Zafu/Text/Parse/Error::Error, a]

`parse_offset`

references: Int, Parser0, String, Tuple2, Zafu/Control/Result::Result, Zafu/Text/Parse/Error::Error

def parse_offset[a
](parser: Parser0[a], text: String) -> Zafu/Control/Result::Result[Zafu/Text/Parse/Error::Error, (Int, a)]

`parse_prefix`

references: Parser0, String, Tuple2, Zafu/Control/Result::Result, Zafu/Text/Parse/Error::Error

def parse_prefix[a
](parser: Parser0[a], text: String) -> Zafu/Control/Result::Result[Zafu/Text/Parse/Error::Error, (String, a)]

`peek`

references: Parser0, Unit

def peek[a](parser: Parser0[a]) -> Parser0[()]

`product`

references: Parser, Tuple2

def product[a, b](left: Parser[a], right: Parser[b]) -> Parser[(a, b)]

`product0`

references: Parser0, Tuple2

def product0[a, b](left: Parser0[a], right: Parser0[b]) -> Parser0[(a, b)]

`product01`

references: Parser, Parser0, Tuple2

def product01[a, b](left: Parser0[a], right: Parser[b]) -> Parser[(a, b)]

`product10`

references: Parser, Parser0, Tuple2

def product10[a, b](left: Parser[a], right: Parser0[b]) -> Parser[(a, b)]

`pure0`

references: Parser0

def pure0[a](value: a) -> Parser0[a]

`rep`

references: Parser, Zafu/Collection/NonEmptyList::NonEmptyList

def rep[a](parser: Parser[a]) -> Parser[Zafu/Collection/NonEmptyList::NonEmptyList[a]]

`rep0`

references: List, Parser, Parser0

def rep0[a](parser: Parser[a]) -> Parser0[List[a]]

`rep0_max`

references: Int, List, Parser, Parser0

def rep0_max[a](parser: Parser[a], max_items: Int) -> Parser0[List[a]]

`rep_exactly`

references: Int, Parser, Zafu/Collection/NonEmptyList::NonEmptyList

def rep_exactly[a
](parser: Parser[a], times: Int) -> Parser[Zafu/Collection/NonEmptyList::NonEmptyList[a]]

`rep_min`

references: Int, Parser, Zafu/Collection/NonEmptyList::NonEmptyList

def rep_min[a
](parser: Parser[a], min_items: Int) -> Parser[Zafu/Collection/NonEmptyList::NonEmptyList[a]]

`rep_min_max`

references: Int, Parser, Zafu/Collection/NonEmptyList::NonEmptyList

def rep_min_max[a
](parser: Parser[a], min_items: Int, max_items: Int) -> Parser[Zafu/Collection/NonEmptyList::NonEmptyList[a]]

`rep_sep`

references: Parser, Parser0, Zafu/Collection/NonEmptyList::NonEmptyList

def rep_sep[a,
    b](parser: Parser[a], sep: Parser0[b]) -> Parser[Zafu/Collection/NonEmptyList::NonEmptyList[a]]

`rep_sep0`

references: List, Parser, Parser0

def rep_sep0[a, b](parser: Parser[a], sep: Parser0[b]) -> Parser0[List[a]]

`rep_until`

references: List, Parser, Parser0

def rep_until[a, b](parser: Parser[a], end_parser: Parser0[b]) -> Parser[List[a]]

`rep_until0`

references: List, Parser, Parser0

def rep_until0[a, b](parser: Parser[a], end_parser: Parser0[b]) -> Parser0[List[a]]

`soft_product0`

references: Parser0, Tuple2

def soft_product0[a, b](left: Parser0[a], right: Parser0[b]) -> Parser0[(a, b)]

`soft_product01`

references: Parser, Parser0, Tuple2

def soft_product01[a, b](left: Parser0[a], right: Parser[b]) -> Parser[(a, b)]

`soft_product10`

references: Parser, Parser0, Tuple2

def soft_product10[a, b](left: Parser[a], right: Parser0[b]) -> Parser[(a, b)]

`start`

references: Parser0, Unit

start: Parser0[()]

`string`

references: Parser, String, Unit

def string(value: String) -> Parser[()]

`string0`

references: Parser0, String, Unit

def string0(value: String) -> Parser0[()]

`surrounded_by`

references: Parser, Parser0

def surrounded_by[a, b](inner: Parser[a], border: Parser0[b]) -> Parser[a]

`surrounded_by0`

references: Parser0

def surrounded_by0[a, b](inner: Parser0[a], border: Parser0[b]) -> Parser0[a]

`void`

references: Parser0, Unit

def void[a](parser: Parser0[a]) -> Parser0[()]

`with_context`

references: Parser, String

def with_context[a](parser: Parser[a], ctx: String) -> Parser[a]

`with_context0`

references: Parser0, String

def with_context0[a](parser: Parser0[a], ctx: String) -> Parser0[a]

`with_string`

references: Parser0, String, Tuple2

def with_string[a](parser: Parser0[a]) -> Parser0[(a, String)]