Merge branch 'master' into tm/prepare-0.12.0

src/identity.js

@@ -1,15 +1,15 @@
 import { foldl } from 'funcadelic';
-import { promap, valueOf, pathOf, Meta } from './meta';
+import { promap, valueOf, pathOf, Meta, mount } from './meta';
 import CachedProperty from './cached-property';
 import { methodsOf } from './reflection';
+import { isArrayType } from './types/array';
+import { create } from './microstates';
 
 //function composition should probably not be part of lens :)
 import { At, view, Path, compose, set } from './lens';
 
 class Location {
-  static data = At(Symbol('@location'));
-  static id = compose(Location.data, At("id"));
-  static microstate = compose(Location.data, At("microstate"));
+  static id = At(Symbol('@id'));
 }
 
 export default function Identity(microstate, observe = x => x) {
@@ -32,8 +32,6 @@ export default function Identity(microstate, observe = x => x) {
       let Type = microstate.constructor.Type;
       let value = valueOf(microstate);
 
-      pathmap = set(compose(Path(path), Location.microstate), microstate, pathmap);
-
       let id = view(compose(Path(path), Location.id), pathmap);
 
       let Id = id != null && id.constructor.Type === Type ? id.constructor : IdType(Type, path);
@@ -71,7 +69,14 @@ export default function Identity(microstate, observe = x => x) {
     Object.assign(Id.prototype, foldl((methods, name) => {
       methods[name] = function(...args) {
         let path = P;
-        let microstate = view(compose(Path(path), Location.microstate), pathmap);
+        let microstate = path.reduce((microstate, key) => {
+          if (isArrayType(microstate)) {
+            let value = valueOf(microstate)[key];
+            return mount(microstate, create(microstate.constructor.T, value), key);
+          } else {
+            return microstate[key];
+          }
+        }, current);
         let next = microstate[name](...args);
 
         return next === current ? identity : tick(next);

src/types/array.js

@@ -4,8 +4,17 @@ import { Profunctor, promap, mount, valueOf } from '../meta';
 import { create } from '../microstates';
 import parameterized from '../parameterized';
 
+
+const ARRAY_TYPE = Symbol('ArrayType');
+
+export function isArrayType(microstate) {
+  return microstate.constructor && microstate.constructor[ARRAY_TYPE];
+}
+
 export default parameterized(T => class ArrayType {
   static T = T;
+  static get [ARRAY_TYPE]()  { return true; }
+
   static get name() {
     return `Array<${T.name}>`;
   }

tests/identity.test.js

@@ -169,4 +169,31 @@ describe('Identity', () => {
       });
     });
   });
+
+  describe('identity support of type reuse', () => {
+    class Person {
+      name = String;
+      father = Person;
+      mother = Person;
+    }
+
+    it('it keeps both branches', () => {
+      let s = Identity(create(Person), next => (s = next));
+      let { name, father, mother } = s;
+
+      name.set('Bart');
+      father.name.set('Homer');
+      mother.name.set('Marge');
+
+      expect({
+        name: s.name.state,
+        father: { name: s.father.name.state },
+        mother: { name: s.mother.name.state }
+      }).toEqual({
+        name: 'Bart',
+        father: { name: 'Homer' },
+        mother: { name: 'Marge' }
+      });
+    });
+  });
 });