partial.lenses - npm Package Compare versions

Comparing version 1.4.0 to 1.4.1

lib/partial.lenses.js

@@ -264,35 +264,6 @@ "use strict";
   var kks = [k].concat(ks);
-  return _ramda2.default.lens(function () {
-    var o = arguments.length <= 0 || arguments[0] === undefined ? empty : arguments[0];
-
-    var r = void 0;
-    kks.forEach(function (k) {
-      if (k in o) {
-        if (!r) r = {};
-        r[k] = o[k];
-      }
-    });
-    return r;
-  }, toConserve(function () {
-    var s = arguments.length <= 0 || arguments[0] === undefined ? empty : arguments[0];
-    var o = arguments.length <= 1 || arguments[1] === undefined ? empty : arguments[1];
-
-    var r = void 0;
-    for (var _k in o) {
-      if (!_ramda2.default.contains(_k, kks)) {
-        if (!r) r = {};
-        r[_k] = o[_k];
-      }
-    }
-    kks.forEach(function (k) {
-      if (k in s) {
-        if (!r) r = {};
-        r[k] = s[k];
-      }
-    });
-    return r;
-  }));
+  return L.pick(_ramda2.default.zipObj(kks, kks));
 };
 
 exports.default = L;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/partial.lenses.js"],"names":[],"mappings":"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","file":"partial.lenses.js","sourcesContent":["import R from \"ramda\"\n\n//\n\nconst empty = {}\n\nconst deleteKey = (k, o) => {\n  if (o === undefined || !(k in o))\n    return o\n  let r\n  for (const p in o) {\n    if (p !== k) {\n      if (undefined === r)\n        r = {}\n      r[p] = o[p]\n    }\n  }\n  return r\n}\n\nconst setKey = (k, v, o) => {\n  if (o === undefined)\n    return {[k]: v}\n  if (k in o && R.equals(v, o[k]))\n    return o\n  const r = {[k]: v}\n  for (const p in o)\n    if (p !== k)\n      r[p] = o[p]\n  return r\n}\n\n//\n\nconst dropped = xs => Object.keys(xs).length === 0 ? undefined : xs\n\n//\n\nconst toPartial = transform => x => undefined === x ? x : transform(x)\n\n//\n\nconst conserve = (c0, c1) => R.equals(c0, c1) ? c0 : c1\n\nconst toConserve = f => (y, c0) => conserve(c0, f(y, c0))\n\n//\n\nexport const lift = l => {\n  switch (typeof l) {\n  case \"string\": return L.prop(l)\n  case \"number\": return L.index(l)\n  default:       return l\n  }\n}\n\nconst L = (l, ...ls) =>\n  ls.length === 0 ? lift(l) : R.compose(lift(l), ...ls.map(lift))\n\nL.compose = L\nL.delete = R.curry((l, s) => R.set(lift(l), undefined, s))\nL.deleteAll = R.curry((lens, data) => {\n  while (L.view(lens, data) !== undefined)\n    data = L.delete(lens, data)\n  return data\n})\nL.lens = R.lens\nL.over = R.curry((l, x2x, s) => R.over(lift(l), x2x, s))\nL.set = R.curry((l, x, s) => R.set(lift(l), x, s))\nL.view = R.curry((l, s) => R.view(lift(l), s))\n\nL.choose = x2yL => toFunctor => target => {\n  const l = lift(x2yL(target))\n  return R.map(focus => R.set(l, focus, target), toFunctor(R.view(l, target)))\n}\n\nL.firstOf = (l, ...ls) => L.choose(x => {\n  const lls = [l, ...ls]\n  return lls[Math.max(0, lls.findIndex(l => L.view(l, x) !== undefined))]\n})\n\nL.replace = R.curry((inn, out) =>\n  R.lens(x => R.equals(x, inn) ? out : x,\n         toConserve(y => R.equals(y, out) ? inn : y)))\n\nL.default = L.replace(undefined)\nL.required = inn => L.replace(inn, undefined)\nL.define = v => R.compose(L.required(v), L.default(v))\n\nL.normalize = transform =>\n  R.lens(toPartial(transform), toConserve(toPartial(transform)))\n\nL.prop = k =>\n  R.lens(o => o && o[k],\n         (v, o) => v === undefined ? deleteKey(k, o) : setKey(k, v, o))\n\nL.find = predicate => L.choose(xs => {\n  if (xs === undefined)\n    return L.append\n  const i = xs.findIndex(predicate)\n  return i < 0 ? L.append : i\n})\n\nL.findWith = (l, ...ls) => {\n  const lls = L(l, ...ls)\n  return L(L.find(x => R.view(lls, x) !== undefined), lls)\n}\n\nL.index = i => R.lens(xs => xs && xs[i], (x, xs) => {\n  if (x === undefined) {\n    if (xs === undefined)\n      return undefined\n    if (i < xs.length)\n      return dropped(xs.slice(0, i).concat(xs.slice(i+1)))\n    return xs\n  } else {\n    if (xs === undefined)\n      return Array(i).concat([x])\n    if (xs.length <= i)\n      return xs.concat(Array(i - xs.length), [x])\n    if (R.equals(x, xs[i]))\n      return xs\n    return xs.slice(0, i).concat([x], xs.slice(i+1))\n  }\n})\n\nL.append = R.lens(() => {}, (x, xs) =>\n  x === undefined ? xs : xs === undefined ? [x] : xs.concat([x]))\n\nL.filter = p => R.lens(xs => xs && xs.filter(p), (ys, xs) =>\n  conserve(xs, dropped(R.concat(ys || [], (xs || []).filter(R.complement(p))))))\n\nL.augment = template => R.lens(\n  toPartial(x => {\n    const z = {...x}\n    for (const k in template)\n      z[k] = template[k](x)\n    return z\n  }),\n  toConserve((y, c) => {\n    if (y === undefined)\n      return undefined\n    let z\n    const set = (k, v) => {\n      if (undefined === z)\n        z = {}\n      z[k] = v\n    }\n    for (const k in y) {\n      if (!(k in template))\n        set(k, y[k])\n      else\n        if (k in c)\n          set(k, c[k])\n    }\n    return z\n  }))\n\nL.pick = template => R.lens(\n  c => {\n    let r\n    for (const k in template) {\n      const v = L.view(template[k], c)\n      if (v !== undefined) {\n        if (r === undefined)\n          r = {}\n        r[k] = v\n      }\n    }\n    return r\n  },\n  (o = empty, cIn) => {\n    let c = cIn\n    for (const k in template)\n      c = L.set(template[k], o[k], c)\n    return c\n  })\n\nL.identity = R.lens(R.identity, R.identity)\n\nL.props = (k, ...ks) => {\n  const kks = [k, ...ks]\n  return R.lens(\n    (o = empty) => {\n      let r\n      kks.forEach(k => {\n        if (k in o) {\n          if (!r)\n            r = {}\n          r[k] = o[k]\n        }\n      })\n      return r\n    },\n    toConserve((s = empty, o = empty) => {\n      let r\n      for (const k in o) {\n        if (!R.contains(k, kks)) {\n          if (!r)\n            r = {}\n          r[k] = o[k]\n        }\n      }\n      kks.forEach(k => {\n        if (k in s) {\n          if (!r)\n            r = {}\n          r[k] = s[k]\n        }\n      })\n      return r\n    }))\n}\n\nexport default L\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/partial.lenses.js"],"names":[],"mappings":"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","file":"partial.lenses.js","sourcesContent":["import R from \"ramda\"\n\n//\n\nconst empty = {}\n\nconst deleteKey = (k, o) => {\n  if (o === undefined || !(k in o))\n    return o\n  let r\n  for (const p in o) {\n    if (p !== k) {\n      if (undefined === r)\n        r = {}\n      r[p] = o[p]\n    }\n  }\n  return r\n}\n\nconst setKey = (k, v, o) => {\n  if (o === undefined)\n    return {[k]: v}\n  if (k in o && R.equals(v, o[k]))\n    return o\n  const r = {[k]: v}\n  for (const p in o)\n    if (p !== k)\n      r[p] = o[p]\n  return r\n}\n\n//\n\nconst dropped = xs => Object.keys(xs).length === 0 ? undefined : xs\n\n//\n\nconst toPartial = transform => x => undefined === x ? x : transform(x)\n\n//\n\nconst conserve = (c0, c1) => R.equals(c0, c1) ? c0 : c1\n\nconst toConserve = f => (y, c0) => conserve(c0, f(y, c0))\n\n//\n\nexport const lift = l => {\n  switch (typeof l) {\n  case \"string\": return L.prop(l)\n  case \"number\": return L.index(l)\n  default:       return l\n  }\n}\n\nconst L = (l, ...ls) =>\n  ls.length === 0 ? lift(l) : R.compose(lift(l), ...ls.map(lift))\n\nL.compose = L\nL.delete = R.curry((l, s) => R.set(lift(l), undefined, s))\nL.deleteAll = R.curry((lens, data) => {\n  while (L.view(lens, data) !== undefined)\n    data = L.delete(lens, data)\n  return data\n})\nL.lens = R.lens\nL.over = R.curry((l, x2x, s) => R.over(lift(l), x2x, s))\nL.set = R.curry((l, x, s) => R.set(lift(l), x, s))\nL.view = R.curry((l, s) => R.view(lift(l), s))\n\nL.choose = x2yL => toFunctor => target => {\n  const l = lift(x2yL(target))\n  return R.map(focus => R.set(l, focus, target), toFunctor(R.view(l, target)))\n}\n\nL.firstOf = (l, ...ls) => L.choose(x => {\n  const lls = [l, ...ls]\n  return lls[Math.max(0, lls.findIndex(l => L.view(l, x) !== undefined))]\n})\n\nL.replace = R.curry((inn, out) =>\n  R.lens(x => R.equals(x, inn) ? out : x,\n         toConserve(y => R.equals(y, out) ? inn : y)))\n\nL.default = L.replace(undefined)\nL.required = inn => L.replace(inn, undefined)\nL.define = v => R.compose(L.required(v), L.default(v))\n\nL.normalize = transform =>\n  R.lens(toPartial(transform), toConserve(toPartial(transform)))\n\nL.prop = k =>\n  R.lens(o => o && o[k],\n         (v, o) => v === undefined ? deleteKey(k, o) : setKey(k, v, o))\n\nL.find = predicate => L.choose(xs => {\n  if (xs === undefined)\n    return L.append\n  const i = xs.findIndex(predicate)\n  return i < 0 ? L.append : i\n})\n\nL.findWith = (l, ...ls) => {\n  const lls = L(l, ...ls)\n  return L(L.find(x => R.view(lls, x) !== undefined), lls)\n}\n\nL.index = i => R.lens(xs => xs && xs[i], (x, xs) => {\n  if (x === undefined) {\n    if (xs === undefined)\n      return undefined\n    if (i < xs.length)\n      return dropped(xs.slice(0, i).concat(xs.slice(i+1)))\n    return xs\n  } else {\n    if (xs === undefined)\n      return Array(i).concat([x])\n    if (xs.length <= i)\n      return xs.concat(Array(i - xs.length), [x])\n    if (R.equals(x, xs[i]))\n      return xs\n    return xs.slice(0, i).concat([x], xs.slice(i+1))\n  }\n})\n\nL.append = R.lens(() => {}, (x, xs) =>\n  x === undefined ? xs : xs === undefined ? [x] : xs.concat([x]))\n\nL.filter = p => R.lens(xs => xs && xs.filter(p), (ys, xs) =>\n  conserve(xs, dropped(R.concat(ys || [], (xs || []).filter(R.complement(p))))))\n\nL.augment = template => R.lens(\n  toPartial(x => {\n    const z = {...x}\n    for (const k in template)\n      z[k] = template[k](x)\n    return z\n  }),\n  toConserve((y, c) => {\n    if (y === undefined)\n      return undefined\n    let z\n    const set = (k, v) => {\n      if (undefined === z)\n        z = {}\n      z[k] = v\n    }\n    for (const k in y) {\n      if (!(k in template))\n        set(k, y[k])\n      else\n        if (k in c)\n          set(k, c[k])\n    }\n    return z\n  }))\n\nL.pick = template => R.lens(\n  c => {\n    let r\n    for (const k in template) {\n      const v = L.view(template[k], c)\n      if (v !== undefined) {\n        if (r === undefined)\n          r = {}\n        r[k] = v\n      }\n    }\n    return r\n  },\n  (o = empty, cIn) => {\n    let c = cIn\n    for (const k in template)\n      c = L.set(template[k], o[k], c)\n    return c\n  })\n\nL.identity = R.lens(R.identity, R.identity)\n\nL.props = (k, ...ks) => {\n  const kks = [k, ...ks]\n  return L.pick(R.zipObj(kks, kks))\n}\n\nexport default L\n"]}

package.json

 {
   "name": "partial.lenses",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Ramda compatible partial lenses",
@@ -10,3 +10,3 @@ "main": "lib/partial.lenses.js",
     "prepublish": "npm run lint && npm run test && npm run dist",
-    "test": "node_modules/mocha/bin/mocha"
+    "test": "node_modules/.bin/nyc node_modules/mocha/bin/mocha"
   },
@@ -38,4 +38,5 @@ "repository": {
     "eslint": "2.2.x",
-    "mocha": "^2.4.5"
+    "mocha": "^2.4.5",
+    "nyc": "^6.1.1"
   }
 }

README.md

 [ [Tutorial](#tutorial) | [Reference](#reference) | [Background](#background) ]
 
-This library provides a collection of [Ramda](http://ramdajs.com/) compatible
-*partial* lenses.  While an ordinary lens can be used to view and update an
-existing part of a data structure, a partial lens can *view* optional data,
-*insert* new data, *update* existing data and *delete* existing data and can
-provide *default* values and maintain *required* data structure parts.
+Lenses are a convenient abstraction for performing updates on individual
+elements of immutable data structures.  This library provides a collection of
+[Ramda](http://ramdajs.com/) compatible *partial* lenses.  While an ordinary
+lens can be used to view and update an existing part of a data structure, a
+partial lens can *view* optional data, *insert* new data, *update* existing data
+and *delete* existing data and can provide *default* values and maintain
+*required* data structure parts.
 
@@ -16,3 +18,3 @@ In JavaScript, missing data can be mapped to `undefined`, which is what partial
 
-[![npm version](https://badge.fury.io/js/partial.lenses.svg)](http://badge.fury.io/js/partial.lenses) [![Build Status](https://travis-ci.org/calmm-js/partial.lenses.svg?branch=master)](https://travis-ci.org/calmm-js/partial.lenses) [![](https://david-dm.org/calmm-js/partial.lenses.svg)](https://david-dm.org/calmm-js/partial.lenses) [![](https://david-dm.org/calmm-js/partial.lenses/dev-status.svg)](https://david-dm.org/calmm-js/partial.lenses#info=devDependencies) [![Gitter](https://img.shields.io/gitter/room/calmm-js/chat.js.svg?style=flat-square)](https://gitter.im/calmm-js)
+[![npm version](https://badge.fury.io/js/partial.lenses.svg)](http://badge.fury.io/js/partial.lenses) [![Build Status](https://travis-ci.org/calmm-js/partial.lenses.svg?branch=master)](https://travis-ci.org/calmm-js/partial.lenses) [![](https://david-dm.org/calmm-js/partial.lenses.svg)](https://david-dm.org/calmm-js/partial.lenses) [![](https://david-dm.org/calmm-js/partial.lenses/dev-status.svg)](https://david-dm.org/calmm-js/partial.lenses#info=devDependencies) [![Gitter](https://img.shields.io/gitter/room/calmm-js/chat.js.svg?style=flat-square)](https://gitter.im/calmm-js/chat)
 
@@ -216,18 +218,19 @@ ## Tutorial
 
-Binary search may initially seem to be outside the scope of definable lenses.
-However, the `L.choose` lens allows for dynamic construction of lenses based on
-examining the data structure being manipulated.  Inside `L.choose` we can write
-the ordinary BST logic to pick the correct branch based on the key in the
-currently examined node and the key that we are looking for.  So, here is our
-first attempt at a BST lens:
+Binary search might initially seem to be outside the scope of definable lenses.
+However, given basic BST operations, one could easily wrap them as a primitive
+partial lens.  But could we leverage lens combinators to build a BST lens more
+directly?  We can.  The `L.choose` lens combinator allows for dynamic
+construction of lenses based on examining the data structure being manipulated.
+Inside `L.choose` we can write the ordinary BST logic to pick the correct branch
+based on the key in the currently examined node and the key that we are looking
+for.  So, here is our first attempt at a BST lens:
 
 ```js
-const binarySearch = key =>
+const search = key =>
   L(L.default({key}),
-    L.choose(node =>
-             key < node.key ? L("smaller", binarySearch(key)) :
-             node.key < key ? L("greater", binarySearch(key)) :
-                              L.identity))
+    L.choose(n => key < n.key ? L("smaller", search(key)) :
+                  n.key < key ? L("greater", search(key)) :
+                                L.identity))
 
-const valueOf = key => L(binarySearch(key), "value")
+const valueOf = key => L(search(key), "value")
 ```
@@ -250,3 +253,3 @@
 
-However, the above `binarySearch` lens constructor does not maintain the BST
+However, the above `search` lens constructor does not maintain the BST
 structure when values are being deleted:
@@ -262,25 +265,17 @@
 
-How do we fix this?  What we need is to normalize the data structure after
-changes.  The `L.normalize` lens can be used for that purpose.  Here is the
-updated `binarySearch` definition:
+How do we fix this?  We could check and transform the data structure to a BST
+after changes.  The `L.normalize` lens can be used for that purpose.  Here is
+the updated `search` definition:
 
 ```js
-const binarySearch = key =>
-  L(L.normalize(node => {
-      if (!node)
-        return node
-      if ("value" in node)
-        return node
-      if (!("greater" in node) && "smaller" in node)
-        return node.smaller
-      if (!("smaller" in node) && "greater" in node)
-        return node.greater
-      return L.set(binarySearch(node.smaller.key),
-                   node.smaller,
-                   node.greater)}),
+const search = key =>
+  L(L.normalize(n =>
+      undefined !== n.value   ? n         :
+      n.smaller && !n.greater ? n.smaller :
+      !n.smaller && n.greater ? n.greater :
+      L.set(search(n.smaller.key), n.smaller, n.greater)),
     L.default({key}),
-    L.choose(node =>
-             key < node.key ? L("smaller", binarySearch(key)) :
-             node.key < key ? L("greater", binarySearch(key)) :
-                              L.identity))
+    L.choose(n => key < n.key ? L("smaller", search(key)) :
+                  n.key < key ? L("greater", search(key)) :
+                                L.identity))
 ```
@@ -425,2 +420,9 @@
 
+For example:
+
+```js
+> L.set(L.append, "x", undefined)
+[ 'x' ]
+```
+
 #### [`L.augment({prop: obj => val, ...props})`](#laugmentprop-obj--val-props "L.augment :: {p1 :: o -> a1, ...ps} -> PLens {...o} {...o, p1 :: a1, ...ps}")
@@ -434,2 +436,9 @@
 
+For example:
+
+```js
+> L.over(L.augment({y: r => r.x + 1}), r => ({x: r.x + r.y, y: 2, z: r.x - r.y}), {x: 1})
+{ x: 3, z: -1 }
+```
+
 #### [`L.choose(maybeValue => PLens)`](#lchoosemaybevalue--plens "L.choose :: (Maybe s -> PLens s a) -> PLens s a")
@@ -439,4 +448,24 @@
 the given function that maps the underlying view, which can be undefined, to a
-lens.  The lens returned by the given function will be lifted.
+lens.  In other words, the `L.choose` combinator allows a lens to be constructed
+*after* examining the data structure being manipulated.  The lens returned by
+the function given to `L.choose` will be lifted.
 
+For example, given:
+
+```js
+const majorAxis = L.choose(({x, y} = {}) =>
+  Math.abs(x) < Math.abs(y) ? "y" : "x")
+```
+
+we get:
+
+```js
+> L.view(majorAxis, {x: 1, y: 2})
+2
+> L.view(majorAxis, {x: -3, y: 1})
+-3
+> L.over(majorAxis, R.negate, {x: 2, y: -3})
+{ y: 3, x: 2 }
+```
+
 #### [`L.filter(predicate)`](#lfilterpredicate "L.filter :: (a -> Boolean) -> PLens [a] [a]")
@@ -450,2 +479,9 @@
 
+For example:
+
+```js
+> L.delete(L.filter(x => x <= 2), [3,1,4,1,5,9,2])
+[ 3, 4, 5, 9 ]
+```
+
 *Note:* An alternative design for filter could implement a smarter algorithm to
@@ -465,17 +501,22 @@ combine arrays when set.  For example, an algorithm based on
 
+```js
+> L.deleteAll(L.find(x => x <= 2), [3,1,4,1,5,9,2])
+[ 3, 4, 5, 9 ]
+```
+
 #### [`L.findWith(l, ...ls)`](#lfindwithl-ls "L.findWith :: (PLens s s1, ...PLens sN a) -> PLens [s] a")
 
-`L.findWith(l, ...ls)` is defined as
+`L.findWith(l, ...ls)` chooses an index from an array through which the given
+lens, `L(l, ...ls)`, focuses on a defined item and then returns a lens that
+focuses on that item.
 
+For example:
+
 ```js
-L.findWith = (l, ...ls) => {
-  const lls = L(l, ...ls)
-  return L(L.find(x => L.view(lls, x) !== undefined), lls)
-}
+> L.view(L.findWith("x"), [{z: 6}, {x: 9}, {y: 6}])
+9
+> L.set(L.findWith("x"), 3, [{z: 6}, {x: 9}, {y: 6}])
+[ { z: 6 }, { x: 3 }, { y: 6 } ]
 ```
 
-and basically chooses an index from an array through which the given lens, `L(l,
-...ls)`, focuses on a defined item and then returns a lens that focuses on that
-item.
-
 #### [`L.firstOf(l, ...ls)`](#lfirstofl-ls "L.firstOf :: (PLens s a, ...PLens s a) -> PLens s a")
@@ -527,3 +568,4 @@
 `L.pick({p1: l1, ...pls})` creates a lens out of the given object template of
-lenses.  When viewed, an object is created, whose properties are obtained by
+lenses and allows one to pick apart a data structure and then put it back
+together.  When viewed, an object is created, whose properties are obtained by
 viewing through the lenses of the template.  When set with an object, the
@@ -534,2 +576,37 @@ properties of the object are set to the context via the lenses of the template.
 
+For example, let's say we need to deal with data and schema in need of some
+semantic restructuring:
+
+```js
+const data = {px: 1, py: 2, vx: 1.0, vy: 0.0}
+```
+
+We can use `L.pick` to create lenses to pick apart the data and put it back
+together into a more meaningful structure:
+
+```js
+const asVec = prefix => L.pick({x: prefix + "x", y: prefix + "y"})
+const sanitize = L.pick({pos: asVec("p"), vel: asVec("v")})
+```
+
+We now have a better structured view of the data:
+
+```js
+> L.view(sanitize, data)
+{ pos: { x: 1, y: 2 }, vel: { x: 1, y: 0 } }
+```
+
+That works in both directions:
+
+```js
+> L.over(L(sanitize, "pos", "x"), R.add(5), data)
+{ px: 6, py: 2, vx: 1, vy: 0 }
+```
+
+**NOTE:** In order for a lens created with `L.pick` to work in a predictable
+manner, the given lenses must operate on independent parts of the data
+structure.  As a trivial example, in `L.pick({x: "same", y: "same"})` both of
+the resulting object properties, `x` and `y`, address the same property of the
+underlying object, so writing through the lens will give unpredictable results.
+
 Note that, when set, `L.pick` simply ignores any properties that the given
@@ -551,9 +628,15 @@ template doesn't mention.  Note that the underlying data structure need not be
 
-`L.props(key, ...keys)` focuses on a subset of properties of an object.  The
-view of `L.props` is undefined when none of the properties is defined.
-Otherwise the view is an object containing a subset of the properties.  Setting
-through `L.props` updates the whole subset of properties, which means that any
-undefined properties are removed if they did exists previously.  When set, any
-extra properties are ignored.
+`L.props(k1, ..., kN)` is equivalent to `L.pick({[k1]: k1, ..., [kN]: kN})` and
+focuses on a subset of properties of an object, allowing one to treat the subset
+of properties as a unit.  The view of `L.props` is undefined when none of the
+properties is defined.  Otherwise the view is an object containing a subset of
+the properties.  Setting through `L.props` updates the whole subset of
+properties, which means that any undefined properties are removed if they did
+exists previously.  When set, any extra properties are ignored.
 
+```js
+> L.set(L.props("x", "y"), {x: 4}, {x: 1, y: 2, z: 3})
+{ z: 3, x: 4 }
+```
+
 #### [`L.replace(inn, out)`](#lreplaceinn-out "L.replace :: Maybe s -> Maybe s -> PLens s s")
@@ -565,2 +648,11 @@
 
+For example:
+
+```js
+> L.view(L.replace(1, 2), 1)
+2
+> L.set(L.replace(1, 2), 2, 0)
+1
+```
+
 The main use case for `replace` is to handle optional and required properties
@@ -572,12 +664,38 @@ and elements.  In most cases, rather than using `replace`, you will make
 
-`L.default(out)` is the same as `L.replace(undefined, out)`.
+`L.default(out)` is the same as `L.replace(undefined, out)`.  `L.default` is
+used to specify a default value for an element in case it is missing.  This can
+be useful to avoid having to check for and provide default behavior elsewhere.
 
+For example:
+
+```js
+> L.view(L("items", L.default([])), {})
+[]
+> L.view(L("items", L.default([])), {items: [1, 2, 3]})
+[ 1, 2, 3 ]
+```
+
 ##### [`L.define(value)`](#ldefinevalue "L.define :: s -> PLens s s")
 
 `L.define(value)` is the same as `L(L.required(value), L.default(value))`.
+`L.define` is used to specify a value to act as both the default value and the
+required value for an element.
 
 ##### [`L.required(inn)`](#lrequiredinn "L.required :: s -> PLens s s")
 
-`L.required(inn)` is the same as `L.replace(inn, undefined)`.
+`L.required(inn)` is the same as `L.replace(inn, undefined)`.  `L.required` is
+used to specify that an element is not to be deleted; in case it is deleted, the
+given value will be substituted instead.
 
+For example:
+
+```js
+> L.delete(L("items", 0), {items: [1]})
+undefined
+> L.delete(L(L.required({}), "items", 0), {items: [1]})
+{}
+> L.delete(L("items", L.required([]), 0), {items: [1]})
+{ items: [] }
+```
+
 ## Background
@@ -584,0 +702,0 @@

src/partial.lenses.js

@@ -183,34 +183,5 @@ import R from "ramda"
   const kks = [k, ...ks]
-  return R.lens(
-    (o = empty) => {
-      let r
-      kks.forEach(k => {
-        if (k in o) {
-          if (!r)
-            r = {}
-          r[k] = o[k]
-        }
-      })
-      return r
-    },
-    toConserve((s = empty, o = empty) => {
-      let r
-      for (const k in o) {
-        if (!R.contains(k, kks)) {
-          if (!r)
-            r = {}
-          r[k] = o[k]
-        }
-      }
-      kks.forEach(k => {
-        if (k in s) {
-          if (!r)
-            r = {}
-          r[k] = s[k]
-        }
-      })
-      return r
-    }))
+  return L.pick(R.zipObj(kks, kks))
 }
 
 export default L

test/tests.js

@@ -37,2 +37,3 @@ import R from "ramda"
   testEq('L.prop.length', 1)
+  testEq('L.props.length', 1)
   testEq('L.replace.length', 2)
@@ -67,2 +68,3 @@ testEq('L.required.length', 1)
   testEq('L.view(L(5), [1, 2, 3])', undefined)
+  testEq('L.set(1, "2", ["1", "2", "3"])', ["1", "2", "3"])
 })
@@ -147,2 +149,3 @@
   testEq('L.delete(L(L.augment({y: () => 1}), "x"), {x:0})', undefined)
+  testEq('L.delete(L.augment({z: c => c.x + c.y}), {x: 1, y: 2})', undefined)
 })
@@ -168,31 +171,29 @@
   testEq('L.delete(L.props("x", "y"), {x: 1, y: 2})', undefined)
+  testEq('L.set(L.props("a", "b"), {a: 2}, {a: 1, b: 3})', {a: 2})
 })
 
 const BST = {
-  search: key =>
-    L(L.normalize(node => {
-      if (!node)
-        return node
-      if ("value" in node)
-        return node
-      if (!("greater" in node) && "smaller" in node)
-        return node.smaller
-      if (!("smaller" in node) && "greater" in node)
-        return node.greater
-      return L.set(BST.search(node.smaller.key),
-                   node.smaller,
-                   node.greater)}),
-      L.default({key}),
-      L.choose(node =>
-               key < node.key ? L("smaller", BST.search(key)) :
-               node.key < key ? L("greater", BST.search(key)) :
-                                L.identity)),
+  search: key => {
+    const rec =
+      L(L.normalize(n =>
+          undefined !== n.value   ? n         :
+          n.smaller && !n.greater ? n.smaller :
+          !n.smaller && n.greater ? n.greater :
+          L.set(BST.search(n.smaller.key), n.smaller, n.greater)),
+        L.default({key}),
+        L.choose(n => key < n.key ? L("smaller", rec) :
+                      n.key < key ? L("greater", rec) :
+                                    L.identity))
+    return rec
+  },
+
   valueOf: key => L(BST.search(key), "value"),
-  isValid: (node, keyPred = () => true) =>
-    undefined === node
-    || "key" in node
-    && "value" in node
-    && keyPred(node.key)
-    && BST.isValid(node.smaller, key => key < node.key)
-    && BST.isValid(node.greater, key => node.key < key)
+
+  isValid: (n, keyPred = () => true) =>
+    undefined === n
+    || "key" in n
+    && "value" in n
+    && keyPred(n.key)
+    && BST.isValid(n.smaller, key => key < n.key)
+    && BST.isValid(n.greater, key => n.key < key)
 }
@@ -207,13 +208,15 @@
   it("maintains validity through operations", () => {
-    let t0
-    let t1
+    let before
+    let after
     let op
-    let k
+    let key
 
     const error = () => {
-      throw new Error("From " + show(t0) + " " + op + " with " + k + " gave " + t1)
+      throw new Error("From " + show(before) +
+                      " " + op + " with " + key +
+                      " gave " + show(after))
     }
 
     for (let i=0; i<1000; ++i) {
-      k = randomInt(0, 10)
+      key = randomInt(0, 10)
       op = randomPick("set", "delete")
@@ -223,9 +226,9 @@
         case "set":
-          t1 = L.set(BST.valueOf(k), k, t0)
-          if (undefined === L.view(BST.valueOf(k), t1))
+          after = L.set(BST.valueOf(key), key, before)
+          if (undefined === L.view(BST.valueOf(key), after))
             error()
           break
         case "delete":
-          t1 = L.delete(BST.valueOf(k), t0)
-          if (undefined !== L.view(BST.valueOf(k), t1))
+          after = L.delete(BST.valueOf(key), before)
+          if (undefined !== L.view(BST.valueOf(key), after))
             error()
@@ -235,8 +238,8 @@ break
 
-      if (!BST.isValid(t1))
+      if (!BST.isValid(after))
         error()
 
-      t0 = t1
+      before = after
     }
   })
 })

No alert changes

Improved metrics

Total package byte prevSize

168196

102.89%

Number of package files

21

90.91%

Lines of code

1004

55.9%

Number of lines in readme file

741

18.94%

Worsened metrics

Dev dependency count

8

14.29%

No dependency changes