Figuring out where arguments end & values begin

[wreedb]

I'm working on a KDL library for Guile scheme, now that I have the rough basics in place, I'm focused on the specification and ensuring that my parser follows it.

I saw the following example on the specification page

my-node 1 2 \
        3 4

And I've been stumped ever since. I know that a node doesn't need to have a value associated with it; however, when you have something like this, how is it possible to know what is an argument and what could be a value?

my-node 1 2 3 "example" // "example" is the value, and 1 2 3 are the arguments
another-node 1 2 3 4 /* maybe there's no value? maybe 4 is the value, since it's 
                        the last element on that line? */

However I then considered the following:

node "example" a b c { child }

node's value is "example", but it still has arguments a b c, after it.
This means I cannot infer the last element on a line (or in a specific scope)
is the value

[tabatkins]

I'm not sure where you got this distinction between "argument" and "value". Those are the same thing. A node has:

1. A name
2. A (possibly empty) mixed list of attributes (just a value) and/or properties (key and value).
3. A (possibly empty) list of child nodes.

And that's all the constructs that KDL has.

Maybe you got confused with the XML embedding into KDL, where if the XML node just contains text you can encode that as a final string argument on the node rather than needing a child text node?

[wreedb]

Thanks for your reply,

So essentially;
anything that isn't:

• a nodes' name
• a type annotation
• a child block
  Is essentially just a list?

Like:

node foo=bar (u8)1 2 (date)bday="1998-12-09"

could be represented as?

((name . "node")
 (type . #f)
 (args . ((u8 . 1) 2))
 (props . ((foo . "bar")
           (date . (bday . "1998-12-09")))
 (children . ())) 

I figure I could just treat args as a simple list, and props as a list of cons cells; and then when a type annotation is used, that entry would be a cons cell of the (type . val) for args and (type . (key . val)) for properties

[zkat]

It depends on what the data model for your target language is.

The fundamental data model for KDL is a tree of nodes (much like s-ecosystem, but where nodes can further have data associated with them in the form of a single sequence of values (the arguments list), and an associative map of data (properties), and children can only be order nodes.

[tabatkins]

I got the idea of a difference between arguments and values from the fact that they have separate sections in the spec..
It's mentioned that arguments must have their order preserved, and are bare values, which add to the idea of them not being the same thing. I apologize if this was not as obvious to me as it may have been to you.

Ah, I see, that separation in the spec is just because "values" can appear in both attributes and properties. An attribute is just a value; a property is a name + a value. So describing all the types of values separately from their usage in attributes/properties is useful. The description of a "Node" is clear that attributes and properties are the things that a node has.

---

Like [kdl doc] could be represented as? [s-expr equivalents]

That's a reasonable model, sure. Only change I'd probably make is that tags are strings rather than symbols, and always associating the tag with the value in both attributes and properties (rather than wrapping the entire property with the tag).

[zkat]

Yes I would definitely NOT intern anything, since they can all be arbitrary strings and that’s just asking for a CVE

[wreedb]

Right, they dont have to be symbols, I wrote it like since it was less to type on mobile. I think my bases would be covered with this, and would be closer to what my actual implementation of every nodes' data structure

(define (make-kdl-node name type arguments properties children)
  (begin (list (cons 'name       name)       
               (cons 'type       type)
               (cons 'arguments  arguments)
               (cons 'properties properties)
               (cons 'children   children)))) 

(define my-node
  (make-kdl-node
    "my-node" ;; name
    "special" ;; type
    ;; arguments
    (list (list (cons 'value 26)      (cons 'type #f))
          (list (cons 'value "hello") (cons 'type "greeting")))
    ;; properties
    (list (list (cons 'key (list (cons 'value "direction") (cons 'type #f)))
                (cons 'value (list (cons 'value "north") (cons 'type "cardinal")))))
    ;; children
    '())

This would return:

((name . "my-node")
 (type . "special")
 (arguments . (((value . 26)      (type . #f))
               ((value . "hello") (type . "greeting"))))
 (properties . (((key   . ((value . "direction") (type . #f)))
                 (value . ((value . "north")     (type . "cardinal"))))))
 (children . ()))

as a representation of:

(special)my-node 26 (greeting)hello direction=(cardinal)north