app "roctorrent" packages { pf: "https://github.com/roc-lang/basic-cli/releases/download/0.5.0/Cufzl36_SnJ4QbOoEmiJ5dIpUxBvdB3NEySvuH82Wio.tar.br" } imports [pf.Stdout] provides [main] to pf dbgStr: List U8 -> Str dbgStr = \s -> Result.withDefault (Str.fromUtf8 s) "!!!Invalid UTF-8!!!" # Decodes an exact string, errors if there is remaining unused data bDecodeStr: List U8 -> Result (List U8) [Malformatted Str] bDecodeStr = \i -> when bDecodeStrAndRem i is Ok {res, others} -> if List.len others == 0 then Ok res else Err (Malformatted "bDecodeStr: trailing characters in string \(dbgStr others)") Err s -> Err s # Decodes a string and returns the remainder of the input as well if there was any bDecodeStrAndRem: List U8 -> Result {res: List U8, others: List U8} [Malformatted Str] bDecodeStrAndRem = \i -> when (List.splitFirst i ':') is Ok {before, after} -> when (Str.fromUtf8 before) is Ok ls -> when (Str.toNat ls) is Ok l -> if List.len after >= l then r2 = (List.split after l) Ok {res: r2.before, others: r2.others} else Err (Malformatted "bDecodeStrAndRem: len exceeds remaining data") Err _err -> Err (Malformatted "bDecodeStrAndRem: failed to parse number \(dbgStr i)") Err _err -> Err (Malformatted "bDecodeStrAndRem: failed to parse utf8") Err _err -> Err (Malformatted "bDecodeStrAndRem: no ':' found \(dbgStr i)") expect res = bDecodeStr (Str.toUtf8 "3:foo") res == Ok (Str.toUtf8 "foo") expect errCases = [ {case: "", err: "bDecodeStrAndRem: no ':' found "}, #{case: "foo", err: "bDecodeStrAndRem: no ':' found"}, #{case: "1:foo", err: "bDecodeStr: trailing characters"}, #{case: "4:foo",err: "bDecodeStrAndRem: len exceeds remaining data"}, #{case: ":", err: "bDecodeStrAndRem: failed to parse utf8"}, #{case: "foo:", err: "bDecodeStrAndRem: failed to parse number"}, #{case: "1:",err: "bDecodeStrAndRem: len exceeds remaining data"}, #{case: "::",err: "bDecodeStrAndRem: failed to parse utf8"}, ] List.all errCases \t -> res = bDecodeStr (Str.toUtf8 t.case) res == Err (Malformatted t.err) # Decodes an exact number, exta input causes an error bDecodeNum: List U8 -> Result I64 [Malformatted Str] bDecodeNum = \i -> when bDecodeNumAndRem i is Ok {num, rem} -> if (List.len rem) == 0 then Ok num else Err (Malformatted "remaining characters after number") Err e -> Err e # Decodes a number and returns the number and any unused input bDecodeNumAndRem: List U8 -> Result {num: I64, rem: (List U8)} [Malformatted Str] bDecodeNumAndRem = \i -> when (List.first i) is Ok f -> if f == 'i' then when List.findFirstIndex i (\j -> j == 'e') is Ok ix -> {before, others} = List.split i (ix+1) numl = List.sublist before {start: 1, len: ix-1} when (Str.fromUtf8 numl) is Ok nums -> when (Str.toI64 nums) is Ok num -> Ok {num: num, rem: others} Err _e -> Err (Malformatted "failed to parse number from \(nums)") Err _e -> Err (Malformatted "failed to parse utf8") Err _e -> Err (Malformatted "failed to find number end char 'e'") else Err (Malformatted "number didn't start with 'i'") Err _e -> Err (Malformatted "number string was empty") expect res = bDecodeNum (Str.toUtf8 "i32e") res == Ok 32i64 expect errCases = [ {case: "", msg: "number string was empty"}, {case: "foo", msg: "number didn't start with 'i'"}, {case: "i32", msg: "failed to find number end char 'e'"}, {case: "32e", msg: "number didn't start with 'i'"}, {case: "ifooe", msg: "failed to parse number from foo"}, {case: "ie", msg: "failed to parse number from "}, {case: "i", msg: "failed to find number end char 'e'"}, {case: "e", msg: "number didn't start with 'i'"}, {case: "i522222222222222222343423432434322e", msg: "failed to parse number from 522222222222222222343423432434322"}, ] List.all errCases \{case, msg} -> res = bDecodeNum (Str.toUtf8 case) res == Err (Malformatted msg) # Tags for storing heterogenous collections BVal: [ BStr (List U8), BNum I64, BList (List BVal), BDict (Dict (List U8) BVal) ] # Detects and decodes any kind of element. bDecodeValueAndRem: (List U8) -> Result {res: BVal, others: (List U8)} [Malformatted, End (List U8)] bDecodeValueAndRem = \i -> when (List.first i) is Ok first -> when first is '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7'|'8'|'9' -> when bDecodeStrAndRem i is Ok {res, others} -> Ok {res: BStr res, others: others} Err _err -> Err Malformatted 'i' -> when bDecodeNumAndRem i is Ok {num, rem} -> Ok {res: BNum num, others: rem} Err _err -> Err Malformatted 'l' -> when bDecodeListAndRem i is Ok {res, others} -> Ok {res: BList res, others: others} Err _err -> Err Malformatted 'd' -> when bDecodeDictAndRem i is Ok {res, others} -> Ok {res: BDict res, others: others} Err _err -> Err Malformatted 'e' -> {before, others} = List.split i 1 Err (End others) _ -> Err Malformatted Err _err -> Err Malformatted expect res = bDecodeValueAndRem (Str.toUtf8 "i64efoo") res == Ok {res: BNum 64, others: (Str.toUtf8 "foo")} expect res = bDecodeValueAndRem (Str.toUtf8 "3:foo3:foo") res == Ok {res: BStr (Str.toUtf8 "foo"), others: (Str.toUtf8 "3:foo")} expect res = bDecodeValueAndRem (Str.toUtf8 "efoo") res == Err (End (Str.toUtf8 "foo")) expect res = bDecodeValueAndRem (Str.toUtf8 "z") res == Err Malformatted # Decodes a list. List elements can be any bDecodeList: (List U8) -> Result (List BVal) [Malformatted] bDecodeList = \i -> when bDecodeListAndRem i is Ok {res, others} -> if (List.len others) == 0 then Ok res else Err Malformatted Err e -> Err e bDecodeListAndRem: (List U8) -> Result {res: (List BVal), others: (List U8)} [Malformatted] bDecodeListAndRem = \i -> when List.first i is Ok f -> if f == 'l' then {before, others} = List.split i 1 bDecodeListAndRemInternal [] others else Err Malformatted Err _e -> Err Malformatted bDecodeListAndRemInternal: List BVal, List U8 -> Result {res: (List BVal), others: (List U8)} [Malformatted] bDecodeListAndRemInternal = \l, i -> when bDecodeValueAndRem i is Ok {res, others} -> l2 = List.append l res bDecodeListAndRemInternal l2 others Err e -> when e is End others -> Ok {res: l, others: others} Malformatted -> Err Malformatted expect res = bDecodeList (Str.toUtf8 "le") res == Ok [] expect res = bDecodeList (Str.toUtf8 "li123e3:fooe") res == Ok [BNum 123i64, BStr (Str.toUtf8 "foo")] expect res = bDecodeList (Str.toUtf8 "li123e3:fooe123") res == Err Malformatted expect res = bDecodeList (Str.toUtf8 "lli123eee") res == Ok [BList [BNum 123i64]] bDecodeDict: (List U8) -> Result (Dict (List U8) BVal) [Malformatted Str] bDecodeDict = \i -> when bDecodeDictAndRem i is Ok {res, others} -> if (List.len others) == 0 then Ok res else Err (Malformatted "bDecodeDict: trailing characters") Err e -> Err e bDecodeDictAndRem: (List U8) -> Result {res: (Dict (List U8) BVal), others: (List U8)} [Malformatted Str] bDecodeDictAndRem = \i -> when List.first i is Ok f -> if f == 'd' then {before, others} = List.split i 1 bDecodeDictAndRemInternal (Dict.empty{}) others else Err (Malformatted "first character not 'd'") Err _e -> Err (Malformatted "empty input") bDecodeDictAndRemInternal: (Dict (List U8) BVal), (List U8) -> Result {res: (Dict (List U8) BVal), others: (List U8)} [Malformatted Str] bDecodeDictAndRemInternal = \d, i -> when bDecodeValueAndRem i is Ok r1 -> when r1.res is BStr s -> key = s when bDecodeValueAndRem r1.others is Ok r2 -> val = r2.res d2 = Dict.insert d key val bDecodeDictAndRemInternal d2 r2.others Err e -> when e is End others -> Err (Malformatted "key with no value") Malformatted -> Err (Malformatted "bDecodeDictAndRemInternal: error decoding value") _ -> Err (Malformatted "bDecodeDictAndRemInternal: wrong key type") Err Malformatted -> Err (Malformatted "bDecodeDictAndRemInternal: error decoding key") Err (End others) -> Ok {res: d, others: others} expect expected = Dict.fromList [ ((Str.toUtf8 "foo"), (BStr (Str.toUtf8 "bar"))), ] res = bDecodeDict (Str.toUtf8 "d3:foo3:bare") res == Ok expected expect nest = Dict.fromList [ ((Str.toUtf8 "foo"), (BStr (Str.toUtf8 "bar"))), ] expected = Dict.fromList [ ((Str.toUtf8 "top"), (BDict nest)), ] res = bDecodeDict (Str.toUtf8 "d3:topd3:foo3:baree") res == Ok expected main = Stdout.line "Hello, World"