roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-10-26 10:17:51 +03:00
Code Issues Packages Projects Releases Wiki Activity

removed DecodeError

Browse Source
This commit is contained in:
Trevor Settles 2024-07-11 20:25:03 -06:00
parent b65e65f0a4
commit 2344ae5f22
No known key found for this signature in database
GPG Key ID: F46B83058222DBAA
5 changed files with 61 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
crates/compiler/builtins/roc/Decode.roc
View File

@ -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,35 +61,35 @@ 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 err fmt := 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 err fmt 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 err fmt where fmt implements DecoderFormatting
u16 : Decoder U16 err fmt where fmt implements DecoderFormatting
u32 : Decoder U32 err fmt where fmt implements DecoderFormatting
u64 : Decoder U64 err fmt where fmt implements DecoderFormatting
u128 : Decoder U128 err fmt where fmt implements DecoderFormatting
i8 : Decoder I8 err fmt where fmt implements DecoderFormatting
i16 : Decoder I16 err fmt where fmt implements DecoderFormatting
i32 : Decoder I32 err fmt where fmt implements DecoderFormatting
i64 : Decoder I64 err fmt where fmt implements DecoderFormatting
i128 : Decoder I128 err fmt where fmt implements DecoderFormatting
f32 : Decoder F32 err fmt where fmt implements DecoderFormatting
f64 : Decoder F64 err fmt where fmt implements DecoderFormatting
dec : Decoder Dec err fmt where fmt implements DecoderFormatting
bool : Decoder Bool err fmt where fmt implements DecoderFormatting
string : Decoder Str err fmt where fmt implements DecoderFormatting
list : Decoder elem err fmt -> Decoder (List elem) err fmt where fmt implements DecoderFormatting
## `record state stepField finalizer` decodes a record field-by-field.
##
@ -101,7 +97,7 @@ DecoderFormatting implements
## `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 err fmt), Skip]), (state, fmt -> Result val err) -> Decoder val err fmt 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 err fmt), TooLong]), (state -> Result val err) -> Decoder val err fmt 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 err fmt 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 err fmt, 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,7 +148,7 @@ 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), TooShort] where val implements Decoding, fmt implements DecoderFormatting
fromBytes = \bytes, fmt ->
when fromBytesPartial bytes fmt is
{ result, rest } ->
@ -164,5 +160,5 @@ fromBytes = \bytes, fmt ->
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 }

2
crates/compiler/derive/src/decoding/list.rs
View File

@ -36,7 +36,7 @@ pub(crate) fn decoder(env: &mut Env<'_>, _def_symbol: Symbol) -> (Expr, Variable
// set val ~ elem
let val_var = match env.subs.get_content_without_compacting(elem_decoder_var) {
Content::Alias(Symbol::DECODE_DECODER_OPAQUE, vars, _, AliasKind::Opaque)
if vars.type_variables_len == 2 =>
if vars.type_variables_len == 3 =>
{
env.subs.get_subs_slice(vars.type_variables())[0]
}

6
crates/compiler/derive/src/decoding/record.rs
View File

@ -66,7 +66,7 @@ use super::wrap_in_decode_custom_decode_with;
/// Ok f1 -> Ok { f1, f0 }
/// Err _ -> Err TooShort
/// Err _ -> Err TooShort
///
///
/// Decode.custom \bytes, fmt -> Decode.decodeWith bytes (Decode.record initialState stepField finalizer) fmt
///```
pub(crate) fn decoder(
@ -888,7 +888,7 @@ pub(super) fn finalizer(
.zip(field_vars.iter().rev())
.zip(result_field_vars.iter().rev())
{
// [Ok field_var, Err DecodeError]
// [Ok field_var, Err err]
// when rec.f0 is
// Err _ ->
// when Decode.decodeWith [] Decode.decoder fmt is
@ -1020,7 +1020,7 @@ pub(super) fn finalizer(
/// decRec-> decRec.result
/// Ok a -> Ok a
/// ```
/// Tries to decode the field with a zero byte input if it missing,
/// Tries to decode the field with a zero byte input if it missing,
/// this allows the decoder to decode types that have a state for "missing", such as
/// an "Option" type.
///

57
crates/compiler/module/src/symbol.rs
View File

@ -1655,35 +1655,34 @@ define_builtins! {
26 ENCODE_TO_BYTES: "toBytes"
}
12 DECODE: "Decode" => {
0 DECODE_DECODE_ERROR: "DecodeError" exposed_type=true
1 DECODE_DECODE_RESULT: "DecodeResult" exposed_type=true
2 DECODE_DECODER_OPAQUE: "Decoder" exposed_type=true
3 DECODE_DECODING: "Decoding" exposed_type=true
4 DECODE_DECODER: "decoder"
5 DECODE_DECODERFORMATTING: "DecoderFormatting" exposed_type=true
6 DECODE_U8: "u8"
7 DECODE_U16: "u16"
8 DECODE_U32: "u32"
9 DECODE_U64: "u64"
10 DECODE_U128: "u128"
11 DECODE_I8: "i8"
12 DECODE_I16: "i16"
13 DECODE_I32: "i32"
14 DECODE_I64: "i64"
15 DECODE_I128: "i128"
16 DECODE_F32: "f32"
17 DECODE_F64: "f64"
18 DECODE_DEC: "dec"
19 DECODE_BOOL: "bool"
20 DECODE_STRING: "string"
21 DECODE_LIST: "list"
22 DECODE_RECORD: "record"
23 DECODE_TUPLE: "tuple"
24 DECODE_CUSTOM: "custom"
25 DECODE_DECODE_WITH: "decodeWith"
26 DECODE_FROM_BYTES_PARTIAL: "fromBytesPartial"
27 DECODE_FROM_BYTES: "fromBytes"
28 DECODE_MAP_RESULT: "mapResult"
0 DECODE_DECODE_RESULT: "DecodeResult" exposed_type=true
1 DECODE_DECODER_OPAQUE: "Decoder" exposed_type=true
2 DECODE_DECODING: "Decoding" exposed_type=true
3 DECODE_DECODER: "decoder"
4 DECODE_DECODERFORMATTING: "DecoderFormatting" exposed_type=true
5 DECODE_U8: "u8"
6 DECODE_U16: "u16"
7 DECODE_U32: "u32"
8 DECODE_U64: "u64"
9 DECODE_U128: "u128"
10 DECODE_I8: "i8"
11 DECODE_I16: "i16"
12 DECODE_I32: "i32"
13 DECODE_I64: "i64"
14 DECODE_I128: "i128"
15 DECODE_F32: "f32"
16 DECODE_F64: "f64"
17 DECODE_DEC: "dec"
18 DECODE_BOOL: "bool"
19 DECODE_STRING: "string"
20 DECODE_LIST: "list"
21 DECODE_RECORD: "record"
22 DECODE_TUPLE: "tuple"
23 DECODE_CUSTOM: "custom"
24 DECODE_DECODE_WITH: "decodeWith"
25 DECODE_FROM_BYTES_PARTIAL: "fromBytesPartial"
26 DECODE_FROM_BYTES: "fromBytes"
27 DECODE_MAP_RESULT: "mapResult"
}
13 HASH: "Hash" => {
0 HASH_HASH_ABILITY: "Hash" exposed_type=true

6
crates/compiler/test_mono/src/tests.rs
View File

@ -68,11 +68,11 @@ decodeF64 = Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest
decodeDec = Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
decodeBool = Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
decodeString = Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
decodeList : Decoder elem ErrDecoder -> Decoder (List elem) ErrDecoder
decodeList : Decoder elem err ErrDecoder -> Decoder (List elem) err ErrDecoder
decodeList = \_ -> Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
decodeRecord : state, (state, Str -> [Keep (Decoder state ErrDecoder), Skip]), (state, ErrDecoder -> Result val DecodeError) -> Decoder val ErrDecoder
decodeRecord : state, (state, Str -> [Keep (Decoder state err ErrDecoder), Skip]), (state, ErrDecoder -> Result val err) -> Decoder val err ErrDecoder
decodeRecord = \_, _, _ -> Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
decodeTuple : state, (state, U64 -> [Next (Decoder state ErrDecoder), TooLong]), (state -> Result val DecodeError) -> Decoder val ErrDecoder
decodeTuple : state, (state, U64 -> [Next (Decoder state err ErrDecoder), TooLong]), (state -> Result val err) -> Decoder val err ErrDecoder
decodeTuple = \_, _, _ -> Decode.custom \rest, @ErrDecoder {} -> { result: Err TooShort, rest }
"#;