Json

t

RE
type t;

The JSON data structure.

kind

RE
type kind('a) =
  | String: kind(Js_string.t)
  | Number: kind(float)
  | Object: kind(Js_dict.t(t))
  | Array: kind(array(t))
  | Boolean: kind(bool)
  | Null: kind(Js_types.null_val);

Underlying type of a JSON value.

tagged_t

RE
type tagged_t =
  | JSONFalse
  | JSONTrue
  | JSONNull
  | JSONString(string)
  | JSONNumber(float)
  | JSONObject(Js_dict.t(t))
  | JSONArray(array(t));

classify

RE
let classify: t => tagged_t;

test

RE
let test: ('a, kind('b)) => bool;

test(v, kind) returns true if v is of kind.

decodeString

RE
let decodeString: t => option(Js_string.t);

decodeString(json) returns Some(s) if json is a string, None otherwise.

decodeNumber

RE
let decodeNumber: t => option(float);

decodeNumber(json) returns Some(n) if json is a number, None otherwise.

decodeObject

RE
let decodeObject: t => option(Js_dict.t(t));

decodeObject(json) returns Some(o) if json is an object, None otherwise.

decodeArray

RE
let decodeArray: t => option(array(t));

decodeArray(json) returns Some(a) if json is an array, None otherwise.

decodeBoolean

RE
let decodeBoolean: t => option(bool);

decodeBoolean(json) returns Some(b) if json is a boolean, None otherwise.

decodeNull

RE
let decodeNull: t => option(Js_null.t('a));

decodeNull(json) returns Some(null) if json is a null, None otherwise.

null

RE
let null: t;

null is the singleton null JSON value.

string

RE
let string: string => t;

string(s) makes a JSON string of the string s.

number

RE
let number: float => t;

number(n) makes a JSON number of the float n.

boolean

RE
let boolean: bool => t;

boolean(b) makes a JSON boolean of the bool b.

object_

RE
let object_: Js_dict.t(t) => t;

object_(dict) makes a JSON object of the Js.Dict.t dict.

array

RE
let array: array(t) => t;

array_(a) makes a JSON array of the Js.Json.t array a.

stringArray

RE
let stringArray: array(string) => t;

stringArray(a) makes a JSON array of the string array a.

numberArray

RE
let numberArray: array(float) => t;

numberArray(a) makes a JSON array of the float array a.

booleanArray

RE
let booleanArray: array(bool) => t;

booleanArray(a) makes a JSON array of the bool array a.

objectArray

RE
let objectArray: array(Js_dict.t(t)) => t;

objectArray(a) makes a JSON array of the JsDict.tarraya`.

parseExn

RE
let parseExn: string => t;

parseExn(s) parses the string s into a JSON data structure. Returns a JSON data structure. Raises SyntaxError if the given string is not a valid JSON. Note: SyntaxError is a JavaScript exception.

RE
/* parse a simple JSON string */

let json =
  try (Js.Json.parseExn({| "foo" |})) {
  | _ => failwith("Error parsing JSON string")
  };

switch (Js.Json.classify(json)) {
| Js.Json.JSONString(value) => Js.log(value)
| _ => failwith("Expected a string")
};

RE
/* parse a complex JSON string */

let getIds = s => {
  let json =
    try (Js.Json.parseExn(s)) {
    | _ => failwith("Error parsing JSON string")
    };

  switch (Js.Json.classify(json)) {
  | Js.Json.JSONObject(value) =>
    /* In this branch, compiler infer value : Js.Json.t Js.Dict.t */
    switch (Js.Dict.get(value, "ids")) {
    | Some(ids) =>
      switch (Js.Json.classify(ids)) {
      | Js.Json.JSONArray(ids) =>
        /* In this branch compiler infer ids : Js.Json.t array */
        ids
      | _ => failwith("Expected an array")
      }
    | None => failwith("Expected an `ids` property")
    }
  | _ => failwith("Expected an object")
  };
};

/* prints `1, 2, 3` */
Js.log(getIds({| { "ids" : [1, 2, 3 ] } |}));

stringify

RE
let stringify: t => string;

stringify(json) formats the JSON data structure as a string. Returns the string representation of a given JSON data structure.

RE
/* Creates and stringifies a simple JS object */

{
  let dict = Js.Dict.empty();
  Js.Dict.set(dict, "name", Js.Json.string("John Doe"));
  Js.Dict.set(dict, "age", Js.Json.number(30.0));
  Js.Dict.set(
    dict,
    "likes",
    Js.Json.stringArray([|"bucklescript", "ocaml", "js"|]),
  );

  Js.log(Js.Json.stringify(Js.Json.object_(dict)));
};

stringifyWithSpace

RE
let stringifyWithSpace: (t, int) => string;

stringify(json) formats the JSON data structure as a string. Returns the string representation of a given JSON data structure with spacing.

RE
/* Creates and stringifies a simple JS object with spacing */

{
  let dict = Js.Dict.empty();
  Js.Dict.set(dict, "name", Js.Json.string("John Doe"));
  Js.Dict.set(dict, "age", Js.Json.number(30.0));
  Js.Dict.set(
    dict,
    "likes",
    Js.Json.stringArray([|"bucklescript", "ocaml", "js"|]),
  );

  Js.log(Js.Json.stringifyWithSpace(Js.Json.object_(dict), 2));
};

stringifyAny

RE
let stringifyAny: 'a => option(string);

stringifyAny(value) formats any value into a JSON string.

RE
/* prints `["foo", "bar"]` */
Js.log(Js.Json.stringifyAny([|"foo", "bar"|]));