fastener - npm Package Compare versions

Comparing version 0.2.1 to 0.2.2

lib/fastener.js

@@ -20,4 +20,2 @@ "use strict";
 
-var empty = [];
-
 var pass = function pass(x, f) {
@@ -95,7 +93,7 @@ return f(x);
 
-    if (isArray(focus)) {
-      return downIndex(focus, head ? 0 : focus.length - 1, { up: up });
-    } else if (isObject(focus)) {
+    if (isObject(focus)) {
       var keys = R.keys(focus);
       return downIndex(R.values(focus), head ? 0 : keys.length - 1, { keys: keys, up: up });
+    } else if (isArray(focus)) {
+      return downIndex(focus, head ? 0 : focus.length - 1, { up: up });
     } else {
@@ -112,3 +110,3 @@ return undefined;
 var shift = function shift(f, c, t, k) {
-  return f.length === 0 ? undefined : k(R.dropLast(1, f), R.last(f), R.append(c, t));
+  return f && f.length !== 0 ? k(R.dropLast(1, f), R.last(f), R.append(c, t)) : undefined;
 };
@@ -152,3 +150,3 @@
 var toZipper = exports.toZipper = function toZipper(focus) {
-  return { left: empty, right: empty, focus: focus };
+  return { focus: focus };
 };
@@ -193,2 +191,2 @@
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/fastener.js"],"names":[],"mappings":"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","file":"fastener.js","sourcesContent":["import * as R from \"ramda\"\n\nconst empty = []\n\nconst pass = (x, f) => f(x)\n\nconst isObject = x => x && x.constructor === Object\nconst isArray = x => x && x.constructor === Array\n\nexport const get = z => z.focus\nexport const set = R.curry((focus, z) => ({...z, focus}))\nexport const modify = R.curry((f, z) => set(f(get(z)), z))\n\nexport const up = ({left, focus, right, keys, up}) => {\n  if (keys) {\n    return {focus: R.zipObj(keys, [...left, focus, ...R.reverse(right)]), ...up}\n  } else if (up) {\n    return {focus: [...left, focus, ...R.reverse(right)], ...up}\n  } else {\n    return undefined\n  }\n}\n\nconst downIndex = (values, i, rest) =>\n  0 <= i && i < values.length\n  ? ({left: values.slice(0, i),\n      focus: values[i],\n      right: values.slice(i+1).reverse(),\n      ...rest})\n  : undefined\n\nexport const downTo = R.curry((k, {focus, ...up}) => {\n  if (isObject(focus)) {\n    const keys = R.keys(focus)\n    return downIndex(R.values(focus), keys.findIndex(R.equals(k)), {keys, up})\n  } else if (isArray(focus)) {\n    return downIndex(focus, k, {up})\n  } else {\n    return undefined\n  }\n})\n\nexport const keyOf = ({left, keys, up}) =>\n  keys ? keys[left.length] :\n  up   ? left.length :\n  undefined\n\nconst downMost = head => ({focus, ...up}) => {\n  if (isArray(focus)) {\n    return downIndex(focus, head ? 0 : focus.length-1, {up})\n  } else if (isObject(focus)) {\n    const keys = R.keys(focus)\n    return downIndex(R.values(focus), head ? 0 : keys.length-1, {keys, up})\n  } else {\n    return undefined\n  }\n}\n\nexport const downHead = downMost(true)\nexport const downLast = downMost(false)\n\n// FYI: The left and right ops are not accidentally O(n).  I'm just lazy. :)\nconst shift = (f, c, t, k) =>\n  f.length === 0 ? undefined : k(R.dropLast(1, f), R.last(f), R.append(c, t))\n\nexport const left = ({left, focus, right, ...rest}) =>\n  shift(left, focus, right, (l, f, r) => ({left: l, focus: f, right: r, ...rest}))\n\nexport const right = ({left, focus, right, ...rest}) =>\n  shift(right, focus, left, (r, f, l) => ({left: l, focus: f, right: r, ...rest}))\n\nexport const head = z => pass(up(z), z => z && downHead(z))\nexport const last = z => pass(up(z), z => z && downLast(z))\n\nexport const toZipper = focus => ({left: empty, right: empty, focus})\n\nexport const fromZipper = z =>\n  pass(up(z), zz => zz ? fromZipper(zz) : get(z))\n\nexport const queryMove = R.curry((move, b, f, z) =>\n  pass(move(z), z => z ? f(z) : b))\n\nconst bwd = (move, z) => {\n  switch (move) {\n    case left: return right\n    case right: return left\n    case up: return downTo(keyOf(z))\n    default: return up\n  }\n}\n\nexport const transformMove = R.curry((move, f, z) =>\n  queryMove(move, z, R.pipe(f, queryMove(bwd(move, z), z, R.identity)), z))\n\nconst everywhereG = f => z =>\n  transformMove(right, everywhereG(f), everywhere(f, z))\nexport const everywhere = R.curry((f, z) =>\n  modify(f, transformMove(downHead, everywhereG(f), z)))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/fastener.js"],"names":[],"mappings":";;;;;;;;;AAAA;;IAAY,C;;;;;;;;AAEZ,IAAM,OAAO,SAAP,IAAO,CAAC,CAAD,EAAI,CAAJ;AAAA,SAAU,EAAE,CAAF,CAAV;AAAA,CAAb;;AAEA,IAAM,WAAW,SAAX,QAAW;AAAA,SAAK,KAAK,EAAE,WAAF,KAAkB,MAA5B;AAAA,CAAjB;AACA,IAAM,UAAU,SAAV,OAAU;AAAA,SAAK,KAAK,EAAE,WAAF,KAAkB,KAA5B;AAAA,CAAhB;;AAEO,IAAM,oBAAM,SAAN,GAAM;AAAA,SAAK,EAAE,KAAP;AAAA,CAAZ;AACA,IAAM,oBAAM,EAAE,KAAF,CAAQ,UAAC,KAAD,EAAQ,CAAR;AAAA,sBAAmB,CAAnB,IAAsB,YAAtB;AAAA,CAAR,CAAZ;AACA,IAAM,0BAAS,EAAE,KAAF,CAAQ,UAAC,CAAD,EAAI,CAAJ;AAAA,SAAU,IAAI,EAAE,IAAI,CAAJ,CAAF,CAAJ,EAAe,CAAf,CAAV;AAAA,CAAR,CAAf;;AAEA,IAAM,kBAAK,kBAAoC;AAAA,MAAlC,IAAkC,QAAlC,IAAkC;AAAA,MAA5B,KAA4B,QAA5B,KAA4B;AAAA,MAArB,KAAqB,QAArB,KAAqB;AAAA,MAAd,IAAc,QAAd,IAAc;AAAA,MAAR,GAAQ,QAAR,EAAQ;;AACpD,MAAI,IAAJ,EAAU;AACR,sBAAQ,OAAO,EAAE,MAAF,CAAS,IAAT,+BAAmB,IAAnB,IAAyB,KAAzB,sBAAmC,EAAE,OAAF,CAAU,KAAV,CAAnC,GAAf,IAAyE,GAAzE;AACD,GAFD,MAEO,IAAI,GAAJ,EAAQ;AACb,sBAAQ,oCAAW,IAAX,IAAiB,KAAjB,sBAA2B,EAAE,OAAF,CAAU,KAAV,CAA3B,EAAR,IAAyD,GAAzD;AACD,GAFM,MAEA;AACL,WAAO,SAAP;AACD;AACF,CARM;;AAUP,IAAM,YAAY,SAAZ,SAAY,CAAC,MAAD,EAAS,CAAT,EAAY,IAAZ;AAAA,SAChB,KAAK,CAAL,IAAU,IAAI,OAAO,MAArB,cACI,MAAM,OAAO,KAAP,CAAa,CAAb,EAAgB,CAAhB,CADV;AAEI,WAAO,OAAO,CAAP,CAFX;AAGI,WAAO,OAAO,KAAP,CAAa,IAAE,CAAf,EAAkB,OAAlB;AAHX,KAIO,IAJP,IAKE,SANc;AAAA,CAAlB;;AAQO,IAAM,0BAAS,EAAE,KAAF,CAAQ,UAAC,CAAD,SAAuB;AAAA,MAAlB,KAAkB,SAAlB,KAAkB;;AAAA,MAAR,EAAQ;;AACnD,MAAI,SAAS,KAAT,CAAJ,EAAqB;AACnB,QAAM,OAAO,EAAE,IAAF,CAAO,KAAP,CAAb;AACA,WAAO,UAAU,EAAE,MAAF,CAAS,KAAT,CAAV,EAA2B,KAAK,SAAL,CAAe,EAAE,MAAF,CAAS,CAAT,CAAf,CAA3B,EAAwD,EAAC,UAAD,EAAO,MAAP,EAAxD,CAAP;AACD,GAHD,MAGO,IAAI,QAAQ,KAAR,CAAJ,EAAoB;AACzB,WAAO,UAAU,KAAV,EAAiB,CAAjB,EAAoB,EAAC,MAAD,EAApB,CAAP;AACD,GAFM,MAEA;AACL,WAAO,SAAP;AACD;AACF,CATqB,CAAf;;AAWA,IAAM,wBAAQ,SAAR,KAAQ;AAAA,MAAE,IAAF,SAAE,IAAF;AAAA,MAAQ,IAAR,SAAQ,IAAR;AAAA,MAAc,EAAd,SAAc,EAAd;AAAA,SACnB,OAAO,KAAK,KAAK,MAAV,CAAP,GACA,KAAO,KAAK,MAAZ,GACA,SAHmB;AAAA,CAAd;;AAKP,IAAM,WAAW,SAAX,QAAW;AAAA,SAAQ,iBAAoB;AAAA,QAAlB,KAAkB,SAAlB,KAAkB;;AAAA,QAAR,EAAQ;;AAC3C,QAAI,SAAS,KAAT,CAAJ,EAAqB;AACnB,UAAM,OAAO,EAAE,IAAF,CAAO,KAAP,CAAb;AACA,aAAO,UAAU,EAAE,MAAF,CAAS,KAAT,CAAV,EAA2B,OAAO,CAAP,GAAW,KAAK,MAAL,GAAY,CAAlD,EAAqD,EAAC,UAAD,EAAO,MAAP,EAArD,CAAP;AACD,KAHD,MAGO,IAAI,QAAQ,KAAR,CAAJ,EAAoB;AACzB,aAAO,UAAU,KAAV,EAAiB,OAAO,CAAP,GAAW,MAAM,MAAN,GAAa,CAAzC,EAA4C,EAAC,MAAD,EAA5C,CAAP;AACD,KAFM,MAEA;AACL,aAAO,SAAP;AACD;AACF,GATgB;AAAA,CAAjB;;AAWO,IAAM,8BAAW,SAAS,IAAT,CAAjB;AACA,IAAM,8BAAW,SAAS,KAAT,CAAjB;;;AAGP,IAAM,QAAQ,SAAR,KAAQ,CAAC,CAAD,EAAI,CAAJ,EAAO,CAAP,EAAU,CAAV;AAAA,SACZ,KAAK,EAAE,MAAF,KAAa,CAAlB,GAAsB,EAAE,EAAE,QAAF,CAAW,CAAX,EAAc,CAAd,CAAF,EAAoB,EAAE,IAAF,CAAO,CAAP,CAApB,EAA+B,EAAE,MAAF,CAAS,CAAT,EAAY,CAAZ,CAA/B,CAAtB,GAAuE,SAD3D;AAAA,CAAd;;AAGO,IAAM,sBAAO;AAAA,MAAE,KAAF,SAAE,IAAF;AAAA,MAAQ,KAAR,SAAQ,KAAR;AAAA,MAAe,KAAf,SAAe,KAAf;;AAAA,MAAyB,IAAzB;;AAAA,SAClB,MAAM,KAAN,EAAY,KAAZ,EAAmB,KAAnB,EAA0B,UAAC,CAAD,EAAI,CAAJ,EAAO,CAAP;AAAA,sBAAe,MAAM,CAArB,EAAwB,OAAO,CAA/B,EAAkC,OAAO,CAAzC,IAA+C,IAA/C;AAAA,GAA1B,CADkB;AAAA,CAAb;;AAGA,IAAM,wBAAQ;AAAA,MAAE,IAAF,SAAE,IAAF;AAAA,MAAQ,KAAR,SAAQ,KAAR;AAAA,MAAe,MAAf,SAAe,KAAf;;AAAA,MAAyB,IAAzB;;AAAA,SACnB,MAAM,MAAN,EAAa,KAAb,EAAoB,IAApB,EAA0B,UAAC,CAAD,EAAI,CAAJ,EAAO,CAAP;AAAA,sBAAe,MAAM,CAArB,EAAwB,OAAO,CAA/B,EAAkC,OAAO,CAAzC,IAA+C,IAA/C;AAAA,GAA1B,CADmB;AAAA,CAAd;;AAGA,IAAM,sBAAO,SAAP,IAAO;AAAA,SAAK,KAAK,GAAG,CAAH,CAAL,EAAY;AAAA,WAAK,KAAK,SAAS,CAAT,CAAV;AAAA,GAAZ,CAAL;AAAA,CAAb;AACA,IAAM,sBAAO,SAAP,IAAO;AAAA,SAAK,KAAK,GAAG,CAAH,CAAL,EAAY;AAAA,WAAK,KAAK,SAAS,CAAT,CAAV;AAAA,GAAZ,CAAL;AAAA,CAAb;;AAEA,IAAM,8BAAW,SAAX,QAAW;AAAA,SAAU,EAAC,YAAD,EAAV;AAAA,CAAjB;;AAEA,IAAM,kCAAa,SAAb,UAAa;AAAA,SACxB,KAAK,GAAG,CAAH,CAAL,EAAY;AAAA,WAAM,KAAK,WAAW,EAAX,CAAL,GAAsB,IAAI,CAAJ,CAA5B;AAAA,GAAZ,CADwB;AAAA,CAAnB;;AAGA,IAAM,gCAAY,EAAE,KAAF,CAAQ,UAAC,IAAD,EAAO,CAAP,EAAU,CAAV,EAAa,CAAb;AAAA,SAC/B,KAAK,KAAK,CAAL,CAAL,EAAc;AAAA,WAAK,IAAI,EAAE,CAAF,CAAJ,GAAW,CAAhB;AAAA,GAAd,CAD+B;AAAA,CAAR,CAAlB;;AAGP,IAAM,MAAM,SAAN,GAAM,CAAC,IAAD,EAAO,CAAP,EAAa;AACvB,UAAQ,IAAR;AACE,SAAK,IAAL;AAAW,aAAO,KAAP;AACX,SAAK,KAAL;AAAY,aAAO,IAAP;AACZ,SAAK,EAAL;AAAS,aAAO,OAAO,MAAM,CAAN,CAAP,CAAP;AACT;AAAS,aAAO,EAAP;AAJX;AAMD,CAPD;;AASO,IAAM,wCAAgB,EAAE,KAAF,CAAQ,UAAC,IAAD,EAAO,CAAP,EAAU,CAAV;AAAA,SACnC,UAAU,IAAV,EAAgB,CAAhB,EAAmB,EAAE,IAAF,CAAO,CAAP,EAAU,UAAU,IAAI,IAAJ,EAAU,CAAV,CAAV,EAAwB,CAAxB,EAA2B,EAAE,QAA7B,CAAV,CAAnB,EAAsE,CAAtE,CADmC;AAAA,CAAR,CAAtB;;AAGP,IAAM,cAAc,SAAd,WAAc;AAAA,SAAK;AAAA,WACvB,cAAc,KAAd,EAAqB,YAAY,CAAZ,CAArB,EAAqC,WAAW,CAAX,EAAc,CAAd,CAArC,CADuB;AAAA,GAAL;AAAA,CAApB;AAEO,IAAM,kCAAa,EAAE,KAAF,CAAQ,UAAC,CAAD,EAAI,CAAJ;AAAA,SAChC,OAAO,CAAP,EAAU,cAAc,QAAd,EAAwB,YAAY,CAAZ,CAAxB,EAAwC,CAAxC,CAAV,CADgC;AAAA,CAAR,CAAnB","file":"fastener.js","sourcesContent":["import * as R from \"ramda\"\n\nconst pass = (x, f) => f(x)\n\nconst isObject = x => x && x.constructor === Object\nconst isArray = x => x && x.constructor === Array\n\nexport const get = z => z.focus\nexport const set = R.curry((focus, z) => ({...z, focus}))\nexport const modify = R.curry((f, z) => set(f(get(z)), z))\n\nexport const up = ({left, focus, right, keys, up}) => {\n  if (keys) {\n    return {focus: R.zipObj(keys, [...left, focus, ...R.reverse(right)]), ...up}\n  } else if (up) {\n    return {focus: [...left, focus, ...R.reverse(right)], ...up}\n  } else {\n    return undefined\n  }\n}\n\nconst downIndex = (values, i, rest) =>\n  0 <= i && i < values.length\n  ? ({left: values.slice(0, i),\n      focus: values[i],\n      right: values.slice(i+1).reverse(),\n      ...rest})\n  : undefined\n\nexport const downTo = R.curry((k, {focus, ...up}) => {\n  if (isObject(focus)) {\n    const keys = R.keys(focus)\n    return downIndex(R.values(focus), keys.findIndex(R.equals(k)), {keys, up})\n  } else if (isArray(focus)) {\n    return downIndex(focus, k, {up})\n  } else {\n    return undefined\n  }\n})\n\nexport const keyOf = ({left, keys, up}) =>\n  keys ? keys[left.length] :\n  up   ? left.length :\n  undefined\n\nconst downMost = head => ({focus, ...up}) => {\n  if (isObject(focus)) {\n    const keys = R.keys(focus)\n    return downIndex(R.values(focus), head ? 0 : keys.length-1, {keys, up})\n  } else if (isArray(focus)) {\n    return downIndex(focus, head ? 0 : focus.length-1, {up})\n  } else {\n    return undefined\n  }\n}\n\nexport const downHead = downMost(true)\nexport const downLast = downMost(false)\n\n// FYI: The left and right ops are not accidentally O(n).  I'm just lazy. :)\nconst shift = (f, c, t, k) =>\n  f && f.length !== 0 ? k(R.dropLast(1, f), R.last(f), R.append(c, t)) : undefined\n\nexport const left = ({left, focus, right, ...rest}) =>\n  shift(left, focus, right, (l, f, r) => ({left: l, focus: f, right: r, ...rest}))\n\nexport const right = ({left, focus, right, ...rest}) =>\n  shift(right, focus, left, (r, f, l) => ({left: l, focus: f, right: r, ...rest}))\n\nexport const head = z => pass(up(z), z => z && downHead(z))\nexport const last = z => pass(up(z), z => z && downLast(z))\n\nexport const toZipper = focus => ({focus})\n\nexport const fromZipper = z =>\n  pass(up(z), zz => zz ? fromZipper(zz) : get(z))\n\nexport const queryMove = R.curry((move, b, f, z) =>\n  pass(move(z), z => z ? f(z) : b))\n\nconst bwd = (move, z) => {\n  switch (move) {\n    case left: return right\n    case right: return left\n    case up: return downTo(keyOf(z))\n    default: return up\n  }\n}\n\nexport const transformMove = R.curry((move, f, z) =>\n  queryMove(move, z, R.pipe(f, queryMove(bwd(move, z), z, R.identity)), z))\n\nconst everywhereG = f => z =>\n  transformMove(right, everywhereG(f), everywhere(f, z))\nexport const everywhere = R.curry((f, z) =>\n  modify(f, transformMove(downHead, everywhereG(f), z)))\n"]}

package.json

 {
   "name": "fastener",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Zipper for manipulating JSON",
   "main": "lib/fastener.js",
   "scripts": {
-    "bench": "node bench/bench.js",
     "dist": "babel src --source-maps inline --out-dir lib",
@@ -18,4 +17,9 @@ "lint": "eslint src test",
   "keywords": [
-    "zipper",
-    "json"
+    "cursor",
+    "functional",
+    "immutable",
+    "json",
+    "query",
+    "transform",
+    "zipper"
   ],
@@ -36,3 +40,2 @@ "license": "MIT",
     "babel-preset-stage-2": "^6.5.0",
-    "benchmark": "^2.1.0",
     "eslint": "^2.8.0",
@@ -39,0 +42,0 @@ "mocha": "^2.4.5",

README.md

@@ -13,2 +13,211 @@ [ [Tutorial](#tutorial) | [Reference](#reference) | [Related Work](#related-work) ]
 
+Playing with zippers in a REPL can be very instructive.  First we require the
+libraries and define a little helper using
+[`reduce`](http://ramdajs.com/0.21.0/docs/#reduce) to perform a sequence of
+operations on a value:
+
+```js
+const R = require("ramda")
+const F = require("fastener")
+const seq = (x, ...fs) => R.reduce((x, f) => f(x), x, fs)
+```
+
+Let's work with the following simple JSON object:
+
+```js
+const data = { contents: [ { language: "en", text: "Title" },
+                           { language: "sv", text: "Rubrik" } ] }
+```
+
+First we just create a zipper using [`F.toZipper`](#toZipper):
+
+```js
+seq(F.toZipper(data))
+// { focus: { contents: [ [Object], [Object] ] } }
+```
+
+As can be seen, the zipper is just a simple JSON object and the `focus` is the
+`data` object that we gave to [`F.toZipper`](#toZipper).  However, you should
+use the zipper combinators to operate on zippers rather than rely on their exact
+format.
+
+Let's then move into the `contents` property of the object using
+[`F.downTo`](#downTo):
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'))
+// { left: [],
+//   focus:
+//    [ { language: 'en', text: 'Title' },
+//      { language: 'sv', text: 'Rubrik' } ],
+//   right: [],
+//   keys: [ 'contents' ],
+//   up: {} }
+```
+
+As seen above, the `focus` now has the `contents` array.  We can use
+[`F.get`](#get) to extract the value under focus:
+
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.get)
+// [ { language: 'en', text: 'Title' },
+//   { language: 'sv', text: 'Rubrik' } ]
+```
+
+Then we move into the first item of `contents` using [`F.downHead`](#downHead):
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead)
+// { left: [],
+//   focus: { language: 'en', text: 'Title' },
+//   right: [ { language: 'sv', text: 'Rubrik' } ],
+//   up: { left: [], right: [], keys: [ 'contents' ], up: {} } }
+```
+
+And continue into the first item of that which happens to the `language`:
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead,
+    F.downHead)
+// { left: [],
+//   focus: 'en',
+//   right: [ 'Title' ],
+//   keys: [ 'language', 'text' ],
+//   up:
+//    { left: [],
+//      right: [ [Object] ],
+//      up: { left: [], right: [], keys: [Object], up: {} } } }
+```
+
+And to the next item, `title`, using [`F.right`](#right):
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead,
+    F.downHead,
+    F.right)
+// { left: [ 'en' ],
+//   focus: 'Title',
+//   right: [],
+//   keys: [ 'language', 'text' ],
+//   up:
+//    { left: [],
+//      right: [ [Object] ],
+//      up: { left: [], right: [], keys: [Object], up: {} } } }
+```
+
+Let's then use [`F.modify`](#modify) to modify the `title`:
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead,
+    F.downHead,
+    F.right,
+    F.modify(t => "The " + t))
+// { left: [ 'en' ],
+//   focus: 'The Title',
+//   right: [],
+//   keys: [ 'language', 'text' ],
+//   up:
+//    { left: [],
+//      right: [ [Object] ],
+//      up: { left: [], right: [], keys: [Object], up: {} } } }
+```
+
+When we now move outwards using [`F.up`](#up) we can see the changed title
+become part of the data:
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead,
+    F.downHead,
+    F.right,
+    F.modify(t => "The " + t),
+    F.up)
+// { focus: { language: 'en', text: 'The Title' },
+//   left: [],
+//   right: [ { language: 'sv', text: 'Rubrik' } ],
+//   up: { left: [], right: [], keys: [ 'contents' ], up: {} } }
+```
+
+We can also just move back to the root and get the updated data structure using
+[`F.fromZipper`](#fromZipper):
+
+```js
+seq(F.toZipper(data),
+    F.downTo('contents'),
+    F.downHead,
+    F.downHead,
+    F.right,
+    F.modify(t => "The " + t),
+    F.fromZipper)
+// { contents:
+//    [ { language: 'en', text: 'The Title' },
+//      { language: 'sv', text: 'Rubrik' } ] }
+```
+
+The above hopefully helped to understand how zippers work.  However, it is
+important to realize that one typically does not use zipper combinators to
+create such a specific sequence of operations.  One rather uses the zipper
+combinators to create new combinators that perform more complex operations
+directly.
+
+Let's first define a zipper combinator that, given a zipper focused on an array,
+tries to focus on an element inside the array that satisfies a given predicate:
+
+```js
+const find = R.curry((p, z) =>
+  F.downTo(R.findIndex(p, F.get(z)), z))
+```
+
+Like all the basic zipper movement combinators, [`F.downTo`](#downTo) is a
+*partial function* that returns `undefined` in case the index is out of bounds.
+Let's define a simple function to compose partial functions:
+
+```js
+const pipeU = (...fs) => z => {
+  let r = z
+  for (let i=0; r !== undefined && i<fs.length; ++i)
+    r = fs[i](r)
+  return r
+}
+```
+
+We can now compose a zipper combinator that, given a zipper focused on an object
+like `data`, tries to focus on the `text` element of an object with the given
+`language` inside the `contents`:
+
+
+```js
+const textIn = language =>
+  pipeU(F.downTo('contents'),
+        find(r => r.language === language),
+        F.downTo('text'))
+```
+
+Now we can say:
+
+```js
+pipeU(F.toZipper, textIn("en"), F.modify(x => 'The ' + x), F.fromZipper)(data)
+// { contents:
+//    [ { language: 'en', text: 'The Title' },
+//      { language: 'sv', text: 'Rubrik' } ] }
+```
+
+Of course, this just scratches the surface.  Zippers are powerful enough to
+implement arbitrary transforms on data structures.  This can also make them more
+difficult to compose and reason about than more limited approaches such as
+[lenses](https://github.com/calmm-js/partial.lenses).
+
 ## Reference
@@ -15,0 +224,0 @@

src/fastener.js

 import * as R from "ramda"
 
-const empty = []
-
 const pass = (x, f) => f(x)
@@ -49,7 +47,7 @@
 const downMost = head => ({focus, ...up}) => {
-  if (isArray(focus)) {
-    return downIndex(focus, head ? 0 : focus.length-1, {up})
-  } else if (isObject(focus)) {
+  if (isObject(focus)) {
     const keys = R.keys(focus)
     return downIndex(R.values(focus), head ? 0 : keys.length-1, {keys, up})
+  } else if (isArray(focus)) {
+    return downIndex(focus, head ? 0 : focus.length-1, {up})
   } else {
@@ -65,3 +63,3 @@ return undefined
 const shift = (f, c, t, k) =>
-  f.length === 0 ? undefined : k(R.dropLast(1, f), R.last(f), R.append(c, t))
+  f && f.length !== 0 ? k(R.dropLast(1, f), R.last(f), R.append(c, t)) : undefined
 
@@ -77,3 +75,3 @@ export const left = ({left, focus, right, ...rest}) =>
 
-export const toZipper = focus => ({left: empty, right: empty, focus})
+export const toZipper = focus => ({focus})
 
@@ -80,0 +78,0 @@ export const fromZipper = z =>

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

65161

increased by20.33%

Dev dependency count

8

decreased by-11.11%

Number of lines in readme file

439

increased by90.87%

Worsened metrics

Lines of code

304

decreased by-0.65%

No dependency changes