Home

package

  • CSV
    • is_eq
    • parse_str
    • parse_csv
    • parse_csv_record
    • record
    • field
    • string
    • u64
    • f64
    • parse_str_to_csv
    • parse_str_to_csv_record
    • file
    • CSVRecord
    • CSVField
  • HTTP
    • request
    • response
    • Method
    • HttpVersion
    • Header
    • Request
    • Response
  • Markdown
    • to_inspect
    • is_eq
    • to_debug_str
    • inline_to_debug_str
    • all
    • inlines
    • heading
    • link
    • image
    • code
    • Level
      • to_inspect
      • to_str
      • is_eq
    • ListKind
      • to_inspect
      • to_str
      • is_eq
    • TaskState
      • to_inspect
      • to_str
      • is_eq
    • Alignment
      • to_inspect
      • to_str
      • is_eq
    • LinkTarget
    • Inline
      • to_inspect
      • is_eq
  • Parser
    • build_primitive_parser
    • parse_partial
    • parse
    • fail
    • const
    • alt
    • apply
    • one_of
    • map
    • map2
    • map3
    • flatten
    • lazy
    • maybe
    • many
    • one_or_more
    • between
    • sep_by1
    • sep_by
    • ignore
    • keep
    • skip
    • chomp_until
    • chomp_while
    • ParseResult
  • String
    • parse_str
    • parse_str_partial
    • parse_utf8
    • parse_utf8_partial
    • codeunit_satisfies
    • codeunit
    • utf8
    • string
    • any_codeunit
    • any_thing
    • any_string
    • digit
    • digits
    • one_of
    • str_from_utf8
    • str_from_ascii
    • Utf8
  • Xml
    • is_eq
    • xml_parser
    • Attribute
    • TextEncoding
    • Declaration
    • Version
      • is_eq
      • new
    • Node
      • is_eq
  • Yaml
    • is_eq
    • parse_str
    • to_inspect
    • Error
  • CSV.is_eq : _
  • CSV.parse_str : Parser(CSVRecord, a), Str -> Try(List(a), [ParsingFailure(Str), SyntaxError(Str), ParsingIncomplete(CSVRecord)])
  • CSV.parse_csv : Parser(CSVRecord, a), CSV -> Try(List(a), [ParsingFailure(Str), ParsingIncomplete(CSVRecord)])
  • CSV.parse_csv_record : Parser(CSVRecord, a), CSVRecord -> Try(a, [ParsingFailure(Str), ParsingIncomplete(CSVRecord)])
  • CSV.record : a -> Parser(CSVRecord, a)
  • CSV.field : Parser(Utf8, a) -> Parser(CSVRecord, a)
  • CSV.string : Parser(CSVField, Str)
  • CSV.u64 : Parser(CSVField, U64)
  • CSV.f64 : Parser(CSVField, F64)
  • CSV.parse_str_to_csv : Str -> Try(CSV, [ParsingFailure(Str), ParsingIncomplete(Utf8)])
  • CSV.parse_str_to_csv_record : Str -> Try(CSVRecord, [ParsingFailure(Str), ParsingIncomplete(Utf8)])
  • CSV.file : Parser(Utf8, CSV)
  • CSV.CSVRecord : List(CSVField)
  • CSV.CSVField : Utf8
  • HTTP.request : Parser(Utf8, Request)
  • HTTP.response : Parser(Utf8, Response)
  • HTTP.Method : [Options, Get, Post, Put, Delete, Head, Trace, Connect, Patch]
  • HTTP.HttpVersion : { major : U8, minor : U8 }
  • HTTP.Header : [Header(Str, Str)]
  • HTTP.Request : { method : Method, uri : Str, http_version : HttpVersion, headers : List(Header), body : List(U8) }
  • HTTP.Response : { http_version : HttpVersion, status_code : U16, status : Str, headers : List(Header), body : List(U8) }
  • Markdown.to_inspect : Markdown -> Str
  • Markdown.is_eq : _
  • Markdown.to_debug_str : Markdown -> Str
  • Markdown.inline_to_debug_str : Inline -> Str
  • Markdown.all : Parser(Utf8, List(Markdown))
  • Markdown.inlines : Parser(Utf8, List(Inline))
  • Markdown.heading : Parser(Utf8, Markdown)
  • Markdown.link : Parser(Utf8, Inline)
  • Markdown.image : Parser(Utf8, Inline)
  • Markdown.code : Parser(Utf8, Markdown)
  • Markdown.Level := [One, Two, Three, Four, Five, Six]
  • Markdown.Level.to_inspect : Level -> Str
  • Markdown.Level.to_str : Level -> Str
  • Markdown.Level.is_eq : _
  • Markdown.ListKind := [Unordered, Ordered({ start : U64 })]
  • Markdown.ListKind.to_inspect : ListKind -> Str
  • Markdown.ListKind.to_str : ListKind -> Str
  • Markdown.ListKind.is_eq : _
  • Markdown.TaskState := [NoTask, Unchecked, Checked]
  • Markdown.TaskState.to_inspect : TaskState -> Str
  • Markdown.TaskState.to_str : TaskState -> Str
  • Markdown.TaskState.is_eq : _
  • Markdown.Alignment := [Default, Left, Center, Right]
  • Markdown.Alignment.to_inspect : Alignment -> Str
  • Markdown.Alignment.to_str : Alignment -> Str
  • Markdown.Alignment.is_eq : _
  • Markdown.LinkTarget : { href : Str, title : [Some(Str), None] }
  • Markdown.Inline := [Text(Str), Strong(List(Inline)), Emphasis(List(Inline)), Strikethrough(List(Inline)), InlineCode(Str), Link({ label : List(Inline), target : LinkTarget }), Image({ alt : List(Inline), target : LinkTarget }), HardBreak, HtmlInline(Str)]
  • Markdown.Inline.to_inspect : Inline -> Str
  • Markdown.Inline.is_eq : _
  • Parser.build_primitive_parser : (input -> ParseResult(input, a)) -> Parser(input, a)
  • Parser.parse_partial : Parser(input, a), input -> ParseResult(input, a)
  • Parser.parse : Parser(input, a), input, (input -> Bool) -> Try(a, [ParsingFailure(Str), ParsingIncomplete(input)])
  • Parser.fail : Str -> Parser(_, _)
  • Parser.const : a -> Parser(_, a)
  • Parser.alt : Parser(input, a), Parser(input, a) -> Parser(input, a)
  • Parser.apply : Parser(input, a -> b), Parser(input, a) -> Parser(input, b)
  • Parser.one_of : List(Parser(input, a)) -> Parser(input, a)
  • Parser.map : Parser(input, a), (a -> b) -> Parser(input, b)
  • Parser.map2 : Parser(input, a), Parser(input, b), (a, b -> c) -> Parser(input, c)
  • Parser.map3 : Parser(input, a), Parser(input, b), Parser(input, c), (a, b, c -> d) -> Parser(input, d)
  • Parser.flatten : Parser(input, Try(a, Str)) -> Parser(input, a)
  • Parser.lazy : ({ } -> Parser(input, a)) -> Parser(input, a)
  • Parser.maybe : Parser(input, a) -> Parser(input, Try(a, [Nothing]))
  • Parser.many : Parser(input, a) -> Parser(input, List(a))
  • Parser.one_or_more : Parser(input, a) -> Parser(input, List(a))
  • Parser.between : Parser(input, a), Parser(input, open), Parser(input, close) -> Parser(input, a)
  • Parser.sep_by1 : Parser(input, a), Parser(input, sep) -> Parser(input, List(a))
  • Parser.sep_by : Parser(input, a), Parser(input, sep) -> Parser(input, List(a))
  • Parser.ignore : Parser(input, a) -> Parser(input, { })
  • Parser.keep : Parser(input, a -> b), Parser(input, a) -> Parser(input, b)
  • Parser.skip : Parser(input, a), Parser(input, _) -> Parser(input, a)
  • Parser.chomp_until : a -> Parser(List(a), List(a)) where [a.is_eq : a, a -> Bool]
  • Parser.chomp_while : (a -> Bool) -> Parser(List(a), List(a))
  • Parser.ParseResult : Try({ val : a, input : input }, [ParsingFailure(Str)])
  • String.parse_str : Parser(Utf8, a), Str -> Try(a, [ParsingFailure(Str), ParsingIncomplete(Str)])
  • String.parse_str_partial : Parser(Utf8, a), Str -> Try({ val : a, input : Str }, [ParsingFailure(Str)])
  • String.parse_utf8 : Parser(Utf8, a), Utf8 -> Try(a, [ParsingFailure(Str), ParsingIncomplete(Utf8)])
  • String.parse_utf8_partial : Parser(Utf8, a), Utf8 -> Try({ val : a, input : Utf8 }, [ParsingFailure(Str)])
  • String.codeunit_satisfies : (U8 -> Bool) -> Parser(Utf8, U8)
  • String.codeunit : U8 -> Parser(Utf8, U8)
  • String.utf8 : List(U8) -> Parser(Utf8, List(U8))
  • String.string : Str -> Parser(Utf8, Str)
  • String.any_codeunit : Parser(Utf8, U8)
  • String.any_thing : Parser(Utf8, Utf8)
  • String.any_string : Parser(Utf8, Str)
  • String.digit : Parser(Utf8, U64)
  • String.digits : Parser(Utf8, U64)
  • String.one_of : List(Parser(Utf8, a)) -> Parser(Utf8, a)
  • String.str_from_utf8 : Utf8 -> Str
  • String.str_from_ascii : U8 -> Str
  • String.Utf8 : List(U8)
  • Xml.is_eq : _
  • Xml.xml_parser : Parser(Utf8, Xml)
  • Xml.Attribute : { name : Str, value : Str }
  • Xml.TextEncoding : [Utf8Encoding, OtherEncoding(Str)]
  • Xml.Declaration : { version : Version, encoding : [Given(TextEncoding), Missing] }
  • Xml.Version
  • Xml.Version.is_eq : _
  • Xml.Version.new : U8 -> Version
  • Xml.Node := [Element(Str, List({ name : Str, value : Str }), List(Node)), Text(Str)]
  • Xml.Node.is_eq : _
  • Yaml.is_eq : _
  • Yaml.parse_str : Str -> Try(Yaml, [YamlError(Error)])
  • Yaml.to_inspect : Yaml -> Str
  • Yaml.Error : { line : U64, column : U64, message : Str }

Made by people who like to make nice things.