refactor: clean up readme and move decode to read_from_bits

README.md

@@ -17,43 +17,60 @@ Please check out the encode/decode tests.
 
 ## Encode
 ```gleam
-import gbor
+import gbor as g
+import gbor/encode
+
 import gleam/list
 
 type Cat {
   Cat(name: String, lives: Int, nicknames: List(String))
 }
 
-fn cat_encoder(cat: Cat) -> BitArray {
-  encode.map([
-    #(encode.string("name"), encode.string(cat.name)),
-    #(encode.string("lives"), encode.int(cat.lives)),
-    #(
-      encode.string("nicknames"),
-      encode.array(list.map(cat.nicknames, encode.string)),
-    ),
+fn cat_encoder(cat: Cat) -> Result(BitArray, encode.EncodeError) {
+  g.CBMap([
+    #(g.CBString("name"), g.CBString(cat.name)),
+    #(g.CBString("lives"), g.CBInt(cat.lives)),
+    #(g.CBString("nicknames"), g.CBArray(list.map(cat.nicknames, g.CBString))),
   ])
   |> encode.to_bit_array
 }
+
+pub fn main() {
+  let assert Ok(bin) =
+    Cat("Fluffy", 9, ["Fluff", "Fluffers"])
+    |> cat_encoder
+}
 ```
 
 ## Decode
 ```gleam
-import gbor
-import gleam/dynamic/decode as dy_decode
+import gbor/decode as gbor_decode
+import gleam/bit_array
+import gleam/dynamic/decode as gdd
+
+pub type Cat {
+  Cat(name: String, lives: Int, nicknames: List(String))
+}
 
-fn decode_cat(data: BitArray) -> Result(Cat, List(dy_decode.DecodeError)) {
+fn decode_cat(data: BitArray) -> Result(Cat, List(gdd.DecodeError)) {
   let cat_decoder = {
-    use name <- dy_decode.field("name", dy_decode.string)
-    use lives <- dy_decode.field("lives", dy_decode.int)
-    use nicknames <- dy_decode.field(
-      "nicknames",
-      dy_decode.list(dy_decode.string),
-    )
-    dy_decode.success(Cat(name:, lives:, nicknames:))
+    use name <- gdd.field("name", gdd.string)
+    use lives <- gdd.field("lives", gdd.int)
+    use nicknames <- gdd.field("nicknames", gdd.list(gdd.string))
+    gdd.success(Cat(name:, lives:, nicknames:))
   }
 
-  decode.parse(from: data, using: cat_decoder)
+  let assert Ok(cbor) = gbor_decode.from_bit_array(data)
+
+  gdd.run(gbor_decode.cbor_to_dynamic(cbor), cat_decoder)
+}
+
+pub fn main() {
+  let assert Ok(bin_cat) =
+    bit_array.base64_decode(
+      "o2RuYW1lZEx1Y3llbGl2ZXMIaW5pY2tuYW1lc4JqTHVja3kgTHVjeWNMdWM=",
+    )
+  assert Ok(Cat("Lucy", 8, ["Lucky Lucy", "Luc"])) == decode_cat(bin_cat)
 }
 ```
 

src/gbor/decode.gleam

@@ -83,7 +83,7 @@ pub fn tagged_decoder(
 /// 
 /// It takes a bit array and returns a result containing the decoded CBOR value
 /// 
-pub fn decode(data: BitArray) -> Result(g.CBOR, CborDecodeError) {
+pub fn from_bit_array(data: BitArray) -> Result(g.CBOR, CborDecodeError) {
   case decode_helper(data) {
     Ok(#(v, <<>>)) -> Ok(v)
     Ok(#(_, rest)) ->

test/round_trip_test.gleam

@@ -254,7 +254,7 @@ pub fn decode_dynamic_test() {
       "A2646E616D6574323031332D30332D32315432303A30343A30305A63646F62C074323031332D30332D32315432303A30343A30305A",
     )
 
-  let assert Ok(cbor_val) = d.decode(bin)
+  let assert Ok(cbor_val) = d.from_bit_array(bin)
   let dyn_val = d.cbor_to_dynamic(cbor_val)
 
   let decoder = {
@@ -272,7 +272,7 @@ pub fn decode_dynamic_test() {
 
 fn round_trip(expected: g.CBOR, hex: String) -> Result(Nil, String) {
   let assert Ok(binary) = bit_array.base16_decode(hex)
-  let assert Ok(v) = d.decode(binary)
+  let assert Ok(v) = d.from_bit_array(binary)
   use <- bool.guard(
     v != expected,
     Error(