Re: [Yaml-core] Scope for YAML 1.2

[Clark C. E. <cc...@cl...>]

On Sat, Feb 04, 2006 at 02:16:22PM -0600, Andy wrote:
| While we're throwing out our opinions and ideas... I like the !!type
| syntax, but it seems to have limited use when going from one language to
| another, especially with the more complex types.  A simple designation
| of type or class as a "hint" would be useful.

How they type information is used should really be configurable by
the library you use; in a "resolver".  I think one "commendation" 
was just to issue warnings for unknown types; but still load them
as strings/mappings/arrays, etc.

| And what's the standard for how that type information gets stored in
| languages that don't have a place to store metadata about a data
| structure (in perl, you can bless a ref to any string pretty much, and
| store some limited amount of type data in that string without having to
| actually define the class.

I don't know if there is a standard; but you can always use a 'shadow'
mechianism.  You matain a "parallel" array that associates each object
(via the address, or id() in python, etc.) with additional type
information about the object.  

In the Syck library, it defines 3 "YAML Classes", each of which holds
information about type, and even style information.

| It seems there are too many ways to express the same thing.

Well, in this case; JSON is a wonderful option.  Although what JSON
lacks is:

  (a) a mechanism to denote the "type" of a node; and
  (b) an alias mechanism to handle re-occurances of the
      same node within the tree.

Perhaps a good activity would be identifying a simple extension
of JSON that provided _only_ those two features.  We could then
work on making this the "inline" form of YAML, and perhaps even
call it "canonical" (if one could have such a thing).

| At the first intro you have to YAML, it seems really simple, and then as
| you read further and read the spec, it ends up seeming overly complex.

I'd say for any given usage, it's overly complex.  However, if you
take a half-dozen uses that were brought up on the list over the
past few years, it does a nice job with each one.  In most programming
languages there are many ways to write a "loop", depending upon the
particular needs of the loop.  Unlike JSON (one-way-to-do-it), YAML
has taken the opposite approach -- which can be a liability.

| I looked at YAML because I wanted something that could be a common
| serialization method between languages that could be represented using
| the built-in types in the language without having to write a custom
| parser for each document

This seems to be a very important, and emerging use-case that isn't
that compatible with the "human readability" requirement of YAML.

I think a JSON+TYPEs is something we should perhaps work-on; and then
come up with a standard set of types that cross-languages could use.
We worked quite a bit on the type-library for YAML, and the best ways
to encode them into text; perhaps our syntax is too flexible though.
However, it'd be nice if what ever type system did emerge for a 
JSON+TYPEs it would use URIs, and ideally ones that could be easily
written in a friendly-way using YAML type shorthands (see the spec).

Thanks tons for your suggestion Andy!

Best,

Clark