Carl Albrecht-Buehler dinocarl

Keyboard Basics

Keycap: [Plastic outer covering][keycaps] of a particular key typically inscribed with the character that gets sent to the computer when struck.
PCB: Printed Circuit Board (really, just a circuit board), which registers keystrokes and sends them to the computer.
Switch: underlying mechanism that the keycap covers, and in some way creates contact with the PCB to let it know that a keystroke needs

I hereby claim:

To claim this, I am signing this object:


	// accepts an argument object and a data object.
	// first returns the value at lookupName in the data object
	// and then applies the value of that back onto the data object
	// treating it as meta data about the data object, eg
	// lookWIthin(
	// { lookupName: 'currPage', endOfPath: ['position'] },
	// { currPage: 'page!', page!: {position: 55} }
	// ) => 55
	const lookWithin = ({ lookupName, endOfPath = [] }) => compose(

	const juxtMerge = (fnList) => compose(
	mergeAll,
	juxt(fnList)
	);

	// given an object, a foreignKey (name), and a lookup object
	// containing data keyed to the foreignKey,
	// return the data of the lookup, or a fallback value
	const propOfPropOr = (fallback, foreignKey, lookup) => (item) => propOr(
	fallback,

	const eq = (a) => (b) => a === b;

	const everyItemEquala = compose(
	apply(all),
	juxt([compose(equals, head), identity])
	);

	const everyItemEqualb = compose(
	equals(1),
	length,

	const data = {'a.b': 1, 'c.d': 7, 'c.d': 9}

	const assocPathDataLast = curry(
	(mergeAble, pathList, val) => assocPath(pathList, val, mergeAble)
	);

	const processKeys = compose(
	split('.'),
	head
	);

	const clamp = (min, max, x) => Math.min(Math.max(x, min), max);

	const clmp = (minVal, maxVal) => compose(
	min(maxVal),
	max(minVal)
	);

	// Given a value with a unit
	// return the value without the unit
	@function strip-unit($item) {
	@if type-of($item) == 'number' and not unitless($item) {
	@return $item / ( $item * 0 + 1 );
	}

	@return $item;
	}