geojsone 0.1.0 · OCaml Package

type value = [

| `Null
| `Bool of bool
| `Float of float
| `String of string
| `A of value list
| `O of (string * value) list

]

type t = [

| `A of value list
| `O of (string * value) list

]

val value : t -> value

module List : sig ... end

type error_location = (int * int) * (int * int)

type read_value_error = [

| `Error of error_location * Jsone.error
| `Unexpected of [ `Lexeme of error_location * Jsone.lexeme * string | `End_of_input ]

]

type read_error = [

| read_value_error
| `Not_a_t of value

]

val json_of_src : Uutfe.src -> (value, [> read_value_error ]) Stdlib.result

val value_to_dst : ?minify:bool -> Jsone.dst -> value -> unit

val buffer_to_dst : Stdlib.Buffer.t -> Cstruct.t -> unit

val value_to_buffer : ?minify:bool -> Stdlib.Buffer.t -> value -> unit

val to_buffer : 
  ?minify:bool ->
  Stdlib.Buffer.t ->
  [< `A of value list
  | `Bool of bool
  | `Float of float
  | `Null
  | `O of (string * value) list
  | `String of string ] ->
  unit

val value_to_string : ?minify:bool -> value -> string

val to_string : 
  ?minify:bool ->
  [< `A of value list
  | `Bool of bool
  | `Float of float
  | `Null
  | `O of (string * value) list
  | `String of string ] ->
  string

exception Parse_error of value * string

val parse_error : value -> ('a, unit, string, 'b) Stdlib.format4 -> 'c

val wrap : 'a -> [> `A of 'b list ]

val unwrap : 
  [< `A of value list
  | `Bool of bool
  | `Float of float
  | `Null
  | `O of (string * value) list
  | `String of string A ] ->
  value

val read_error_description : 
  [< `Error of
       error_location * Jsone.error & 'a
                                      * [< `Expected of
                                             [< `Aval of bool
                                             | `Comment
                                             | `Eoi
                                             | `Json
                                             | `Name
                                             | `Name_sep
                                             | `Omem of bool
                                             | `Value ]
                                        | `Illegal_BOM
                                        | `Illegal_bytes of string
                                        | `Illegal_escape of
                                          [< `Lone_hi_surrogate of int
                                          | `Lone_lo_surrogate of int
                                          | `Not_esc_uchar of Stdlib.Uchar.t
                                          | `Not_hex_uchar of Stdlib.Uchar.t
                                          | `Not_lo_surrogate of int ]
                                        | `Illegal_literal of string
                                        | `Illegal_number of string
                                        | `Illegal_string_uchar of
                                          Stdlib.Uchar.t
                                        | `Unclosed of
                                          [< `As | `Comment | `Os | `String ] ]
  | `Not_a_t of value & 'b
  | `Unexpected of
    [ `End_of_input | `Lexeme of error_location * Jsone.lexeme * string ] & 
    [< `End_of_input
    | `Lexeme of 'c * 'd * string ] ] ->
  string

val read_error_location : 
  [< `Error of error_location * Jsone.error & error_location * 'a
  | `Not_a_t of value & 'b
  | `Unexpected of
    [ `End_of_input | `Lexeme of error_location * Jsone.lexeme * string ] & 
    [< `End_of_input
    | `Lexeme of error_location * 'c * 'd ] ] ->
  error_location option

val value_from_src_result : 
  Uutfe.src ->
  (value, [> read_value_error ]) Stdlib.result

val value_from_src : Uutfe.src -> value

val src_of_string : string -> unit -> Cstruct.t

val value_from_string_result : 
  string ->
  (value, [> read_value_error ]) Stdlib.result

val value_from_string : string -> value

val ensure_document_result : value -> ([> t ], [> read_error ]) Stdlib.result

val ensure_document : value -> [> t ]

val from_string : string -> [> t ]

val from_string_result : string -> ([> t ], [> read_error ]) Stdlib.result

val unit : unit -> [> `Null ]

val get_unit : value -> unit

val bool : 'a -> [> `Bool of 'a ]

val get_bool : value -> bool

val string : 'a -> [> `String of 'a ]

val get_string : value -> string

val int : int -> [> `Float of float ]

val int32 : int32 -> [> `Float of float ]

val int64 : int64 -> [> `Float of float ]

val get_int : value -> int

val get_int32 : value -> int32

val get_int64 : value -> int64

val float : 'a -> [> `Float of 'a ]

val get_float : value -> float

val list : ('a -> 'b) -> 'a list -> [> `A of 'b list ]

val get_list : (value -> 'a) -> value -> 'a list

val strings : 'a list -> [> `A of [> `String of 'b ] list ]

val get_strings : value -> string list

val option : ('a -> 'b) -> 'c option -> [> `A of 'd list | `Null ]

val get_option : (value -> 'a) -> value -> 'b option

val dict : 'a -> [> `O of 'a ]

val get_dict : value -> (string * value) list

val pair : ('a -> 'b) -> ('c -> 'd) -> ('e * 'f) -> [> `A of 'g list ]

val get_pair : (value -> 'a) -> (value -> 'b) -> value -> 'c * 'd

val triple : 
  ('a -> 'b) ->
  ('c -> 'd) ->
  ('e -> 'f) ->
  ('g * 'h * 'i) ->
  [> `A of 'j list ]

val get_triple : 
  (value -> 'a) ->
  (value -> 'b) ->
  (value -> 'c) ->
  value ->
  'd * 'e * 'f

val mem : [> `O of ('b * 'c) list ] as 'a -> 'b list -> bool

val find : [> `O of ('b * 'c) list ] as 'a -> 'b list -> 'd

val find_opt : [> `O of ('b * 'c) list ] as 'a -> 'b list -> 'd option

val map_dict : 
  ([> `Null ] as 'a -> 'b option) ->
  ('c * 'd) list ->
  'e ->
  ('c * 'd) list

val map : 
  ([> `Null | `O of ('b * 'c) list ] as 'a -> 'c option) ->
  'd ->
  'e list ->
  'f

val update : 
  [> `Null | `O of ('b * 'c) list ] as 'a ->
  'b list ->
  'c option ->
  'd

exception Not_utf8

val is_valid_utf8 : string -> bool

val encode_string : 
  string ->
  [> `O of (string * [> `String of string ]) list | `String of string ]

val decode_string : 
  [> `O of (string * [> `String of string ]) list | `String of string ] ->
  string option

val decode_string_exn : value -> string

val of_sexp : 
  Sexplib0.Sexp.t ->
  [> `A of 'a list
  | `O of (string * [> `String of string ]) list
  | `String of string ] as 'a

val value_of_sexp : 
  Sexplib0.Sexp.t ->
  [> `A of 'a list
  | `O of (string * [> `String of string ]) list
  | `String of string ] as 'a

val t_of_sexp : 
  Sexplib0.Sexp.t ->
  [> `A of
       [> `A of 'a
       | `O of (string * [> `String of string ]) list
       | `String of string ]
         list as 'a
  | `O of (string * [> `String of string ]) list ]

val to_sexp : value -> Sexplib0.Sexp.t

val sexp_of_value : value -> Sexplib0.Sexp.t

val sexp_of_t : t -> Sexplib0.Sexp.t

package geojsone