bigeasy / cadence Goto Github PK

If the first argument is null, we can flatten. When you implement this, remove apply from Proof lib/proof.js.

Find a simple way to pass in a parameter from a calling function. Current thought is that the cadence function is the partition like --.

Ask questions here.

Causing confusion. Actually, the underbar is going to clash with streamline. Maybe $0()?

This library is ready to go once I extract it from Proof.

It gets called and if there's a problem you rethrow.

Create a test case that implements the Proof context preparation use case.

Allow the caller to specify a base context object. See #23.

By default, sub-cadences should run in parallel.

Calls to sub-cadences get a scope that can be overridden.

Create an ephemeral map to store variables whose names begin with $.

Create a CHANGELOG.

When many callbacks are pending, many callbacks may error.

I say yes.

list.forEach(function (file) { 
  file = path.resolve(directory, file);
  async(function () { 

    fs.stat(file, async());

  }, function (stat) { 

    if (stat.isDirectory()) { 
      tree.push(file);
      async(directory)(null);
    } else { 
      fs.readFile(file, 'utf8', async());
    } 

  }, function (body) { 

    if (/proof/.test(body)) count++;

  });
});

An integer means that the next function will have its argument list truncated to the length specified by the integer.

A cadence should be able to return values. Perhaps the last value returned from the last cadence executed?

I've got them transposed for the most part.

Necessary to keep from introducing a strange work into Proof.

If a cadence has a catch step and no exception is thrown, the callbacks are lost.

Don't make it a bootstrap function since Cadence can bootstrap anyway.

Instead of assigning a function to a variable in scope, the function is added by its name to the context. Added benefit of not adding the function to the global scope. Need to test this on Internet Explorer.

Return a function that is either run with or without a callback. Without a callback, on exception we throw. With a callback, on exception we call the callback. The callback can accept a return value.

Why are they flattened? Means you cannot use async to return an array early.

Allow early exit by calling cadence directory with an Error as the only argument, or null as the first argument.

Instead of requiring an exception, we can decide that the default it to throw.

In fact, why not return a function, then if you call that function without arguments, it specifies it's own exception handler?

When someone creates multiple callbacks with the cadence function, gather the results into array results for the context.

The test for building a cadence generator function with an application specified base context is broken.

We were going to do without extending the cadence hash with a return value, but the code is still there and it is breaking Proof.

When a cadence parameter is found in a step function, it is never interpreted as a cadence context assignment. It any arguments in the position of the cadence argument or thereafter are ignored.

Unable to infer arguments for a function that has no arguments, when the async functions are invoked without arguments.

The default exception handler always throws an error, even when error is null.

The first README.md example was cut and paste from a test. The callback() it refers to is not defined in the snippet.

Copy the sizes utility from Timezone.

If the first argument is an object, use that as the context, or else inspect it for additional options?

Like cleaup in Proof.

Allow a plain old callback as a parameter, named callback or _.

Merge an object into the current context.

Ignore cadence if it is the first argument.

Loops parallel and serial:

cadence(function (cadence) {

  records = [];

  cadence(function () {
    new Array(length - offset).forEach(function (x, i) {
      cadence(function () {
        cursor.get(i, callback("got"));
      }, function (got) {
        records[i] = got;
      });
    });
  });

  cadence(function () { 
    var i = offset;
    cadence(new Array(10), function each (item, index) {
      cursor.get(i, callback());
    }, function (got) {
      records[i] = got;
    }, function () {
      cadence(loop);
    });
  });

}, callback);

Run unit tests successfully on Windows.

Sorting out how to invoke parameters. Previously thought that anything after cadence would be variable arguments, but that is going to break Proof, because users of Proof won't know that async is special. The will list async followed by ok, equal and ok and equal are treated as parameters.

My new thought is that we stick with leading arguments always. We do not treat cadence as special. Then we create a special syntax for splats. A function parameters named $splat will mean the end of the argument list, and absorb any extra arguments. The $ indicates that it will not be stored in the cadence context. A parameter named $splat$1 means that all arguments will be absorbed by the splat except for one last one which will be assigned to the next variable.

This way, if someone say ok, equal, async in proof, ok and equal will not be assigned, because there are no values passed into the function. Calling from the outside, you might always want to lead with splat, or have it there, to protect your cadence, but then, cadence will always be cadence, so we might know that cadence means end of arguments. In any case, within the cadence, the cadence context is in the control of the cadence author, so they simply have to avoid collisions.

Pass the arguments onto the next step, but stash their names.

Have points like async and the program invocation itself be places where you can step over to step back out.