removed DecodeError

Author: roboteng

crates/compiler/builtins/roc/Decode.roc

@@ -1,5 +1,4 @@
 module [
-    DecodeError,
     DecodeResult,
     Decoder,
     Decoding,
@@ -49,9 +48,6 @@ import Num exposing [
 ]
 import Bool exposing [Bool]
 
-## Error types when decoding a `List U8` of utf-8 bytes using a [Decoder]
-DecodeError : [TooShort]
-
 ## Return type of a [Decoder].
 ##
 ## This can be useful when creating a [custom](#custom) decoder or when
@@ -65,43 +61,43 @@ DecodeError : [TooShort]
 ##
 ##     actual.result == expected
 ## ```
-DecodeResult val : { result : Result val DecodeError, rest : List U8 }
+DecodeResult val err : { result : Result val err, rest : List U8 }
 
 ## Decodes a `List U8` of utf-8 bytes where `val` is the type of the decoded
 ## value, and `fmt` is a [Decoder] which implements the [DecoderFormatting]
 ## ability
-Decoder val fmt := List U8, fmt -> DecodeResult val where fmt implements DecoderFormatting
+Decoder val fmt err := List U8, fmt -> DecodeResult val err where fmt implements DecoderFormatting
 
 ## Definition of the [Decoding] ability
 Decoding implements
-    decoder : Decoder val fmt where val implements Decoding, fmt implements DecoderFormatting
+    decoder : Decoder val fmt err where val implements Decoding, fmt implements DecoderFormatting
 
 ## Definition of the [DecoderFormatting] ability
 DecoderFormatting implements
-    u8 : Decoder U8 fmt where fmt implements DecoderFormatting
-    u16 : Decoder U16 fmt where fmt implements DecoderFormatting
-    u32 : Decoder U32 fmt where fmt implements DecoderFormatting
-    u64 : Decoder U64 fmt where fmt implements DecoderFormatting
-    u128 : Decoder U128 fmt where fmt implements DecoderFormatting
-    i8 : Decoder I8 fmt where fmt implements DecoderFormatting
-    i16 : Decoder I16 fmt where fmt implements DecoderFormatting
-    i32 : Decoder I32 fmt where fmt implements DecoderFormatting
-    i64 : Decoder I64 fmt where fmt implements DecoderFormatting
-    i128 : Decoder I128 fmt where fmt implements DecoderFormatting
-    f32 : Decoder F32 fmt where fmt implements DecoderFormatting
-    f64 : Decoder F64 fmt where fmt implements DecoderFormatting
-    dec : Decoder Dec fmt where fmt implements DecoderFormatting
-    bool : Decoder Bool fmt where fmt implements DecoderFormatting
-    string : Decoder Str fmt where fmt implements DecoderFormatting
-    list : Decoder elem fmt -> Decoder (List elem) fmt where fmt implements DecoderFormatting
+    u8 : Decoder U8 fmt err where fmt implements DecoderFormatting
+    u16 : Decoder U16 fmt err where fmt implements DecoderFormatting
+    u32 : Decoder U32 fmt err where fmt implements DecoderFormatting
+    u64 : Decoder U64 fmt err where fmt implements DecoderFormatting
+    u128 : Decoder U128 fmt err where fmt implements DecoderFormatting
+    i8 : Decoder I8 fmt err where  fmt implements DecoderFormatting
+    i16 : Decoder I16 fmt err where fmt implements DecoderFormatting
+    i32 : Decoder I32 fmt err where fmt implements DecoderFormatting
+    i64 : Decoder I64 fmt err where fmt implements DecoderFormatting
+    i128 : Decoder I128 fmt err where fmt implements DecoderFormatting
+    f32 : Decoder F32 fmt err where fmt implements DecoderFormatting
+    f64 : Decoder F64 fmt err where fmt implements DecoderFormatting
+    dec : Decoder Dec fmt err where fmt implements DecoderFormatting
+    bool : Decoder Bool fmt err where fmt implements DecoderFormatting
+    string : Decoder Str fmt err where fmt implements DecoderFormatting
+    list : Decoder elem fmt err -> Decoder (List elem) fmt err where fmt implements DecoderFormatting
 
     ## `record state stepField finalizer` decodes a record field-by-field.
     ##
     ## `stepField` returns a decoder for the given field in the record, or
     ## `Skip` if the field is not a part of the decoded record.
     ##
     ## `finalizer` should produce the record value from the decoded `state`.
-    record : state, (state, Str -> [Keep (Decoder state fmt), Skip]), (state, fmt -> Result val DecodeError) -> Decoder val fmt where fmt implements DecoderFormatting
+    record : state, (state, Str -> [Keep (Decoder state fmt err), Skip]), (state, fmt -> Result val err) -> Decoder val fmt err where fmt implements DecoderFormatting
 
     ## `tuple state stepElem finalizer` decodes a tuple element-by-element.
     ##
@@ -110,7 +106,7 @@ DecoderFormatting implements
     ## index passed to `stepElem` is 0-indexed.
     ##
     ## `finalizer` should produce the tuple value from the decoded `state`.
-    tuple : state, (state, U64 -> [Next (Decoder state fmt), TooLong]), (state -> Result val DecodeError) -> Decoder val fmt where fmt implements DecoderFormatting
+    tuple : state, (state, U64 -> [Next (Decoder state fmt err), TooLong]), (state -> Result val err) -> Decoder val fmt err where fmt implements DecoderFormatting
 
 ## Build a custom [Decoder] function. For example the implementation of
 ## `decodeBool` could be defined as follows;
@@ -122,11 +118,11 @@ DecoderFormatting implements
 ##         ['t', 'r', 'u', 'e', ..] -> { result: Ok Bool.true, rest: List.dropFirst bytes 4 }
 ##         _ -> { result: Err TooShort, rest: bytes }
 ## ```
-custom : (List U8, fmt -> DecodeResult val) -> Decoder val fmt where fmt implements DecoderFormatting
+custom : (List U8, fmt -> DecodeResult val err) -> Decoder val fmt err where fmt implements DecoderFormatting
 custom = \decode -> @Decoder decode
 
 ## Decode a `List U8` utf-8 bytes using a specific [Decoder] function
-decodeWith : List U8, Decoder val fmt, fmt -> DecodeResult val where fmt implements DecoderFormatting
+decodeWith : List U8, Decoder val fmt err, fmt -> DecodeResult val err where fmt implements DecoderFormatting
 decodeWith = \bytes, @Decoder decode, fmt -> decode bytes fmt
 
 ## Decode a `List U8` utf-8 bytes and return a [DecodeResult](#DecodeResult)
@@ -138,7 +134,7 @@ decodeWith = \bytes, @Decoder decode, fmt -> decode bytes fmt
 ##
 ##     actual.result == expected
 ## ```
-fromBytesPartial : List U8, fmt -> DecodeResult val where val implements Decoding, fmt implements DecoderFormatting
+fromBytesPartial : List U8, fmt -> DecodeResult val err where val implements Decoding, fmt implements DecoderFormatting
 fromBytesPartial = \bytes, fmt -> decodeWith bytes decoder fmt
 
 ## Decode a `List U8` utf-8 bytes and return a [Result] with no leftover bytes
@@ -152,17 +148,17 @@ fromBytesPartial = \bytes, fmt -> decodeWith bytes decoder fmt
 ##
 ##     actual == expected
 ## ```
-fromBytes : List U8, fmt -> Result val [Leftover (List U8)]DecodeError where val implements Decoding, fmt implements DecoderFormatting
+fromBytes : List U8, fmt -> Result val [Leftover (List U8)] where val implements Decoding, fmt implements DecoderFormatting
 fromBytes = \bytes, fmt ->
     when fromBytesPartial bytes fmt is
         { result, rest } ->
             if List.isEmpty rest then
                 when result is
                     Ok val -> Ok val
-                    Err TooShort -> Err TooShort
+                    Err e -> Err e
             else
                 Err (Leftover rest)
 
 ## Transform the `val` of a [DecodeResult]
-mapResult : DecodeResult a, (a -> b) -> DecodeResult b
+mapResult : DecodeResult a err, (a -> b) -> DecodeResult b err
 mapResult = \{ result, rest }, mapper -> { result: Result.map result mapper, rest }

crates/compiler/builtins/roc/TotallyNotJson.roc

@@ -484,7 +484,7 @@ decodeF32 = Decode.custom \bytes, @Json {} ->
 
 # Test decode of F32
 expect
-    actual : DecodeResult F32
+    actual : DecodeResult F32 [TooShort]
     actual = Str.toUtf8 "12.34e-5" |> Decode.fromBytesPartial json
     numStr = actual.result |> Result.map Num.toStr
 
@@ -503,7 +503,7 @@ decodeF64 = Decode.custom \bytes, @Json {} ->
 
 # Test decode of F64
 expect
-    actual : DecodeResult F64
+    actual : DecodeResult F64 [TooShort]
     actual = Str.toUtf8 "12.34e-5" |> Decode.fromBytesPartial json
     numStr = actual.result |> Result.map Num.toStr
 
@@ -522,7 +522,7 @@ decodeDec = Decode.custom \bytes, @Json {} ->
 
 # Test decode of Dec
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = Str.toUtf8 "12.0034" |> Decode.fromBytesPartial json
 
     actual.result == Ok 12.0034dec
@@ -582,7 +582,7 @@ expect
 
     actual.result == Ok ("The Answer is", 42)
 
-parseExactChar : List U8, U8 -> DecodeResult {}
+parseExactChar : List U8, U8 -> DecodeResult {} [TooShort]
 parseExactChar = \bytes, char ->
     when List.get bytes 0 is
         Ok c ->
@@ -595,19 +595,19 @@ parseExactChar = \bytes, char ->
 
         Err _ -> { result: Err TooShort, rest: bytes }
 
-openBracket : List U8 -> DecodeResult {}
+openBracket : List U8 -> DecodeResult {} [TooShort]
 openBracket = \bytes -> parseExactChar bytes '['
 
-closingBracket : List U8 -> DecodeResult {}
+closingBracket : List U8 -> DecodeResult {} [TooShort]
 closingBracket = \bytes -> parseExactChar bytes ']'
 
-anything : List U8 -> DecodeResult {}
+anything : List U8 -> DecodeResult {} [TooShort]
 anything = \bytes -> { result: Err TooShort, rest: bytes }
 
-comma : List U8 -> DecodeResult {}
+comma : List U8 -> DecodeResult {} [TooShort]
 comma = \bytes -> parseExactChar bytes ','
 
-tryDecode : DecodeResult a, ({ val : a, rest : List U8 } -> DecodeResult b) -> DecodeResult b
+tryDecode : DecodeResult a [TooShort], ({ val : a, rest : List U8 } -> DecodeResult b [TooShort]) -> DecodeResult b [TooShort]
 tryDecode = \{ result, rest }, mapper ->
     when result is
         Ok val -> mapper { val, rest }
@@ -723,96 +723,96 @@ expect
     actual == expected
 
 expect
-    actual : DecodeResult U16
+    actual : DecodeResult U16 [TooShort]
     actual = "+1" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = { result: Err TooShort, rest: ['+', '1'] }
     actual == expected
 
 expect
-    actual : DecodeResult U16
+    actual : DecodeResult U16 [TooShort]
     actual = ".0" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = { result: Err TooShort, rest: ['.', '0'] }
     actual == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "-.1" |> Str.toUtf8 |> Decode.fromBytesPartial json
     actual.result == Err TooShort
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "72" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Ok 72dec
     actual.result == expected
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "-0" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Ok 0dec
     actual.result == expected
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "-7" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Ok -7dec
     actual.result == expected
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "-0\n" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = { result: Ok 0dec, rest: ['\n'] }
     actual == expected
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "123456789000 \n" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = { result: Ok 123456789000dec, rest: [' ', '\n'] }
     actual == expected
 
 expect
-    actual : DecodeResult Dec
+    actual : DecodeResult Dec [TooShort]
     actual = "-12.03" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Ok -12.03
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "-12." |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "01.1" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = ".0" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "1.e1" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "-1.2E" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "0.1e+" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
 
 expect
-    actual : DecodeResult U64
+    actual : DecodeResult U64 [TooShort]
     actual = "-03" |> Str.toUtf8 |> Decode.fromBytesPartial json
     expected = Err TooShort
     actual.result == expected
@@ -1180,7 +1180,7 @@ ArrayClosingState : [
 expect
     input = Str.toUtf8 "[ ]"
 
-    actual : DecodeResult (List U8)
+    actual : DecodeResult (List U8) [TooShort]
     actual = Decode.fromBytesPartial input json
 
     actual.result == Ok []
@@ -1189,7 +1189,7 @@ expect
 expect
     input = Str.toUtf8 "\n[\t 1 , 2  , 3]"
 
-    actual : DecodeResult (List U64)
+    actual : DecodeResult (List U64) [TooShort]
     actual = Decode.fromBytesPartial input json
 
     expected = Ok [1, 2, 3]
@@ -1200,7 +1200,7 @@ expect
 expect
     input = Str.toUtf8 "\n\t [\n \"one\"\r , \"two\" , \n\"3\"\t]"
 
-    actual : DecodeResult (List Str)
+    actual : DecodeResult (List Str) [TooShort]
     actual = Decode.fromBytesPartial input json
     expected = Ok ["one", "two", "3"]