JSON decoders chapter

json/DataTypes/DecodeStudent.roc

@@ -0,0 +1,28 @@
+module [readStudents]
+
+import Student exposing [Student, Module]
+import Decoding exposing [JsonDecoder, list, field, string, number, bool, map2, map3, or]
+
+Students : List Student
+
+readStudents : JsonDecoder Students
+readStudents = \json ->
+    studentsField = \s -> (list readStudent) s
+    (field "students" studentsField) json
+
+readStudent : JsonDecoder Student
+readStudent = \json ->
+    nameField = field "name" string
+    modulesField = field "modules" (\m -> (list readModule) m)
+    currentGrade = field "currentGrade" number
+    finalGrade = field "finalGrade" number
+    currentStudent = map3 nameField modulesField currentGrade (\(name, mods, cg) -> CurrentStudent { name: name, modules: mods, currentGrade: cg })
+    graduatedStudent = map3 nameField modulesField finalGrade (\(name, mods, fg) -> GraduatedStudent { name: name, modules: mods, finalGrade: fg })
+    (or currentStudent graduatedStudent) json
+
+readModule : JsonDecoder Module
+readModule = \json ->
+    nameField = field "name" string
+    creditsField = field "credits" number
+    enrolledField = field "enrolled" bool
+    (map3 nameField creditsField enrolledField \(name, credits, enrolled) -> { name: name, credits: credits, enrolled: enrolled }) json

json/DataTypes/DecodeStudentLong.roc

@@ -0,0 +1,81 @@
+module [getListStudents]
+
+import JsonData exposing [Json]
+import Student exposing [Student, Module]
+
+JsonErrors : [
+    FieldNotFound Str,
+    ExpectedJsonObject Str,
+    ExpectedJsonArray Str,
+]
+
+getListStudents : Json -> Result (List Student) JsonErrors
+getListStudents = \json ->
+    when json is
+        Object obj ->
+            when Dict.get obj "students" is
+                Ok students -> checkStudentList students
+                _ -> Err (FieldNotFound "Expected field with name students in object")
+
+        _ -> Err (ExpectedJsonObject "Expected an Object")
+
+checkStudentList : Json -> Result (List Student) JsonErrors
+checkStudentList = \json ->
+    when json is
+        Arr students ->
+            List.mapTry (List.map students checkStudentObj) \x -> x
+
+        _ -> Err (ExpectedJsonArray "Expected an Array")
+
+checkStudentObj : Json -> Result Student JsonErrors
+checkStudentObj = \json ->
+    when json is
+        Object obj ->
+            when Dict.get obj "name" is
+                Ok (String name) ->
+                    when Dict.get obj "modules" is
+                        Ok modules ->
+                            when checkModulesList modules is
+                                Ok goodMods ->
+                                    when Dict.get obj "finalGrade" is
+                                        Ok (Number fg) -> Ok (GraduatedStudent { name: name, modules: goodMods, finalGrade: fg })
+                                        _ ->
+                                            when Dict.get obj "currentGrade" is
+                                                Ok (Number cg) -> Ok (CurrentStudent { name: name, modules: goodMods, currentGrade: cg })
+                                                _ -> Err (FieldNotFound "Expected field ")
+
+                                Err e -> Err e
+
+                        _ -> Err (FieldNotFound "Expected field with name modules in object")
+
+                _ -> Err (FieldNotFound "Expected field with name name in object")
+
+        _ -> Err (ExpectedJsonObject "Expected an Object")
+
+checkModulesList : Json -> Result (List Module) JsonErrors
+checkModulesList = \json ->
+    when json is
+        Arr modules ->
+            List.mapTry (List.map modules readModuleObject) \x -> x
+
+        _ -> Err (ExpectedJsonArray "Expected an Array")
+
+readModuleObject : Json -> Result Module JsonErrors
+readModuleObject = \json ->
+    when json is
+        Object fields ->
+            when Dict.get fields "name" is
+                Ok (String name) ->
+                    when Dict.get fields "credits" is
+                        Ok (Number credits) ->
+                            when Dict.get fields "enrolled" is
+                                Ok (Boolean enrolled) ->
+                                    Ok ({ name: name, credits: credits, enrolled: enrolled })
+
+                                _ -> Err (FieldNotFound "Expected field with name \"credits\" in object")
+
+                        _ -> Err (FieldNotFound "Expected field with name \"credits\" in object")
+
+                _ -> Err (FieldNotFound "Expected field with name \"name\" in object")
+
+        _ -> Err (ExpectedJsonObject "Expected an Object")

json/DataTypes/Decoding.roc

@@ -0,0 +1,167 @@
+module [string, number, bool, list, field, map, map2, map3, andThen, or, JsonDecoder, DecodingErrors]
+import JsonData exposing [Json]
+
+DecodingErrors : [
+    FieldNotFound Str,
+    ExpectedJsonObject Str,
+    ExpectedJsonArray Str,
+    WrongJsonType Str,
+    KeyNotFound,
+    DecodingFailed
+]
+
+JsonDecoder t : Json -> Result t DecodingErrors
+
+string : JsonDecoder Str
+string = \json ->
+    when json is
+        String str -> Ok str
+        _ -> Err (WrongJsonType "Expected a String when decoding, found $(printJsonType json)")
+
+number : JsonDecoder U64
+number = \json ->
+    when json is
+        Number num -> Ok num
+        _ -> Err (WrongJsonType "Expected a Number when decoding")
+
+bool : JsonDecoder Bool
+bool = \json ->
+    when json is
+        Boolean b -> Ok b
+        _ -> Err (WrongJsonType "Expected a Bool when decoding")
+
+list : JsonDecoder a -> JsonDecoder (List a)
+list = \decoderA ->
+    \data ->
+        when data is
+            Arr jsonValues -> List.mapTry jsonValues decoderA
+            _ -> Err (ExpectedJsonArray "Expected an Arr when decoding")
+
+field : Str, JsonDecoder a -> JsonDecoder a
+field = \name, decoder ->
+    \data ->
+        when data is
+            Object dict ->
+                when Dict.get dict name is
+                    Ok v -> decoder v
+                    Err s -> Err s
+
+            _ -> Err (WrongJsonType "Expected an Object when decoding")
+
+map : JsonDecoder a, (a -> b) -> JsonDecoder b
+map = \decoderA, f ->
+    \data -> Result.map (decoderA data) f
+# \data -> decoderA data |> Result.map f
+# decoderA |> Result.map f
+
+map2 : JsonDecoder a, JsonDecoder b, ((a, b) -> c) -> JsonDecoder c
+map2 = \decoderA, decoderB, f ->
+    \data ->
+        when (decoderA data, decoderB data) is
+            (Ok a, Ok b) -> Ok (f (a, b))
+            (Err a, _) -> Err a
+            (_, Err b) -> Err b
+
+map3 : JsonDecoder a, JsonDecoder b, JsonDecoder c, ((a, b, c) -> d) -> JsonDecoder d
+map3 = \decoderA, decoderB, decoderC, f ->
+    \data ->
+        when (decoderA data, decoderB data, decoderC data) is
+            (Ok a, Ok b, Ok c) -> Ok (f (a, b, c))
+            (Err a, _, _) -> Err a
+            (_, Err b, _) -> Err b
+            (_, _, Err c) -> Err c
+
+andThen : (a -> JsonDecoder b), JsonDecoder a -> JsonDecoder b
+andThen = \toB, aDecoder  ->
+    \data -> 
+        when aDecoder data is
+            Ok a -> (toB a) data
+            Err a -> Err a
+
+
+
+or : JsonDecoder a, JsonDecoder a -> JsonDecoder a
+or = \decoderA, decoderB -> 
+    \data -> 
+       decoderA data 
+       |> Result.onErr \_ -> (decoderB data)
+
+
+# TODO - Sum and Product decoders 
+# product=\a, b, c, decoderA, decoderB, decoderC, f -> 
+ # could you take in a dictionary of Dict Str JsonDecoder a?
+ product : Str, Str, Str, JsonDecoder a, JsonDecoder b, JsonDecoder c, ((a, b, c) -> d) -> JsonDecoder d
+ altPr : List (Str, JsonDecoder a) 
+
+# sum : JsonDecoder a, JsonDecoder b -> JsonDecoder c
+# sum : [JsonDecoder a] -> JsonDecoder a
+# sum =\ds -> 
+#     \data -> 
+#         List.mapTry ds (\decoder -> decoder data)
+        # when decoderA data is 
+        #     Ok a -> a
+        #     _ -> when decoderB data is 
+        #         Ok b -> b
+        #         Err b -> Err b
+# sum: List (JsonDecoder a) -> JsonDecoder a ⁠
+
+# sum : [JsonDecoder a] -> JsonDecoder a
+# sum =\ decoders -> 
+#     \data -> 
+#         List.walkTry decoders \d -> d
+
+
+
+# TESTS
+mathsMod = Object
+    (
+        Dict.empty {}
+        |> Dict.insert "name" (String "Maths 101")
+        |> Dict.insert "credits" (Number 200)
+        |> Dict.insert "enrolled" (Boolean Bool.true)
+    )
+phyMod = Object
+    (
+        Dict.empty {}
+        |> Dict.insert "name" (String "Physics 101")
+        |> Dict.insert "credits" (Number 200)
+    )
+nameDecoder = field "name" string
+creditsDecoder = field "credits" number
+enrolledDecoder = field "enrolled" bool
+
+# map tests
+expect (map nameDecoder \name -> { name: name }) phyMod == Ok ({ name: "Physics 101" })
+expect (map enrolledDecoder \name -> { name: name }) phyMod == Err(KeyNotFound)
+
+# map2 tests
+expect (map2 nameDecoder creditsDecoder \(name, credits) -> { name: name, credits: credits }) (phyMod) == Ok ({ name: "Physics 101", credits: 200 })
+
+# map3 tests
+expect (map3 nameDecoder creditsDecoder enrolledDecoder \(name, credits, enrolled) -> { name: name, credits: credits, enrolled: enrolled }) (mathsMod) == Ok ({ name: "Maths 101", credits: 200, enrolled: Bool.true })
+
+# list tests
+myList = Arr [String "hello", String "world"]
+expect (list string) myList == Ok (["hello", "world"])
+expect (list string) mathsMod == Err (ExpectedJsonArray "Expected an Arr when decoding")
+
+# field tests
+expect nameDecoder mathsMod == Ok ("Maths 101")
+expect nameDecoder myList == Err (WrongJsonType "Expected an Object when decoding")
+expect (field "blah" string) mathsMod == Err KeyNotFound
+
+# primitive types
+expect string (String "hello") == Ok ("hello")
+expect string (Number 123) == Err (WrongJsonType "Expected a String when decoding, found Number 123")
+expect bool (Boolean Bool.true) == Ok Bool.true
+expect number (Number 400) == Ok (400)
+# expect null (Null) == Ok ("null")
+
+printJsonType : Json -> Str
+printJsonType = \json ->
+    when json is 
+        String str -> "String $(str)"
+        Number num -> "Number $(Num.toStr num)"
+        Boolean _ -> "Boolean"
+        Object _ -> "Object"
+        Arr _ -> "Arr"

json/DataTypes/Encoding.roc

@@ -0,0 +1,41 @@
+module []
+import JsonData exposing [Json]
+
+JsonEncoder t : t -> Json
+
+string : JsonEncoder Str
+string = \str ->
+    String str
+
+number : JsonEncoder U64
+number = \num ->
+    Number num
+
+bool : JsonEncoder Bool
+bool = \b ->
+    Boolean b
+
+list : JsonEncoder a -> JsonEncoder (List a)
+list = \encoderA ->
+    \data ->
+        json = List.map data encoderA
+        Arr json
+
+# field : Str, JsonEncoder a -> JsonEncoder (Str, Json)
+field = \ fieldName, encoderA -> 
+        \data -> 
+            j = encoderA data
+            (fieldName, j)
+# TESTS
+# primitives
+expect string "hello" == (String "hello")
+expect number 50 == (Number 50)
+expect bool Bool.true == (Boolean Bool.true)
+# there is no null type in Roc
+
+# list tests
+strs = ["hello", "hello again"]
+expect (list string) strs == Arr[(String "hello"), (String "hello again")]
+
+# field encoder 
+expect (field "fieldName" string) "fieldValue" == ("fieldName", String "fieldValue")

json/DataTypes/JsonData.roc

@@ -0,0 +1,9 @@
+module [Json]
+
+Json : [
+    String Str,
+    Number U64,
+    Boolean Bool,
+    Object (Dict Str Json),
+    Arr (List Json),
+]

json/DataTypes/Student.roc

@@ -0,0 +1,20 @@
+module [Student, Module]
+
+Student : [
+    CurrentStudent {
+        name : Str,
+        modules : List (Module),
+        currentGrade : U64
+    }, 
+    GraduatedStudent {
+        name : Str,
+        modules : List (Module),
+        finalGrade : U64
+    }
+]
+
+Module : {
+    name : Str,
+    credits : U64,
+    enrolled : Bool
+}

json/DataTypes/StudentData.json

@@ -0,0 +1,31 @@
+{
+    "students": [
+        {
+            "name": "Alice",
+            "modules": [
+                {
+                    "name": "Physics 101",
+                    "credits": 10,
+                    "enrolled": true
+                },
+                {
+                    "name": "Maths 101",
+                    "credits": 20,
+                    "enrolled": true
+                }
+            ],
+            "currentGrade": 75
+        },
+        {
+            "name": "Bob",
+            "modules": [
+                {
+                    "name": "Maths 101",
+                    "credits": 20,
+                    "enrolled": false
+                }
+            ],
+            "finalGrade": 70
+        }
+    ]
+}

json/DataTypes/main.roc

@@ -0,0 +1,5 @@
+package [
+    JsonData,
+    Student,
+    DecodeStudent
+]{}