go-yaml | YAML support for the Go language | YAML Processing library

The conda run function provides a clean way to run code within an environment context without having to manually activate. Try something like

You can do this by implementing a custom UnmarshalYAML func. However, with the v2 version of the API, you would basically do the same thing as you do now and just encapsulate it a bit better.

If you switch to using the v3 API however, you get a better UnmarshalYAML that actually lets you work on the parsed YAML node before it is processed into a native Go type. Here's how that looks:

Finally, I found the solution. Because Hyperledger Fabric already exported module named fabric-config@v0.0.9, we can use this module to create and generate config block. It was pretty upset that they don't tell us in document. Lucky for me when I saw the module and tried.

go-yaml has a rather minimal interface, as it is typical for Go packages. Since the lowest possible structure you can access (via Marshaler / Unmarshaler interface) is yaml.Node, it is not possible to implement round-tripping with it, without changing go-yaml itself (just like ruamel is a fork of PyYAML).

For proper round tripping, you need:

• Preservation of comments and whitespace. This needs to happen at the lexer level, a level very few YAML implementations cover externally (libyaml is the only one I know that does it, but you can't feed lexer tokens back into it so it's basically useless for that purpose)
• Preservation of scalar presentation. This is the hardest to get right since quoted scalars allow you to escape any unicode character and if you only have the resulting string, you cannot know the original presentation. I think not even ruamel is able to reproduce scalar representation. Scalar representation also includes where line breaks are in a folded scalar, chomping and indentation indicators, none of which are exposed in go-yaml.
• Preservation of anchors & aliases. go-yaml actually lets you access this with Node.Anchor however you need to figure out which was the first node that has the anchors, and which are the others that were originally aliases. This is difficult because…
• Preservation of key order. YAML defines that the order of keys in a mapping must not convey content information. Typically, mappings are loaded in a hashmap which loses this information (as is the case with Go's map). However, Node does provide the original order of child items, so this is doable in go-yaml.
• Preservation of document header & footer. YAML allows directives before a document (%YAML and %TAG) and also allows documents to end with multiple ... lines (and comments in between). This information is not available with go-yaml.

Since round-tripping goes against the YAML spec if interpreted strictly (because it disallows presentation details to have any impact on the processing), it is usually not part of a YAML implementation and afaik ruamel is the only implementation that attempts to do it.

So the answer is: Of course it's possible to do it in Go, but you need to implement it yourself, possibly by forking go-yaml. Since parsing YAML is very complicated by itself (see here, not one implementation gets it completely right), a proper YAML round-tripping implementation the covers all edge cases will be very complex to write and I strongly advise against it.

Your types are wrong, Go doesn't have inheritance. You cannot store a value of type *Mercedes or *BMW into an array of type []*Car; both types just include a Car value as a mixin. To do what you want to do, you have to change your Car type into an interface.

Now for the YAML part: You can store a part of your YAML structure inside an object of type yaml.Node and deserialize that later. You can implement a custom unmarshaler by implementing UnmarshalYAML (from the yaml.Unmarshaler interface). So what we're gonna do is to implement a custom unmarshaler for CarShop that deserializes the surrounding structure into a list containing mappings from car type to yaml.Node (the values for that type), and then depending on the given car types, deserialize each node into the proper type. Here's how it looks: