# [▶](https://calmm-js.github.io/partial.lenses/exercises.html#) Partial Lenses Exercises · [](https://gitter.im/calmm-js/chat) [](https://github.com/calmm-js/partial.lenses) [](https://www.npmjs.com/package/partial.lenses)
This page contains exercises for the [Partial Lenses](/#) library. Each
exercise asks you to implement an [optic](/#optics) or [transform](/#transforms)
using Partial lenses. An acceptable solution will then make all the `test(
... )` cases to log `Ok`. In case a `test( ... )` doesn't pass it logs `Error`
and the (wrong) result.
Most of the exercises include hints that you can reveal by placing the pointer
over them. The hints are written with a particular solution in mind, but it is
often possible to solve a particular exercise in more than one way.
Suggestions for additional exercises are welcome!
## Contents
* [Lenses](#lenses)
* [Getter and Setter](#getter-and-setter)
* [Nested objects](#nested-objects)
* [Association list](#association-list)
* [Dimorphic ranges](#dimorphic-ranges)
* [Traversals](#traversals)
* [Xces](#xces)
* [Nested properties](#nested-properties)
* [Isomorphisms](#isomorphisms)
* [Inverse puzzle](#inverse-puzzle)
* [Transforms](#transforms)
* [Increment and Decrement](#increment-and-decrement)
## Lenses
### Getter and Setter
* Complete the getter and setter for `L.lens` to access the `part` field of an
object.
* Use `Object.assign` in the setter.
* Then replace the whole thing using the [`L.prop`](/#L-prop) shorthand, which
also supports [removal](/#L-remove).
* `const lens = 'part'`
```js
const lens = L.lens(
/* getter: */whole => '???',
/* setter: */(part, whole) => '???'
)
const whole = {
part: 101
}
test('get', L.get(lens, whole), 101)
test('set', L.set(lens, 42, whole), {part: 42})
test('mod', L.modify(lens, R.negate, whole), {part: -101})
test('no-mutate', whole, {part: 101})
```
### Nested objects
* Create a lens to access `inside.part`.
* Use the [`L.compose`](/#L-compose) shorthand
notation.
* Make it so that when `part` is removed then so is the whole object.
* Use [`L.removable`](/#L-removable).
```js
const lens = '???'
const nested = {
inside: {
part: 101,
more: 'stuff'
}
}
test('get', L.get(lens, nested), 101)
test('set', L.set(lens, 42, nested), {inside: {part: 42, more: 'stuff'}})
test('mod', L.modify(lens, R.negate, nested), {inside: {part: -101, more: 'stuff'}})
test('rem', L.remove(lens, nested), undefined)
```
### Association list
* Write a function `valOf` to return a lens to access value with given key.
* Compose a lens that uses [`L.find`](/#L-find) to
search for an object with the given key.
* Support removal.
* Use [`L.removable`](/#L-valueOr).
* Support insertion and make it so that keys remain ordered.
* Use [`L.valueOr`](/#L-valueOr) to add the `key`
property in case there is no matching object.
* Use [`L.rewrite`](/#L-rewrite) to sort by
`key`.
```js
const valOf = key => '???'
const data = [{key: 'en', val: 'Title'},
{key: 'sv', val: 'Rubrik'}]
test('get', L.get(valOf('en'), data), 'Title')
test('set', L.set(valOf('en'), 'The title', data), [{key: 'en', val: 'The title'}, {key: 'sv', val: 'Rubrik'}])
test('rem', L.remove(valOf('en'), data), [{key: 'sv', val: 'Rubrik'}])
test('emp', L.remove(valOf('sv'), L.remove(valOf('en'), data)), [])
test('ins', L.set(valOf('fi'), 'Otsikko', data), [{key: 'en', val: 'Title'}, {key: 'fi', val: 'Otsikko'}, {key: 'sv', val: 'Rubrik'}])
```
### Dimorphic ranges
* Implement the `end` lens to access the end of range objects that may take one
of two different forms.
* Using [`L.lens`](/#L-lens), write a custom lens
to access the end of `{start, num}` pair.
* Use [`L.ifElse`](/#L-ifElse) or
[`L.choices`](/#L-choices) to select between `'end'` and the custom
lens.
* Enhance the lens to allow additional fields beyond `start`, `end` / `num` in a
range object.
* Use [`L.props`](/#L-props) to limit the fields that the
lens deals with.
```js
const end = '???'
test('get_num', L.get(end, {start: 1, num: 2}), 3)
test('get_end', L.get(end, {start: 1, end: 3}), 3)
test('set_num', L.set(end, 4, {start: 1, num: 2}), {start: 1, num: 3})
test('set_end', L.set(end, 4, {start: 1, end: 3}), {start: 1, end: 4})
test('set_ext', L.set(end, 4, {start: 1, num: 2, xtra: 'field'}), {start: 1, num: 3, xtra: 'field'})
```
## Traversals
### Xces
* Define a traversal that targets the `x` properties of the coordinate pairs.
* Compose [`L.elems`](/#L-elems) and
[`'x'`](/#L-prop).
* Support removal so that the whole coordinate pair is removed.
* Use [`L.removable`](/#L-removable).
```js
const xs = '???'
const coords = [
{x: 3, y: 9},
{x: 1, y: 2},
{x: 4, y: 6},
{x: 1, y: 5},
{x: 5, y: 3}
]
test('max', L.maximum(xs, coords), 5)
test('neg', L.modify([xs, L.when(x => 3 < x)], R.negate, coords), [
{x: 3, y: 9},
{x: 1, y: 2},
{x: -4, y: 6},
{x: 1, y: 5},
{x: -5, y: 3}
])
test('rem', L.remove([xs, L.when(x => x < 3)], coords), [
{x: 3, y: 9},
{x: 4, y: 6},
{x: 5, y: 3}
])
test('emp', L.remove([xs, L.when(x => 0 < x)], coords), [])
```
### Nested properties
* Implement a `nonObject` traversal that targets all non-object or primitive
properties of arbitrarily nested objects.
* Use [`L.ifElse`](/#L-ifElse) to select whether to treat
target as an object or primitive.
* Use [`L.values`](/#L-values) to traverse through all
properties of an object.
* You will need a recursive lens.
* Use [`L.lazy`](/#L-lazy) to allow recursion.
```js
const nonObjects = '???'
test('max', L.maximum(nonObjects, {a: 1, b: {c: 2, d: {e: 5}}, e: 3}), 5)
test('mod', L.modify(nonObjects, R.of, {x: {y: {z: {w: 1}}}}), {x: {y: {z: {w: [1]}}}})
```
## Isomorphisms
### Inverse puzzle
* Solve for `iso`.
* Use [`L.complement`](/#L-complement) on the booleans.
* Lift with [`L.array`](/#L-array) to complement them.
* Use [`L.pick`](/#L-pick) to convert object shapes.
* Use [`L.json`](/#L-json) to convert between JSON and objects.
```js
const iso = '???'
test('inv', L.getInverse(L.inverse(iso), '{"foo":[true,false,true]}'), '{"bar":[false,true,false]}')
test('get', L.get(L.inverse(iso), '{"bar":[true]}'), '{"foo":[false]}')
```
## Transforms
### Increment and Decrement
* Implement transform `trn` that increments primitives under `xs` and decrements
under `ys`.
* Use [`L.modifyOp`](/#L-modifyOp) on the leafs.
* Use [`L.branch`](/#L-branch) to do different things to
`xs` and `ys`.
* Use [`L.elems`](/#L-elems) and [`L.values`](/#L-values)
to get to the leafs.
```js
const trn = '???'
test('sol', L.transform(trn, {xs: {a:3, b:1, c:4}, ys: [1, 5, 9]}),
/**/ {xs: {a:4, b:2, c:5}, ys: [0, 4, 8]})
```