Named parameters object?

[jwulf]

What about making the function parameters a named object?

So instead of:

conn.query("db-name", 
   "select distinct * where { ?s ?p ?o } limit 5", 
   null, 5, 0, function (data) {});

you get:

conn.query('db-name', {query: 'select distinct * where { ?s ?p ?o} limit 5',
   baseURI: null,
   limit: 5,
   offset: 0}, function cb(data){});

which is self-documenting, and collapses to:

conn.query('db-name', {query: 'select distinct * where { ?s ?p ?o} limit 5',
                  limit: 5}, function cb(data){});

since baseURI and offset are not required, they don't need to be set.

Code samples can look like this:

var query = {},
      query.query = "select distinct * where { ?s ?p ?o} limit 5",
      query.limit = 5;

conn.query("db-name", query, function cb(data) {});

[edgarRd]

I like this idea, although since this means changing the API it'll break some code, but probably we're in the right time to do it.

[jwulf]

I was thinking about that last night.

You could maintain backward compatibility, if you wanted to, by doing function signature overloading. I've seen it done in Javascript like this:

Connection.prototype.query(database, query, baseURI, limit, offset, cb) {
  var arg = query;
  if (typeof arg == 'object')
    {
        query = arg.query;
        if (typeof baseURI == 'function') cb = baseURI;
        baseURI = arg.baseURI;
        limit = arg.limit;
        offset = arg.offset;
   }

So the function now has two signatures:

query(database: string; query: string; baseURI: 
          string; limit: integer; offset: integer; cb: function)

query(database: string; query: queryObject; cb: function)

One would be the documented signature, the other one would be for backward-compatibility.