anil.recoil.org
Yaml encoder/decoder for OCaml jsont codecs
simplify
+105
-162
+105
-162
lib/yamlt.ml
+105
-162
lib/yamlt.ml
···
43
43
44
44
(* Decoder helpers *)
45
45
46
+
(* Local helper to reduce Jsont.Error.msgf boilerplate *)
47
+
let err_msg meta fmt = Jsont.Error.msgf meta fmt
48
+
let err_msg_none fmt = Jsont.Error.msgf Jsont.Meta.none fmt
49
+
46
50
let check_depth d ~nest =
47
51
if nest > d.max_depth then
48
-
Jsont.Error.msgf Jsont.Meta.none "Maximum nesting depth %d exceeded"
49
-
d.max_depth
52
+
err_msg_none "Maximum nesting depth %d exceeded" d.max_depth
50
53
51
54
let check_nodes d =
52
55
d.node_count <- d.node_count + 1;
53
56
if d.node_count > d.max_nodes then
54
-
Jsont.Error.msgf Jsont.Meta.none "Maximum node count %d exceeded"
55
-
d.max_nodes
57
+
err_msg_none "Maximum node count %d exceeded" d.max_nodes
56
58
57
59
let meta_of_span d span =
58
60
if not d.locs then d.meta_none
···
115
117
| Some ev ->
116
118
let span = ev.Event.span in
117
119
let meta = meta_of_span d span in
118
-
Jsont.Error.msgf meta "Expected %s but found %a" name Event.pp
119
-
ev.Event.event
120
-
| None ->
121
-
Jsont.Error.msgf Jsont.Meta.none "Expected %s but reached end of stream"
122
-
name
120
+
err_msg meta "Expected %s but found %a" name Event.pp ev.Event.event
121
+
| None -> err_msg_none "Expected %s but reached end of stream" name
123
122
124
123
(* Error helpers *)
125
124
126
125
let _err_expected_scalar d ev =
127
126
let meta = meta_of_span d ev.Event.span in
128
-
Jsont.Error.msgf meta "Expected scalar but found %a" Event.pp ev.Event.event
127
+
err_msg meta "Expected scalar but found %a" Event.pp ev.Event.event
129
128
130
129
let err_type_mismatch d span t ~fnd =
130
+
let open Jsont.Repr in
131
131
let meta = meta_of_span d span in
132
-
Jsont.Error.msgf meta "Expected %s but found %s" (Jsont.Repr.kinded_sort t)
133
-
fnd
132
+
err_msg meta "Expected %s but found %s" (kinded_sort t) fnd
134
133
135
134
(* YAML scalar resolution *)
136
135
···
215
214
fun d ~nest t ->
216
215
check_depth d ~nest;
217
216
match peek_event d with
218
-
| None -> Jsont.Error.msgf Jsont.Meta.none "Unexpected end of YAML stream"
217
+
| None -> err_msg_none "Unexpected end of YAML stream"
219
218
| Some ev -> (
220
219
match (ev.Event.event, t) with
221
220
(* Scalar events *)
···
248
247
| Event.Mapping_start _, _ -> err_type_mismatch d ev.span t ~fnd:"mapping"
249
248
(* Unexpected events *)
250
249
| Event.Sequence_end, _ ->
251
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected sequence end"
250
+
err_msg (meta_of_span d ev.span) "Unexpected sequence end"
252
251
| Event.Mapping_end, _ ->
253
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected mapping end"
252
+
err_msg (meta_of_span d ev.span) "Unexpected mapping end"
254
253
| Event.Document_start _, _ ->
255
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected document start"
254
+
err_msg (meta_of_span d ev.span) "Unexpected document start"
256
255
| Event.Document_end _, _ ->
257
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected document end"
256
+
err_msg (meta_of_span d ev.span) "Unexpected document end"
258
257
| Event.Stream_start _, _ ->
259
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected stream start"
258
+
err_msg (meta_of_span d ev.span) "Unexpected stream start"
260
259
| Event.Stream_end, _ ->
261
-
Jsont.Error.msgf (meta_of_span d ev.span) "Unexpected stream end")
260
+
err_msg (meta_of_span d ev.span) "Unexpected stream end")
262
261
263
262
and decode_scalar : type a.
264
263
decoder -> nest:int -> Event.spanned -> string -> Scalar_style.t -> a t -> a
···
280
279
a =
281
280
fun d ev value style t map ->
282
281
check_nodes d;
282
+
let meta = meta_of_span d ev.span in
283
+
let type_err fnd = Jsont.Repr.type_error meta t ~fnd in
283
284
(* Determine which decoder to use based on scalar content *)
284
285
if is_null_scalar value then
285
286
match map.dec_null with
286
287
| Some t' -> decode_scalar_as d ev value style t'
287
-
| None ->
288
-
Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.Null
288
+
| None -> type_err Jsont.Sort.Null
289
289
else if style = `Plain then
290
290
(* Try bool, then number, then string *)
291
291
match bool_of_scalar_opt value with
···
295
295
| None -> (
296
296
match map.dec_string with
297
297
| Some t' -> decode_scalar_as d ev value style t'
298
-
| None ->
299
-
Jsont.Repr.type_error (meta_of_span d ev.span) t
300
-
~fnd:Jsont.Sort.Bool))
298
+
| None -> type_err Jsont.Sort.Bool))
301
299
| None -> (
302
300
match float_of_scalar_opt value with
303
301
| Some _ -> (
···
306
304
| None -> (
307
305
match map.dec_string with
308
306
| Some t' -> decode_scalar_as d ev value style t'
309
-
| None ->
310
-
Jsont.Repr.type_error (meta_of_span d ev.span) t
311
-
~fnd:Jsont.Sort.Number))
307
+
| None -> type_err Jsont.Sort.Number))
312
308
| None -> (
313
309
(* Plain scalar that's not bool/number -> string *)
314
310
match map.dec_string with
315
311
| Some t' -> decode_scalar_as d ev value style t'
316
-
| None ->
317
-
Jsont.Repr.type_error (meta_of_span d ev.span) t
318
-
~fnd:Jsont.Sort.String))
312
+
| None -> type_err Jsont.Sort.String))
319
313
else
320
314
(* Quoted scalars are strings *)
321
315
match map.dec_string with
322
316
| Some t' -> decode_scalar_as d ev value style t'
323
-
| None ->
324
-
Jsont.Repr.type_error (meta_of_span d ev.span) t ~fnd:Jsont.Sort.String
317
+
| None -> type_err Jsont.Sort.String
325
318
326
319
and decode_alias : type a. decoder -> Event.spanned -> string -> a t -> a =
327
320
fun d ev anchor t ->
···
329
322
match Hashtbl.find_opt d._anchors anchor with
330
323
| None ->
331
324
let meta = meta_of_span d ev.span in
332
-
Jsont.Error.msgf meta "Unknown anchor: %s" anchor
333
-
| Some json -> (
325
+
err_msg meta "Unknown anchor: %s" anchor
326
+
| Some json_value ->
334
327
(* Decode the stored JSON value through the type *)
335
328
let t' = Jsont.Repr.unsafe_to_t t in
336
-
match Jsont.Json.decode' t' json with
329
+
match Jsont.Json.decode' t' json_value with
337
330
| Ok v -> v
338
-
| Error e -> raise (Jsont.Error e))
331
+
| Error e -> raise (Jsont.Error e)
339
332
340
333
and decode_array : type a elt b.
341
334
decoder -> nest:int -> Event.spanned -> (a, elt, b) array_map -> a =
342
-
fun d ~nest start_ev map ->
335
+
fun d ~nest start_ev array_map ->
343
336
skip_event d;
344
337
(* consume Sequence_start *)
345
338
check_nodes d;
346
339
let meta = meta_of_span d start_ev.span in
347
-
let builder = ref (map.dec_empty ()) in
340
+
let builder = ref (array_map.dec_empty ()) in
348
341
let idx = ref 0 in
349
342
let rec loop () =
350
343
match peek_event d with
351
344
| Some { Event.event = Event.Sequence_end; span } ->
352
345
skip_event d;
353
346
let end_meta = meta_of_span d span in
354
-
map.dec_finish end_meta !idx !builder
347
+
array_map.dec_finish end_meta !idx !builder
355
348
| Some _ ->
356
349
let i = !idx in
357
350
(try
358
-
if map.dec_skip i !builder then begin
351
+
if array_map.dec_skip i !builder then begin
359
352
(* Skip this element by decoding as ignore *)
360
353
let _ : unit =
361
354
decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.ignore)
···
363
356
()
364
357
end
365
358
else begin
366
-
let elt = decode d ~nest:(nest + 1) map.elt in
367
-
builder := map.dec_add i elt !builder
359
+
let elt = decode d ~nest:(nest + 1) array_map.elt in
360
+
builder := array_map.dec_add i elt !builder
368
361
end
369
362
with Jsont.Error e ->
370
-
let imeta = Jsont.Meta.none in
371
-
Jsont.Repr.error_push_array meta map (i, imeta) e);
363
+
Jsont.Repr.error_push_array meta array_map (i, Jsont.Meta.none) e);
372
364
incr idx;
373
365
loop ()
374
-
| None -> Jsont.Error.msgf meta "Unclosed sequence"
366
+
| None -> err_msg meta "Unclosed sequence"
375
367
in
376
368
loop ()
377
369
···
432
424
mem_dec String_map.t ->
433
425
Dict.t ->
434
426
Dict.t =
435
-
fun d ~nest obj_meta map umems mem_miss dict ->
427
+
fun d ~nest obj_meta object_map umems mem_miss dict ->
436
428
let ubuilder =
437
429
ref
438
430
(match umems with
···
446
438
| Some { Event.event = Event.Mapping_end; _ } ->
447
439
skip_event d;
448
440
(* Finalize *)
449
-
finish_object obj_meta map umems !ubuilder !mem_miss !dict
441
+
finish_object obj_meta object_map umems !ubuilder !mem_miss !dict
450
442
| Some ev ->
451
443
(* Expect a scalar key *)
452
444
let name, name_meta = decode_mapping_key d ev in
453
445
(* Look up member decoder *)
454
-
(match String_map.find_opt name map.mem_decs with
446
+
(match String_map.find_opt name object_map.mem_decs with
455
447
| Some (Mem_dec mem) -> (
456
448
mem_miss := String_map.remove name !mem_miss;
457
449
try
458
450
let v = decode d ~nest:(nest + 1) mem.type' in
459
451
dict := Dict.add mem.id v !dict
460
452
with Jsont.Error e ->
461
-
Jsont.Repr.error_push_object obj_meta map (name, name_meta) e)
453
+
Jsont.Repr.error_push_object obj_meta object_map (name, name_meta)
454
+
e)
462
455
| None -> (
463
456
(* Unknown member *)
464
457
match umems with
···
468
461
in
469
462
()
470
463
| Unknown_error ->
471
-
Jsont.Repr.unexpected_mems_error obj_meta map
464
+
Jsont.Repr.unexpected_mems_error obj_meta object_map
472
465
~fnd:[ (name, name_meta) ]
473
466
| Unknown_keep (mmap, _) -> (
474
467
try
475
468
let v = decode d ~nest:(nest + 1) mmap.mems_type in
476
469
ubuilder := mmap.dec_add name_meta name v !ubuilder
477
470
with Jsont.Error e ->
478
-
Jsont.Repr.error_push_object obj_meta map (name, name_meta) e)
479
-
));
471
+
Jsont.Repr.error_push_object obj_meta object_map
472
+
(name, name_meta) e)));
480
473
loop ()
481
-
| None -> Jsont.Error.msgf obj_meta "Unclosed mapping"
474
+
| None -> err_msg obj_meta "Unclosed mapping"
482
475
in
483
476
loop ()
484
477
···
491
484
Dict.t ->
492
485
Dict.t =
493
486
fun meta map umems ubuilder mem_miss dict ->
487
+
let open Jsont.Repr in
494
488
let dict = Dict.add object_meta_arg meta dict in
495
489
let dict =
496
490
match umems with
···
508
502
with Exit ->
509
503
let no_default _ (Mem_dec mm) = Option.is_none mm.dec_absent in
510
504
let exp = String_map.filter no_default mem_miss in
511
-
Jsont.Repr.missing_mems_error meta map ~exp ~fnd:[]
505
+
missing_mems_error meta map ~exp ~fnd:[]
512
506
513
507
and decode_object_cases : type o cases tag.
514
508
decoder ->
···
521
515
(Jsont.name * Jsont.json) list ->
522
516
Dict.t ->
523
517
Dict.t =
524
-
fun d ~nest obj_meta map umems cases mem_miss delayed dict ->
518
+
fun d ~nest obj_meta object_map umems cases mem_miss delayed dict ->
525
519
match peek_event d with
526
520
| Some { Event.event = Event.Mapping_end; _ } -> (
527
521
skip_event d;
528
522
(* No tag found - use dec_absent if available *)
529
523
match cases.tag.dec_absent with
530
524
| Some tag ->
531
-
decode_with_case_tag d ~nest obj_meta map umems cases tag mem_miss
532
-
delayed dict
525
+
decode_with_case_tag d ~nest obj_meta object_map umems cases tag
526
+
mem_miss delayed dict
533
527
| None ->
534
528
(* Missing required case tag *)
535
529
let exp = String_map.singleton cases.tag.name (Mem_dec cases.tag) in
536
530
let fnd = List.map (fun ((n, _), _) -> n) delayed in
537
-
Jsont.Repr.missing_mems_error obj_meta map ~exp ~fnd)
531
+
Jsont.Repr.missing_mems_error obj_meta object_map ~exp ~fnd)
538
532
| Some ev ->
539
533
let name, name_meta = decode_mapping_key d ev in
540
534
if String.equal name cases.tag.name then begin
541
535
(* Found the case tag *)
542
536
let tag = decode d ~nest:(nest + 1) cases.tag.type' in
543
-
decode_with_case_tag d ~nest obj_meta map umems cases tag mem_miss
544
-
delayed dict
537
+
decode_with_case_tag d ~nest obj_meta object_map umems cases tag
538
+
mem_miss delayed dict
545
539
end
546
540
else begin
547
541
(* Not the case tag - check if known member or delay *)
548
-
match String_map.find_opt name map.mem_decs with
542
+
match String_map.find_opt name object_map.mem_decs with
549
543
| Some (Mem_dec mem) -> (
550
544
let mem_miss = String_map.remove name mem_miss in
551
545
try
552
546
let v = decode d ~nest:(nest + 1) mem.type' in
553
547
let dict = Dict.add mem.id v dict in
554
-
decode_object_cases d ~nest obj_meta map umems cases mem_miss
555
-
delayed dict
548
+
decode_object_cases d ~nest obj_meta object_map umems cases
549
+
mem_miss delayed dict
556
550
with Jsont.Error e ->
557
-
Jsont.Repr.error_push_object obj_meta map (name, name_meta) e)
551
+
Jsont.Repr.error_push_object obj_meta object_map (name, name_meta)
552
+
e)
558
553
| None ->
559
554
(* Unknown member - decode as generic JSON and delay *)
560
-
let v = decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.json) in
555
+
let v =
556
+
decode d ~nest:(nest + 1) (Jsont.Repr.of_t Jsont.json)
557
+
in
561
558
let delayed = ((name, name_meta), v) :: delayed in
562
-
decode_object_cases d ~nest obj_meta map umems cases mem_miss
563
-
delayed dict
559
+
decode_object_cases d ~nest obj_meta object_map umems cases
560
+
mem_miss delayed dict
564
561
end
565
-
| None -> Jsont.Error.msgf obj_meta "Unclosed mapping"
562
+
| None -> err_msg obj_meta "Unclosed mapping"
566
563
567
564
and decode_with_case_tag : type o cases tag.
568
565
decoder ->
···
577
574
Dict.t ->
578
575
Dict.t =
579
576
fun d ~nest obj_meta map umems cases tag mem_miss delayed dict ->
577
+
let open Jsont.Repr in
580
578
let eq_tag (Case c) = cases.tag_compare c.tag tag = 0 in
581
579
match List.find_opt eq_tag cases.cases with
582
-
| None -> Jsont.Repr.unexpected_case_tag_error obj_meta map cases tag
580
+
| None -> unexpected_case_tag_error obj_meta map cases tag
583
581
| Some (Case case) ->
584
582
(* Continue decoding with the case's object map *)
585
583
let case_dict =
···
605
603
let mem_miss = String_map.union u mem_miss case_map.mem_decs in
606
604
let dict, mem_miss =
607
605
List.fold_left
608
-
(fun (dict, mem_miss) ((name, meta), json) ->
606
+
(fun (dict, mem_miss) ((name, meta), json_value) ->
609
607
match String_map.find_opt name case_map.mem_decs with
610
608
| Some (Mem_dec mem) -> (
611
609
let t' = Jsont.Repr.unsafe_to_t mem.type' in
612
-
match Jsont.Json.decode' t' json with
610
+
match Jsont.Json.decode' t' json_value with
613
611
| Ok v ->
614
612
let dict = Dict.add mem.id v dict in
615
613
let mem_miss = String_map.remove name mem_miss in
···
646
644
(value, meta)
647
645
| _ ->
648
646
let meta = meta_of_span d ev.span in
649
-
Jsont.Error.msgf meta "Mapping keys must be scalars (strings), found %a"
650
-
Event.pp ev.event
647
+
err_msg meta "Mapping keys must be scalars (strings), found %a" Event.pp
648
+
ev.event
651
649
652
650
(* Skip stream/document wrappers *)
653
651
let skip_to_content d =
···
675
673
| None -> ()
676
674
| Some ev ->
677
675
let meta = meta_of_span d ev.span in
678
-
Jsont.Error.msgf meta "Expected end of document but found %a" Event.pp
679
-
ev.event
676
+
err_msg meta "Expected end of document but found %a" Event.pp ev.event
680
677
in
681
678
loop ()
682
679
···
730
727
| Error.Yamlrw_error err ->
731
728
skip_to_document_end d;
732
729
let msg = Error.to_string err in
733
-
let e =
734
-
Jsont.Error.make_msg Jsont.Error.Context.empty Jsont.Meta.none msg
735
-
in
730
+
let e = Jsont.(Error.make_msg Error.Context.empty Meta.none msg) in
736
731
Seq.Cons (Error e, next_doc))
737
732
in
738
733
next_doc
···
754
749
| Jsont.Error e -> Error e
755
750
| Error.Yamlrw_error err ->
756
751
let msg = Error.to_string err in
757
-
Error (Jsont.Error.make_msg Jsont.Error.Context.empty Jsont.Meta.none msg)
752
+
Error Jsont.(Error.make_msg Error.Context.empty Meta.none msg)
758
753
759
754
let decode ?layout ?locs ?file ?max_depth ?max_nodes t reader =
760
755
Result.map_error Jsont.Error.to_string
···
785
780
else if String.contains s '\n' then `Literal
786
781
else if String.length s > 80 then `Folded
787
782
else `Plain
783
+
784
+
(* Helper to create scalar events with common defaults *)
785
+
let scalar_event ?(anchor = None) ?(tag = None) ~value ~style () =
786
+
Event.Scalar
787
+
{
788
+
anchor;
789
+
tag;
790
+
value;
791
+
plain_implicit = true;
792
+
quoted_implicit = true;
793
+
style;
794
+
}
795
+
796
+
(* Helper to emit events *)
797
+
let emit e = Emitter.emit e.emitter
788
798
789
799
(* Encode null *)
790
-
let encode_null e _meta =
791
-
Emitter.emit e.emitter
792
-
(Event.Scalar
793
-
{
794
-
anchor = None;
795
-
tag = None;
796
-
value = "null";
797
-
plain_implicit = true;
798
-
quoted_implicit = true;
799
-
style = `Plain;
800
-
})
800
+
let encode_null e _meta = emit e (scalar_event ~value:"null" ~style:`Plain ())
801
801
802
802
(* Encode boolean *)
803
803
let encode_bool e _meta b =
804
-
Emitter.emit e.emitter
805
-
(Event.Scalar
806
-
{
807
-
anchor = None;
808
-
tag = None;
809
-
value = (if b then "true" else "false");
810
-
plain_implicit = true;
811
-
quoted_implicit = true;
812
-
style = `Plain;
813
-
})
804
+
emit e (scalar_event ~value:(if b then "true" else "false") ~style:`Plain ())
814
805
815
806
(* Encode number *)
816
807
let encode_number e _meta f =
···
822
813
if Float.is_integer f && Float.abs f < 1e15 then Printf.sprintf "%.0f" f
823
814
else Printf.sprintf "%g" f
824
815
in
825
-
Emitter.emit e.emitter
826
-
(Event.Scalar
827
-
{
828
-
anchor = None;
829
-
tag = None;
830
-
value;
831
-
plain_implicit = true;
832
-
quoted_implicit = true;
833
-
style = `Plain;
834
-
})
816
+
emit e (scalar_event ~value ~style:`Plain ())
835
817
836
818
(* Encode string *)
837
819
let encode_string e _meta s =
838
820
let style = choose_scalar_style ~preferred:e.scalar_style s in
839
-
Emitter.emit e.emitter
840
-
(Event.Scalar
841
-
{
842
-
anchor = None;
843
-
tag = None;
844
-
value = s;
845
-
plain_implicit = true;
846
-
quoted_implicit = true;
847
-
style;
848
-
})
821
+
emit e (scalar_event ~value:s ~style ())
849
822
850
823
let rec encode : type a. encoder -> a t -> a -> unit =
851
824
fun e t v ->
···
877
850
and encode_array : type a elt b. encoder -> (a, elt, b) array_map -> a -> unit =
878
851
fun e map v ->
879
852
let style = layout_style_of_format e.format in
880
-
Emitter.emit e.emitter
853
+
emit e
881
854
(Event.Sequence_start { anchor = None; tag = None; implicit = true; style });
882
855
let _ =
883
856
map.enc
···
886
859
())
887
860
() v
888
861
in
889
-
Emitter.emit e.emitter Event.Sequence_end
862
+
emit e Event.Sequence_end
890
863
891
864
and encode_object : type o. encoder -> (o, o) object_map -> o -> unit =
892
865
fun e map v ->
893
866
let style = layout_style_of_format e.format in
894
-
Emitter.emit e.emitter
895
-
(Event.Mapping_start { anchor = None; tag = None; implicit = true; style });
867
+
emit e (Event.Mapping_start { anchor = None; tag = None; implicit = true; style });
896
868
(* Encode each member *)
897
869
List.iter
898
870
(fun (Mem_enc mem) ->
899
871
let mem_v = mem.enc v in
900
872
if not (mem.enc_omit mem_v) then begin
901
873
(* Emit key *)
902
-
Emitter.emit e.emitter
903
-
(Event.Scalar
904
-
{
905
-
anchor = None;
906
-
tag = None;
907
-
value = mem.name;
908
-
plain_implicit = true;
909
-
quoted_implicit = true;
910
-
style = `Plain;
911
-
});
874
+
emit e (scalar_event ~value:mem.name ~style:`Plain ());
912
875
(* Emit value *)
913
876
encode e mem.type' mem_v
914
877
end)
···
920
883
let (Case_value (case_map, case_v)) = cases.enc_case (cases.enc v) in
921
884
(* Emit case tag *)
922
885
if not (cases.tag.enc_omit case_map.tag) then begin
923
-
Emitter.emit e.emitter
924
-
(Event.Scalar
925
-
{
926
-
anchor = None;
927
-
tag = None;
928
-
value = cases.tag.name;
929
-
plain_implicit = true;
930
-
quoted_implicit = true;
931
-
style = `Plain;
932
-
});
886
+
emit e (scalar_event ~value:cases.tag.name ~style:`Plain ());
933
887
encode e cases.tag.type' case_map.tag
934
888
end;
935
889
(* Emit case members *)
···
937
891
(fun (Mem_enc mem) ->
938
892
let mem_v = mem.enc case_v in
939
893
if not (mem.enc_omit mem_v) then begin
940
-
Emitter.emit e.emitter
941
-
(Event.Scalar
942
-
{
943
-
anchor = None;
944
-
tag = None;
945
-
value = mem.name;
946
-
plain_implicit = true;
947
-
quoted_implicit = true;
948
-
style = `Plain;
949
-
});
894
+
emit e (scalar_event ~value:mem.name ~style:`Plain ());
950
895
encode e mem.type' mem_v
951
896
end)
952
897
case_map.object_map.mem_encs);
953
-
Emitter.emit e.emitter Event.Mapping_end
898
+
emit e Event.Mapping_end
954
899
955
900
(* Public encode API *)
956
901
···
965
910
let emitter = Emitter.of_writer ~config writer in
966
911
let e = make_encoder ?format ?indent ?explicit_doc ?scalar_style emitter in
967
912
try
968
-
Emitter.emit e.emitter (Event.Stream_start { encoding = `Utf8 });
969
-
Emitter.emit e.emitter
970
-
(Event.Document_start { version = None; implicit = not e.explicit_doc });
913
+
emit e (Event.Stream_start { encoding = `Utf8 });
914
+
emit e (Event.Document_start { version = None; implicit = not e.explicit_doc });
971
915
let t' = Jsont.Repr.of_t t in
972
916
encode e t' v;
973
-
Emitter.emit e.emitter
974
-
(Event.Document_end { implicit = not e.explicit_doc });
975
-
Emitter.emit e.emitter Event.Stream_end;
917
+
emit e (Event.Document_end { implicit = not e.explicit_doc });
918
+
emit e Event.Stream_end;
976
919
if eod then Emitter.flush e.emitter;
977
920
Ok ()
978
921
with
979
922
| Jsont.Error err -> Error err
980
923
| Error.Yamlrw_error err ->
981
924
let msg = Error.to_string err in
982
-
Error (Jsont.Error.make_msg Jsont.Error.Context.empty Jsont.Meta.none msg)
925
+
Error Jsont.(Error.make_msg Error.Context.empty Meta.none msg)
983
926
984
927
let encode ?buf ?format ?indent ?explicit_doc ?scalar_style t v ~eod writer =
985
928
Result.map_error Jsont.Error.to_string