Convert yaml -> json in Racket - json

Question

I was looking to convert some yaml documents to json using Racket and the yaml and json libraries. Both seem to work very well, but don't necessarily work well together. At the risk of this question being a little meta (I am interested in an idiomatic solution), can someone point me in the right direction?
Example yaml:
Title: Example
Description: An example
Content:
Type1:
- foo
- bar
- baz
Type2:
- chocolate
- vanilla
- strawberry
My quick attempt at converting a yaml:
#lang racket/base
(require json
yaml)
; reading is easy
(define example-yaml (file->yaml "./example.yaml"))
; writing doesn't like the keys-as-strings... why not?
; (write-json example-yaml)
; write-json: expected argument of type <legal JSON key value>; given: "Description"
; keys-as-symbols seems to be fine
(define example-yaml-2
#hash((Content
.
#hash((Type1 . ("foo" "bar" "baz"))
(Type2 . ("chocolate" "vanilla" "strawberry"))))
(Description . "An example")
(Title . "Example")))
(write-json example-yaml-2)
; {"Content":{"Type2":["chocolate","vanilla","strawberry"],"Type1":["foo","bar","baz"]},"Description":"An example","Title":"Example"}
I gather that the issue is that the json package doesn't see strings as a valid key in a jsexpr. The docs give the following example:
> (jsexpr? #hasheq(("turnip" . 82)))
#f
From where I sit the options seem to be:
Change the behavior of the yaml package to emit keys as symbols rather than as strings
Change the behavior of the json package to treat (jsexpr? #hasheq(("turnip" . 82))) as #t
Parse my yamls, then munge the resulting data structure such that keys are symbols.
I guess I don't entirely understand the implications (or have a solid handle on the implementation) of these options. I also am not entirely sure why keys as strings aren't valid jsexprs, given that the json it emits uses strings as keys as well. Thank you for any insight you can provide!

Answer 1

For method 3, just changing hash-table keys from strings to symbols might not be enough. It depends on how much you know about the format of your data.
For example the yaml package allows all sorts of things as "keys", not just strings but also binary data, numbers, hash-maps, or any other Yaml objects (keys may be arbitrary nodes).
So you must either:
Know beforehand that all keys in all of your Yaml data are simple strings,
Or be able to sanely convert any arbitrary Yaml value into a symbol,
Or convert Yaml maps into some Json structure other than a Json map.
For now I'm going to assume (1), that you know beforehand that all keys are strings.
;; yaml-key->symbol
;; In my Yaml data, I know beforehand that all keys are strings
(define (yaml-key->symbol key)
(cond
[(string? key) (string->symbol key)]
[else
(error 'yaml-key->symbol
"expected all Yaml keys to be strings, but got: ~v"
key)]))
There are other potential mismatches between Yaml and Json that you might have to consider.
How do you convert yaml byte-strings? As lists of bytes? Hex strings?
How do you convert yaml sets? As lists?
How do you convert yaml timestamps / dates? As Json maps mapping fields to numbers? Date strings? Number of seconds since the unix epoch?
For each of these questions, make a decision and document it. Or if you know ahead of time that your Yaml data definitely doesn't include any of these, document that too, and validate with an error similar to yaml-key->symbol above.
Once you know how to convert everything you might see in your data, you can traverse the Yaml recursively and convert it to Json.