RE: [Yaml-core] Quoting rules

[Oren Ben-K. <or...@ri...>]

Dave Long wrote:
> Arguing from the basis of the native
> types of current scripting languages
> seems to miss the point that dates,
> times, and currency amounts are all
> human native types.  (otherwise why
> would localization be so important?)

I'd call them "domain-specific" types, but you are basically right.

> Is it unreasonable to wish that type
> metadata stay "meta", so applications
> which don't instantiate objects can
> still easily parse and produce YAML,
> to interoperate with those which do?

It is very reasonable. And in fact it is OK for you to do so for "unknown
implicit types" - as long as you round trip them properly.

> (In other words -- is it difficult
> to ensure that parsing YAML and type
> assignment are logically separated?)

They are. At some parsing level, you just say "here's some value, it should
be an implicit type. I'll ask my type library about it". This "type library"
is completely divorced from the actual parsing.

Also, there's no requirement for your application to handle types it isn't
interested in. The minimum required is !str, !seq and !map - that's all. If
your application doesn't have any dates - don't do dates.

In general there are two types of applications. One that is schema-specific.
The schema may be very wide (e.g., "serializing Java classes") or very
narrow ("my schema for data about penguins").

A schema-specific system can happily ignore types outside the schema (in
your case, dates). They just don't exist for it. No fuss, no cost. An
example would be a Java de/serialization code or a penguin statistics tool.

A schema-independent system should just sigh when it sees an "unknown type"
and round-trip it. This is rather easy, especially in the case of an unknown
implicit type. Just store it as a string, internally, and be certain to emit
it in the same way you have scanned it. That's all. It is trickier for
unknown explicit types - you have to remember the transfer method together
with the value. Again, no big deal. An example of a schema-independent
system would be a YAML pretty-printer, or a hub routing YAML messages, etc.

The reasoning behind having some domain-specific types in the spec is that
the relevant domain is very wide. Dates, for example, appear in config
files, financial records, databases, log files, and so on. So we figured
they are important enough to *mention* in the spec (not require).

We may, *if* the need arises, define additional "widely used" types later
on, based on feedback from actual use of YAML. We just felt that date is
"obviously" very useful.

Hope this helps,

    Oren Ben-Kiki