package ppx_deriving_yojson

  1. Overview
  2. Docs
JSON codec generator for OCaml

Install

Dune Dependency

Authors

Maintainers

Sources

ppx_deriving_yojson-3.7.0.tar.gz
md5=456be82acb16bbf6be12ab01f9dfaa94
sha512=6aa8b3a6e60afd1ce68995bad6776c975b3640303b2049233e661c46300abea1f48916d4e876412de49f35744f31b99c29736e2bb974e1b4a494b0932bbd6e80

Description

ppx_deriving_yojson is a ppx_deriving plugin that provides a JSON codec generator.

Tags

syntax json

Published: 16 Aug 2022

README

[@@deriving yojson]

deriving Yojson is a ppx_deriving plugin that generates JSON serializers and deserializes that use the Yojson library from an OCaml type definition.

Sponsored by Evil Martians.

Note: ppx_yojson_conv is a more recent deriving extension for Yojson that uses a more durable technical foundation and is more actively maintained. We keep maintaing ppx_deriving_yojson for our existing users, but we would recommend that new projects start from ppx_yojson_conv instead.

Installation

deriving Yojson can be installed via OPAM:

$ opam install ppx_deriving_yojson

Usage

In order to use deriving yojson, require the package ppx_deriving_yojson.

If you are using dune, add ppx_deriving_json to the preprocess entry, and ppx_deriving_json.runtime to your requirements, like so:

...
(libraries  yojson core ppx_deriving_yojson.runtime)
(preprocess (pps ppx_deriving_yojson))
...

Syntax

deriving yojson generates two functions per type:

# #require "ppx_deriving_yojson";;
# type ty = .. [@@deriving yojson];;
val ty_of_yojson : Yojson.Safe.t -> (ty, string) Result.result
val ty_to_yojson : ty -> Yojson.Safe.t

When the deserializing function returns Error loc, loc points to the point in the JSON hierarchy where the error has occurred.

It is possible to generate only serializing or deserializing functions by using [@@deriving to_yojson] or [@@deriving of_yojson]. It is also possible to generate an expression for serializing or deserializing a type by using [%to_yojson:] or [%of_yojson:]; non-conflicting versions [%derive.to_yojson:] or [%derive.of_yojson:] are available as well. Custom or overriding serializing or deserializing functions can be provided on a per-field basis via [@to_yojson] and [@of_yojson] attributes.

If the type is called t, the functions generated are {of,to}_yojson instead of t_{of,to}_yojson.

Using the option [@@deriving yojson { exn = true }] will also generate a function ty_of_yojson_exn : Yojson.Safe.t -> ty which raises Failure err on error instead of returning an Error err result.

Semantics

deriving yojson handles tuples, records, normal and polymorphic variants; builtin types: int, int32, int64, nativeint, float, bool, char, string, bytes, ref, list, array, option and their Mod.t aliases.

The following table summarizes the correspondence between OCaml types and JSON values:

OCaml type JSON value Remarks
int, int32, float Number
int64, nativeint Number Can exceed range of double
bool Boolean
string, bytes String
char String Strictly one character in length
list, array Array
A tuple Array
ref 'a
option Null or 'a
A record Object
Yojson.Safe.t any Identity transformation
unit Null

Variants (regular and polymorphic) are represented using arrays; the first element is a string with the name of the constructor, the rest are the arguments. Note that the implicit tuple in a polymorphic variant is flattened. For example:

# type pvs = [ `A | `B of int | `C of int * string ] list [@@deriving yojson];;
# type v = A | B of int | C of int * string [@@deriving yojson];;
# type vs = v list [@@deriving yojson];;
# print_endline (Yojson.Safe.to_string (vs_to_yojson [A; B 42; C (42, "foo")]));;
[["A"],["B",42],["C",42,"foo"]]
# print_endline (Yojson.Safe.to_string (pvs_to_yojson [`A; `B 42; `C (42, "foo")]));;
[["A"],["B",42],["C",42,"foo"]]

Record variants are represented in the same way as if the nested structure was defined separately. For example:

# type v = X of { v: int } [@@deriving yojson];;
# print_endline (Yojson.Safe.to_string (v_to_yojson (X { v = 0 })));;
["X",{"v":0}]

Record variants are currently not supported for extensible variant types.

By default, objects are deserialized strictly; that is, all keys in the object have to correspond to fields of the record. Passing strict = false as an option to the deriver (i.e. [@@deriving yojson { strict = false }]) changes the behavior to ignore any unknown fields.

Options

Option attribute names may be prefixed with yojson. to avoid conflicts with other derivers.

[@key]

If the JSON object keys differ from OCaml conventions, lexical or otherwise, it is possible to specify the corresponding JSON key implicitly using [@key "field"], e.g.:

type geo = {
  lat : float [@key "Latitude"];
  lon : float [@key "Longitude"];
}
[@@deriving yojson]
[@name]

If the JSON variant names differ from OCaml conventions, it is possible to specify the corresponding JSON string explicitly using [@name "constr"], e.g.:

type units =
| Metric   [@name "metric"]
| Imperial [@name "imperial"]
[@@deriving yojson]
[@encoding]

Very large int64 and nativeint numbers can wrap when decoded in a runtime which represents all numbers using double-precision floating point, e.g. JavaScript and Lua. It is possible to specify the [@encoding `string] attribute to encode them as strings.

[@default]

It is possible to specify a default value for fields that can be missing from the JSON object, e.g.:

type pagination = {
  pages   : int;
  current : (int [@default 0]);
} [@@deriving yojson]

Fields with default values are not required to be present in inputs and will not be emitted in outputs.

[@to_yojson] / [@of_yojson]

One can provide custom serialization or deserialization functions, either overriding the default derivation or to provide support for abstract, functor, or other types that aren't otherwise amenable to derivation (similar to the @printer option provided by ppx_deriving's show plugin):

# module StringMap = Map.Make(struct type t = string let compare = compare end);;
# let yojson_of_stringmap m = StringMap.bindings m
                           |> [%to_yojson: (string * string) list];;
# type page = { number : int [@to_yojson fun i -> `Int (i + 1)]
              ; bounds : (int * int * int * int)
              ; attrs  : string StringMap.t [@to_yojson yojson_of_stringmap]}
              [@@deriving to_yojson];;
# { number = 0
  ; bounds = (0, 0, 792, 612)
  ; attrs  = StringMap.add "foo" "bar" StringMap.empty }
  |> page_to_yojson
  |> Yojson.Safe.to_string
  |> print_endline

{"number":1,"bounds":[0,0,792,612],"attrs":[["foo","bar"]]}
Yojson_meta module

The meta deriver option can be used to generate a module containing all JSON key names, e.g.

type foo = {
 fvalue : float;
 svalue : string [@key "@svalue_json"];
 ivalue : int;
} [@@deriving to_yojson { strict = false, meta = true } ]
end

defines the following module:

module Yojson_meta_foo = struct
  let keys = ["fvalue"; "@svalue_json"; "ivalue"]
  let _ = keys
end

When the type is named t, the module is named just Yojson_meta.

License

deriving yojson is distributed under the terms of MIT license.

Dependencies (6)

  1. ppxlib >= "0.26.0"
  2. ppx_deriving >= "5.1"
  3. result
  4. yojson >= "1.6.0"
  5. dune >= "1.0"
  6. ocaml >= "4.05.0"

Dev Dependencies (1)

  1. ounit2 with-test

Used by (92)

  1. archetype
  2. aws-s3 < "1.1.0"
  3. builder-web >= "0.2.0"
  4. caisar
  5. caisar-xgboost
  6. camels
  7. canary
  8. coclobas
  9. colibrics
  10. comby
  11. comby-kernel
  12. coq-lsp >= "0.2.0+8.17"
  13. coq-serapi >= "8.10.0+0.7.0"
  14. current-albatross-deployer
  15. current_docker
  16. current_examples >= "0.4"
  17. current_git
  18. current_github >= "0.4"
  19. current_gitlab
  20. current_ocluster
  21. current_web >= "0.3"
  22. cwe_checker >= "0.3"
  23. dap
  24. disml
  25. earlybird
  26. easy_logging_yojson
  27. fiat-p256
  28. frama-c >= "25.0"
  29. fred
  30. fsml
  31. fstar >= "0.9.6.0~alpha1"
  32. gdbprofiler < "0.2"
  33. gemini
  34. goblint
  35. goblint-cil >= "1.8.0"
  36. grpc-examples
  37. guardian
  38. hacl_x25519
  39. hardcaml-lua
  40. hl_yaml
  41. i3ipc
  42. index-bench
  43. irmin-bench < "3.0.0"
  44. jhupllib >= "0.1.1"
  45. jupyter < "2.7.9"
  46. karamel
  47. ketrew >= "3.0.0"
  48. key-parsers >= "0.3.0" & < "1.0.0"
  49. kremlin < "transition"
  50. kubecaml
  51. lambda-runtime
  52. links >= "0.7.3"
  53. mirage-crypto-ec
  54. morbig
  55. netml
  56. noise
  57. nsq >= "0.2.4"
  58. ocaml_db_model
  59. ocaml_pgsql_model
  60. ocluster-api
  61. oframl
  62. ogen >= "0.1.3"
  63. ojs-base >= "0.3.0"
  64. ojs_base
  65. opam-check-npm-deps
  66. oraft
  67. pa_ppx < "0.07" | >= "0.10" & < "0.15"
  68. pds-reachability
  69. petr4
  70. pkcs11
  71. pkcs11-driver
  72. ppx_json_types
  73. ppx_netblob >= "1.2.1"
  74. repr-bench < "0.2.1"
  75. SZXX >= "2.0.0"
  76. safemoney
  77. satyrographos >= "0.0.2.8"
  78. sihl < "0.2.0" | >= "0.3.0~rc2"
  79. sihl-core
  80. slacko >= "0.13.0"
  81. socket-daemon >= "0.3.0"
  82. starred_ml
  83. stitch
  84. stog_server
  85. styled-ppx
  86. textrazor
  87. u2f
  88. usbmux >= "1.3.2"
  89. vercel
  90. wamp < "1.0"
  91. webauthn
  92. zeit

Conflicts

None

OCaml

Innovation. Community. Security.