A few more notes on ordered mappings, now that I've re-reviewed the issue in detail:  As I sort of recalled, this is one of the few issues where I found the YAML spec somewhat underspecified and in conflict with itself.  I think that the "omap" feature was tacked on later, but the spec wasn't fully updated to reflect its addition.

The issue here is there is an official tag called `omap` in YAML.  It does not have a special, distinct serialization format.  Rather it is usually represented as a sequence of single-key mappings, like:

```
- a: foo
- b: bar
```

which might translate in Python to:

```
[{'a': 'foo'}, {'b': 'bar'}]
```

that is, a list of single-element dicts.  The `omap` tag makes explicit that this data structure should be interpreted like an ordered-dict.  Custom tags (including most that I came up with for the initial FINF prototype) could also explicitly state that it should be interpreted as an ordered mapping in this way.  That's all fine, I think.

Where the conflict comes in is that the YAML Spec makes several declarations along the lines of "native data structures are constructed only from information available in the representation.  In particular, **mapping key order**, comments, and tag handles should not be referenced during composition."

In other words, it's saying that the order of mapping keys is only relevant to the serialization stage and should not be used when constructing native objects.  I think this is wrong, since an ordered mapping *is* a useful data structure (regardless of how well supported it is by a given programming language), and so that at least for `omap` structures it is information that should be used in object construction.

My feeling (and I might contact the authors to get clarification on this), is that it was used as an *example* of the sort of thing that should not be used in object construction but before the `omap` tag was added.  At that point I think it should have been removed as such an example.

In my prototype (which I believe you've carried over into pyfinf) I got around this by overriding the "constructor" phase to recognize this sort of data structure and go ahead and construct Python OrderedDicts.  Technically this is in some sense violating the recommendation of the YAML Spec, but it's too useful not to and is effectively harmless.