gatlin · June 5, 2025 19:20
diff --git a/gistfile1.txt b/gistfile1.txt
 /*
 * (!) You can go to https://repl.it/languages/javascript, paste all this code
 * in there, and try it out for yourself!
 */

 'use strict';
 /*
 *
 * What is a lens?
 *
 * A lens, basically, takes a structure and breaks out a part from the whole,
 * allowing you to do something with or to the part before reconstructing the
 * whole. Much like a tangible optical lens it lets you focus on some smaller
 * part of a larger object.
 *
 * That "something" can be changing the value or merely passing the value
 * elsewhere to be read.
 *
 * More technically, a lens is a function of three arguments:
 *
 *   1. Some structure (eg an Object, an Array, etc);
 *   2. An index specifying some piece of the structure; and
 *   3. A function which transforms that piece
 *
 * The lens then returns a new structure, with its transformed piece inside.
 *
 * Lenses have several very neat properties.
 *
 * First, a lens defined for part of some structure may be used as both a
 * setter and a getter. This means you only need to define a lens once to use
 * it for reading and writing.
 *
 * Because lenses are functions, they may be composed.
 *
 * First, let's define some things we know we'll need, to wit:
 *
 *   - A way to replace part of a structure at a certain key with a new value;
 *   - A way to compose functions.
 */

 if(!Function.prototype.compose) {
    Function.prototype.compose = function(g) {
        let f = this;
        return function(x) {
            return f(g(x));
        };
    };
 }

 let replace = function(key, value, thing) {
    thing[key] = value;
    return thing;
 };

 /*
 * Now, on to lenses. A lens breaks a part from a whole, passes the part to a
 * function, and puts the result back into the whole. Intuitively, then,
 * whether or not a lens is used as a setter or a getter rests on that function
 * we pass in.
 *
 * This function we pass to the lens must return something we can put back in
 * the whole -- or at the very least, lead us to something which fits the bill.
 *
 * My strategy will be to write two functions which **both** take a value and
 * return an object with two properties:
 *
 *   - a reference to the wrapped-up value; and
 *   - a function to let us transform that value.
 *
 * Some of you may have already guessed it, but I'm basically defining two
 * functors:
 */

 let Setter = (x) => Object.seal({
    value: x,
    map: (f) => Setter(f(x))
 });

 let Getter = (x) => Object.seal({
    value: x,
    map: (f) => Getter(x)
 });

 let extract = (s) => s.value;

 let setTest = Setter(5);
 console.log(extract(setTest.map((x) => x*2))); // 10

 let getTest = Getter(5);
 console.log(extract(getTest.map((x) => x*2))); // 5

 /*
 * The key here is uniformity: both Setter and Getter wrap up a value and allow
 * me to at least pretend I'm transforming the value inside. Setter lets me do
 * it; Getter doesn't. Simple.
 *
 * The uniform way to transform the value inside is the `map()` method.
 *
 * Armed with these two functions, we can finally write the lens function:
 */

 let lens = (key) => (fn) => (s) => fn(s[key]).map((v) => replace(key, v, s));

 /*
 * Note that I'm writing this function in *curried* style. This is mostly for
 * stylistic reasons but it does make the code more readable and usable later
 * on. You'll see.
 *
 * So now we can create lenses!
 */

 let myself = {
    name: 'gatlin',
    age: 27,
    dogs: [{
        name: 'louie', breed: 'pug'
    }, {
        name: 'pugzy', breed: 'pug'
    }]
 };

 let nameL = lens('name'); // <-- this is why we curried the function
 let ageL  = lens('age');
 let dogsL = lens('dogs');
 let dogAt = (idx) => dogsL.compose(lens(idx));

 let rename = (thing, newName) => set(nameL)(newName)(thing);

 /*
 * So how do we *use* these fancy new lenses? Lets first tackle reading, or
 * "getting", a value from a structure using a lens:
 */

 let get = (l) => (s) => extract.compose(l(Getter))(s);

 /*
 * This is a function which takes a lens and a structure. The `l` variable is a
 * lens, which means that it is going to need a transformation function and
 * then a value. so `l(Getter)` returns a function that needs a structure given
 * to it (which would be `s`). However, ultimately we don't want a `Getter`
 * object, we want the value inside it. So we compose `extract` with all this
 * to retrieve the final value.
 *
 * As for setting, that's a special case of a more general operation:
 * transforming a part of a whole. Replacement is one kind of transformation.
 * For historical reasons let's define this more general kind of mutation as
 * `over`:
 */

 let over = (l) => (f) => (s) => extract.compose(l(Setter.compose(f)))(s);

 /*
 * Let's unpack this. `over` requires a lens, a transformation function, and a
 * structure. We compose `Setter` and our transformation function, creating a
 * `Setter` containing the new value we want to put back in the whole. Then we
 * pass this resulting function to our lens `l`, creating a new function asking
 * for a structure. And again, as with `Getter`, we ultimately want the object
 * back, not the `Setter` object, so we compose `extract` with all this.
 *
 * Pause and re-read this a few times if you need to; I'll wait.
 *
 * So actually *setting* a value is a special case of `over` where our
 * transformation function takes the value we want to set, the original value,
 * and returns the value we want to set. This function is called `constant`:
 */

 let constant = (x) => (y) => x;
 let set = (l) => (v) => (s) => over(l)(constant(v))(s);

 /*
 * Now let's try out our lenses!
 */

 console.log(myself);
 rename(myself, 'Gatlin');
 console.log(get(nameL)(myself));

 // Lenses compose!
 set(
 	dogAt(0).compose(nameL)
 )('Louie')(myself);

 // But we can also retrieve a part and use existing lens-based functions on them!
 let pugzy = get(dogAt(1))(myself);
 rename(pugzy,'Pugzy');

 console.log(myself);
	/*
	* (!) You can go to https://repl.it/languages/javascript, paste all this code
	* in there, and try it out for yourself!
	*/

	'use strict';
	/*
	*
	* What is a lens?
	*
	* A lens, basically, takes a structure and breaks out a part from the whole,
	* allowing you to do something with or to the part before reconstructing the
	* whole. Much like a tangible optical lens it lets you focus on some smaller
	* part of a larger object.
	*
	* That "something" can be changing the value or merely passing the value
	* elsewhere to be read.
	*
	* More technically, a lens is a function of three arguments:
	*
	* 1. Some structure (eg an Object, an Array, etc);
	* 2. An index specifying some piece of the structure; and
	* 3. A function which transforms that piece
	*
	* The lens then returns a new structure, with its transformed piece inside.
	*
	* Lenses have several very neat properties.
	*
	* First, a lens defined for part of some structure may be used as both a
	* setter and a getter. This means you only need to define a lens once to use
	* it for reading and writing.
	*
	* Because lenses are functions, they may be composed.
	*
	* First, let's define some things we know we'll need, to wit:
	*
	* - A way to replace part of a structure at a certain key with a new value;
	* - A way to compose functions.
	*/

	if(!Function.prototype.compose) {
	Function.prototype.compose = function(g) {
	let f = this;
	return function(x) {
	return f(g(x));
	};
	};
	}

	let replace = function(key, value, thing) {
	thing[key] = value;
	return thing;
	};

	/*
	* Now, on to lenses. A lens breaks a part from a whole, passes the part to a
	* function, and puts the result back into the whole. Intuitively, then,
	* whether or not a lens is used as a setter or a getter rests on that function
	* we pass in.
	*
	* This function we pass to the lens must return something we can put back in
	* the whole -- or at the very least, lead us to something which fits the bill.
	*
	* My strategy will be to write two functions which both take a value and
	* return an object with two properties:
	*
	* - a reference to the wrapped-up value; and
	* - a function to let us transform that value.
	*
	* Some of you may have already guessed it, but I'm basically defining two
	* functors:
	*/

	let Setter = (x) => Object.seal({
	value: x,
	map: (f) => Setter(f(x))
	});

	let Getter = (x) => Object.seal({
	value: x,
	map: (f) => Getter(x)
	});

	let extract = (s) => s.value;

	let setTest = Setter(5);
	console.log(extract(setTest.map((x) => x*2))); // 10

	let getTest = Getter(5);
	console.log(extract(getTest.map((x) => x*2))); // 5

	/*
	* The key here is uniformity: both Setter and Getter wrap up a value and allow
	* me to at least pretend I'm transforming the value inside. Setter lets me do
	* it; Getter doesn't. Simple.
	*
	* The uniform way to transform the value inside is the `map()` method.
	*
	* Armed with these two functions, we can finally write the lens function:
	*/

	let lens = (key) => (fn) => (s) => fn(s[key]).map((v) => replace(key, v, s));

	/*
	* Note that I'm writing this function in curried style. This is mostly for
	* stylistic reasons but it does make the code more readable and usable later
	* on. You'll see.
	*
	* So now we can create lenses!
	*/

	let myself = {
	name: 'gatlin',
	age: 27,
	dogs: [{
	name: 'louie', breed: 'pug'
	}, {
	name: 'pugzy', breed: 'pug'
	}]
	};

	let nameL = lens('name'); // <-- this is why we curried the function
	let ageL = lens('age');
	let dogsL = lens('dogs');
	let dogAt = (idx) => dogsL.compose(lens(idx));

	let rename = (thing, newName) => set(nameL)(newName)(thing);

	/*
	* So how do we use these fancy new lenses? Lets first tackle reading, or
	* "getting", a value from a structure using a lens:
	*/

	let get = (l) => (s) => extract.compose(l(Getter))(s);

	/*
	* This is a function which takes a lens and a structure. The `l` variable is a
	* lens, which means that it is going to need a transformation function and
	* then a value. so `l(Getter)` returns a function that needs a structure given
	* to it (which would be `s`). However, ultimately we don't want a `Getter`
	* object, we want the value inside it. So we compose `extract` with all this
	* to retrieve the final value.
	*
	* As for setting, that's a special case of a more general operation:
	* transforming a part of a whole. Replacement is one kind of transformation.
	* For historical reasons let's define this more general kind of mutation as
	* `over`:
	*/

	let over = (l) => (f) => (s) => extract.compose(l(Setter.compose(f)))(s);

	/*
	* Let's unpack this. `over` requires a lens, a transformation function, and a
	* structure. We compose `Setter` and our transformation function, creating a
	* `Setter` containing the new value we want to put back in the whole. Then we
	* pass this resulting function to our lens `l`, creating a new function asking
	* for a structure. And again, as with `Getter`, we ultimately want the object
	* back, not the `Setter` object, so we compose `extract` with all this.
	*
	* Pause and re-read this a few times if you need to; I'll wait.
	*
	* So actually setting a value is a special case of `over` where our
	* transformation function takes the value we want to set, the original value,
	* and returns the value we want to set. This function is called `constant`:
	*/

	let constant = (x) => (y) => x;
	let set = (l) => (v) => (s) => over(l)(constant(v))(s);

	/*
	* Now let's try out our lenses!
	*/

	console.log(myself);
	rename(myself, 'Gatlin');
	console.log(get(nameL)(myself));

	// Lenses compose!
	set(
	dogAt(0).compose(nameL)
	)('Louie')(myself);

	// But we can also retrieve a part and use existing lens-based functions on them!
	let pugzy = get(dogAt(1))(myself);
	rename(pugzy,'Pugzy');

	console.log(myself);
No results found