Swap argument order in reduce

Closes #33

Author: matthewpblog

demos/counter.js

@@ -3,11 +3,11 @@ import { state, transition, createMachine, guard, interpret, reduce } from './ma
 const machine = createMachine({
   idle: state(
     transition('inc', 'idle',
-      reduce((e, {count}) => ({ count: count + 1 })),
+      reduce(({count}) => ({ count: count + 1 })),
       guard(({count}) => count < 10)
     ),
     transition('dec', 'idle',
-      reduce((e, {count}) => ({ count: count - 1 })),
+      reduce(({count}) => ({ count: count - 1 })),
       guard(({count}) => count > 0)
     )
   )

demos/fullname.js

@@ -1,7 +1,7 @@
 import { guard, state, transition, createMachine, interpret, reduce } from './machine.js';
 
-const setFirst = (ev, ctx) => ({ ...ctx, first: ev.target.value });
-const setLast = (ev, ctx) => ({ ...ctx, last: ev.target.value });
+const setFirst = (ctx, ev) => ({ ...ctx, first: ev.target.value });
+const setLast = (ctx, ev) => ({ ...ctx, last: ev.target.value });
 const nothingEntered = ({ first, last }) => !first && !last;
 const somethingEntered = (ctx) => !nothingEntered(ctx);
 

demos/login.js

@@ -9,7 +9,7 @@ function canSubmit(ctx) {
   return !!(ctx.login && ctx.password);
 }
 
-function updateSubmissionError(ev, ctx) {
+function updateSubmissionError(ctx) {
   return {
     ...ctx,
     error: 'Missing fields'
@@ -20,18 +20,18 @@ function hasError(ctx) {
   return !!ctx.error;
 }
 
-function clearError(ev, ctx) {
+function clearError(ctx) {
   return { ...ctx, error: '' };
 }
 
-function setLogin({ event }, ctx) {
+function setLogin(ctx, { event }) {
   return {
     ...ctx,
     login: event.target.value
   };
 }
 
-function setPassword({ event }, ctx) {
+function setPassword(ctx, { event }) {
   return {
     ...ctx,
     password: event.target.value

demos/users.js

@@ -21,7 +21,7 @@ const machine = createMachine({
   ),
   loading: invoke(loadUsers,
     transition('done', 'loaded',
-      reduce((ev, ctx) => ({ ...ctx, users: ev.data }))
+      reduce((ctx, ev) => ({ ...ctx, users: ev.data }))
     )
   ),
   loaded: state()

docs/api/invoke.md

@@ -30,10 +30,10 @@ const machine = createMachine({
   ),
   loading: invoke(loadUsers,
     transition('done', 'idle',
-      reduce((ev, ctx) => ({ ...ctx, user: ev.data }))
+      reduce((ctx, ev) => ({ ...ctx, user: ev.data }))
     ),
     transition('error', 'error',
-      reduce((ev, ctx) => ({ ...ctx, error: ev.error }))
+      reduce((ctx, ev) => ({ ...ctx, error: ev.error }))
     )
   ),
   error: state()
@@ -80,7 +80,7 @@ const inputMachine = createMachine({
 const wizardMachine = createMachine({
   step1: invoke(inputMachine,
     transition('done', 'step2',
-      reduce((ev, ctx) => ({ ...ctx, childContext: ev.data }))
+      reduce((ctx, ev) => ({ ...ctx, childContext: ev.data }))
     )
   ),
   step2: state() // Machine another machine here?
@@ -126,7 +126,7 @@ import { createMachine, invoke, reduce, state, transition } from 'robot3';
 const machine = createMachine({
   start: invoke(loadTodos,
     transition('done', 'loaded',
-      reduce((ev, ctx) => ({ ...ctx, todo: ev.data }))
+      reduce((ctx, ev) => ({ ...ctx, todo: ev.data }))
     )
   ),
   loaded: state()
@@ -156,7 +156,7 @@ const loadTodos = () => Promise.reject("Sorry but you can't do that");
 const machine = createMachine({
   start: invoke(loadTodos,
     transition('error', 'error',
-      reduce((ev, ctx) => ({ ...ctx, error: ev.error }))
+      reduce((ctx, ev) => ({ ...ctx, error: ev.error }))
     )
   ),
   error: state()

docs/api/reduce.md

@@ -17,10 +17,10 @@ import { createMachine, reduce, state, transition } from 'robot3';
 const machine = createMachine({
   idle: state(
     transition('login', 'idle',
-      reduce((ev, ctx) => ({ ...ctx, login: ev.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, login: ev.target.value }))
     ),
     transition('password', 'idle',
-      reduce((ev, ctx) => ({ ...ctx, password: ev.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, password: ev.target.value }))
     ),
     transition('submit', 'complete')
   ),

docs/api/state.md

@@ -22,7 +22,7 @@ const machine = createMachine({
 
   input: state(
     immediate('idle',
-      reduce((ev, ctx) => ({ ...ctx, first: ev.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, first: ev.target.value }))
     )
   )
 });

docs/api/transition.md

@@ -38,7 +38,7 @@ const machine = createMachine({
   )
   loading: invoke(loadUsers,
     transition('done', 'show',
-      reduce((ev, ctx) => ({ ...ctx, users: ev.data })))
+      reduce((ctx, ev) => ({ ...ctx, users: ev.data })))
   )
 }, () => ({ users: [] }));
 ```

docs/guides/comparison-with-xstate.md

@@ -99,7 +99,7 @@ import { createMachine, reduce, state, transition } from 'robot3';
 const machine = createMachine({
   idle: state(
     transition('inc', 'idle',
-      reduce((ev, ctx) => ({ ...ctx, count: ctx.count + 1 }))
+      reduce(ctx => ({ ...ctx, count: ctx.count + 1 }))
     )
   )
 });

docs/guides/composition.md

@@ -15,10 +15,10 @@ import { createMachine, state, reduce, transition } from 'robot3';
 const machine = createMachine(
   form: state(
     transition('first', 'form',
-      reduce((ev, ctx) => ({ ...ctx, first: ev.event.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, first: ev.event.target.value }))
     ),
     transition('last', 'form',
-      reduce((ev, ctx) => ({ ...ctx, first: ev.event.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, first: ev.event.target.value }))
     )
   )
 );
@@ -37,7 +37,7 @@ import { createMachine, state, reduce, transition } from 'robot3';
 
 const field = (prop, state) => (
   transition(prop, state,
-    reduce((ev, ctx) => ({ ...ctx, [prop]: ev.event.target.value }))
+    reduce((ctx, ev) => ({ ...ctx, [prop]: ev.event.target.value }))
   )
 );
 
@@ -58,7 +58,7 @@ __transitions.js__
 ```js
 export const field = (prop, state) => (
   transition(prop, state,
-    reduce((ev, ctx) => ({ ...ctx, [prop]: ev.event.target.value }))
+    reduce((ctx, ev) => ({ ...ctx, [prop]: ev.event.target.value }))
   )
 );
 
@@ -84,7 +84,7 @@ You might find that you need a *slight* modification to how one of the transitio
 ```js
 export const field = (prop, state, ...args) => (
   transition(prop, state,
-    reduce((ev, ctx) => ({ ...ctx, [prop]: ev.event.target.value })),
+    reduce((ctx, ev) => ({ ...ctx, [prop]: ev.event.target.value })),
     ...args
   )
 );

docs/index.md

@@ -94,7 +94,7 @@ const machine = createMachine({
   ),
   loading: invoke(loadUsers,
     transition('done', 'loaded',
-      reduce((ev, ctx) => ({ ...ctx, users: ev.data }))
+      reduce((ctx, ev) => ({ ...ctx, users: ev.data }))
     )
   ),
   loaded: state()
@@ -199,20 +199,20 @@ const machine = createMachine({
   preview: state(
     transition('edit', 'editMode'
       // Save the current title as oldTitle so we can reset later.
-      reduce((ev, ctx) => ({ ...ctx, oldTitle: ctx.title }))
+      reduce(ctx => ({ ...ctx, oldTitle: ctx.title }))
     )
   ),
   editMode: state(
     transition('input', 'editMode'
-      reduce((ev, ctx) => ({ ...ctx, title: ev.target.value }))
+      reduce((ctx, ev) => ({ ...ctx, title: ev.target.value }))
     ),
     transition('cancel', 'cancel'),
     transition('save', 'validate')
   ),
   cancel: state(
     immediate('preview',
       // Reset the title back to oldTitle
-      reduce((ev, ctx) => ({ ...ctx, title: ctx.oldTitle })
+      reduce(ctx => ({ ...ctx, title: ctx.oldTitle })
     )
   ),
   validate: state(

machine.js

@@ -10,9 +10,8 @@ export let d = {};
 let truthy = () => true;
 let empty = () => ({});
 let identity = a => a;
-let identity2 = (a, b) => b;
 let callBoth = (par, fn, self, args) => par.apply(self, args) && fn.apply(self, args);
-let callForward = (par, fn, self, [a, b]) => fn.call(self, a, par.call(self, a, b));
+let callForward = (par, fn, self, [a, b]) => fn.call(self, par.call(self, a, b), b);
 let create = (a, b) => Object.freeze(Object.create(a, b));
 
 function stack(fns, def, caller) {
@@ -27,9 +26,6 @@ function fnType(fn) {
   return create(this, { fn: valueEnumerable(fn) });
 }
 
-let actionType = {};
-export let action = fnType.bind(actionType);
-
 let reduceType = {};
 export let reduce = fnType.bind(reduceType);
 
@@ -42,7 +38,7 @@ function filter(Type, arr) {
 
 function extractActions(args) {
   let guards = stack(filter(guardType, args).map(t => t.fn), truthy, callBoth);
-  let reducers = stack(filter(reduceType, args).map(t => t.fn), identity2, callForward);
+  let reducers = stack(filter(reduceType, args).map(t => t.fn), identity, callForward);
   return [guards, reducers];
 }
 
@@ -105,7 +101,7 @@ let invokeType = {
 };
 function machineToPromise(machine) {
   return function() {
-    return new Promise((resolve, reject) => {
+    return new Promise(resolve => {
       this.child = interpret(machine, s => {
         this.onChange(s);
         if(s.machine.state.value.final) {
@@ -130,11 +126,11 @@ let machine = {
     };
   }
 };
-export function createMachine(states, contextFn) {
+export function createMachine(states, contextFn = empty) {
   if(d._create) d._create(states);
   let current = Object.keys(states)[0];
   return create(machine, {
-    context: valueEnumerable(contextFn || empty),
+    context: valueEnumerable(contextFn),
     current: valueEnumerable(current),
     states: valueEnumerable(states)
   });
@@ -144,7 +140,7 @@ function transitionTo(service, fromEvent, candidates) {
   let { machine, context } = service;
   for(let { to, guards, reducers } of candidates) {  
     if(guards(context)) {
-      service.context = reducers.call(service, fromEvent, context);
+      service.context = reducers.call(service, context, fromEvent);
 
       let original = machine.original || machine;
       let newMachine = create(original, {
@@ -177,6 +173,7 @@ let service = {
     this.onChange(this);
   }
 };
+
 export function interpret(machine, onChange) {
   let s = Object.create(service, {
     machine: valueEnumerableWritable(machine),
@@ -186,4 +183,4 @@ export function interpret(machine, onChange) {
   s.send = s.send.bind(s);
   s.machine = s.machine.state.value.enter(s.machine, s, {});
   return s;
-}
+} 

test/test-invoke.js

@@ -8,7 +8,7 @@ QUnit.module('Invoke', hooks => {
       one: state(transition('click', 'two')),
       two: invoke(() => Promise.resolve(13),
         transition('done', 'three',
-          reduce((ev, ctx) => ({ ...ctx, age: ev.data }))
+          reduce((ctx, ev) => ({ ...ctx, age: ev.data }))
         )
       ),
       three: state()
@@ -26,7 +26,7 @@ QUnit.module('Invoke', hooks => {
       one: state(transition('click', 'two')),
       two: invoke(() => Promise.reject(new Error('oh no')),
         transition('error', 'three',
-          reduce((ev, ctx) => ({ ...ctx, error: ev.error }))
+          reduce((ctx, ev) => ({ ...ctx, error: ev.error }))
         )
       ),
       three: state()
@@ -41,7 +41,7 @@ QUnit.module('Invoke', hooks => {
   QUnit.test('The initial state can be an invoke', async assert => {
     let machine = createMachine({
       one: invoke(() => Promise.resolve(2),
-        transition('done', 'two', reduce((ev, ctx) => ({...ctx, age: ev.data})))
+        transition('done', 'two', reduce((ctx, ev) => ({...ctx, age: ev.data})))
       ),
       two: state()
     }, () => ({ age: 0 }));

test/test-reduce.js

@@ -5,8 +5,8 @@ QUnit.module('Reduce', () => {
     let machine = createMachine({
       one: state(
         transition('ping', 'two',
-          reduce((ev, ctx) => ({ ...ctx, one: 1 })),
-          reduce((ev, ctx) => ({ ...ctx, two: 2 }))
+          reduce((ctx) => ({ ...ctx, one: 1 })),
+          reduce((ctx) => ({ ...ctx, two: 2 }))
         )
       ),
       two: state()
@@ -18,4 +18,36 @@ QUnit.module('Reduce', () => {
     assert.equal(one, 1, 'first reducer ran');
     assert.equal(two, 2, 'second reducer ran');
   });
+
+  QUnit.test('If no reducers, the context remains', assert => {
+    let machine = createMachine({
+      one: state(
+        transition('go', 'two')
+      ),
+      two: state()
+    }, () => ({ one: 1, two: 2 }));
+
+    let service = interpret(machine, () => {});
+    service.send('go');
+    assert.deepEqual(service.context, { one: 1, two: 2 }, 'context remains');
+  });
+
+  QUnit.test('Event is the second argument', assert => {
+    assert.expect(2);
+
+    let machine = createMachine({
+      one: state(
+        transition('go', 'two',
+          reduce(function(ctx, ev) {
+            assert.equal(ev, 'go');
+            return { ...ctx, worked: true };
+          })
+        )
+      ),
+      two: state()
+    });
+    let service = interpret(machine, () => {});
+    service.send('go');
+    assert.equal(service.context.worked, true, 'changed the context');
+  });
 });