New Feature: "Top Level Array"

[christianalfoni]

New Feature: "Top Level Array"

[idream3]

If we implement an array notation for the signals as I saw at one point you @christianalfoni were tossing about then we can just concat ourselves rather than adding more API.

const $actionGroup = [
  action1,
  action2,
  [action3]
];

controller.signal('somethingHappened', [ someAction, anotherAction ].concat($actionGroup));

[christianalfoni]

Haha, that is just brilliant :D

[christianalfoni]

I will keep this open until it is documented ;-)

[christianalfoni]

that reminds me that we should support having an array at "top level" too. So:

controller.signal('somethingHappened', someAction, anotherAction);
// is the same as
controller.signal('somethingHappened', [ someAction, anotherAction ]);

[idream3]

Another feature ticket perhaps :)

[christianalfoni]

Changed this issue instead... though, hm, I think we have to require the top level to be an array. Because:

controller.signal('somethingHappened', [asyncAction]);
controller.signal('somethingHappened', [syncAction].concat(otherActions));

They are not compatible... so yeah, that will break the API. But again, a quick fix and easy to throw error on it.

Cause it have to be:

controller.signal('somethingHappened', [ [asyncAction] ]);
controller.signal('somethingHappened', [syncAction].concat(otherActions));

[idream3]

I see what you mean. Hmm, could start to look messy. I wonder if other people have suggestions...

[christianalfoni]

Yeah, lets keep it open and await more feedback. But signals are most commonly typed like this:

controller.signal('somethingHappened', [ 
  [asyncAction] 
]);

controller.signal('somethingHappened', [
  syncAction
].concat(otherActions));

So it is not that bad ;-)

[idream3]

Ahh yes, the new line provides the visual separation :)

[garth]

If top level actions must be provided as an array then why not accept multiple arrays without the need for concat()?

controller.signal('somethingHappened', [ 
  [asyncAction] 
], otherActionsArray);

controller.signal('somethingHappened', [
  syncAction
], otherActionsArray);

Just need to enforce that all arguments must be arrays.

[christianalfoni]

Jup, that I was also thinking about that. In that scenario it makes sense just to add it as a second argument, but:

controller.signal('somethingHappened', [ 
  [asyncAction, {
    [SUCCESS]: [mySpecialAction].concat(otherSuccessActions)
  }]
], otherActionsArray);

So yeah, lets change to multiple arrays instead of multiple functions as arguments to the signal?

[idream3]

Can we use the ES6 spread operator for this perhaps?

const otherActions = [
   action,
  otherAction
];

controller.signal('somethingHappened', [firstAction, ...otherActions] );

Example above:

controller.signal('somethingHappened', [ 
  [asyncAction, {
    [SUCCESS]: [mySpecialAction, ...otherSuccessActions]
  }],
...otherActionsArray ]);

Second example: http://odetocode.com/blogs/scott/archive/2014/09/02/features-of-es6-part-5-the-spread.aspx

[christianalfoni]

Of course we can, haha, I have not got this new syntax into my intuition system yet ;-)

So we do not need top level array at all, you can use spread for arguments too

controller.signal('somethingHappened', controller.signal('somethingHappened', 
  firstAction, 
  ...otherActions
);

Let me update the other issue with this, and close this one. #46