Avaq

Algebraic Law Cheatsheet

An overview of algebraic laws from the perspective of a functional programmer. I've used a Haskell-esque syntax for the definitions of the laws and examples.

General Laws

name	definition	example
Identity [¹][]	f x = x	add 0 42 = 42

Avaq

Keybase proof

I hereby claim:

• I am avaq on github.
• I am avaq (https://keybase.io/avaq) on keybase.
• I have a public key ASAlzUb3ZvdW8CYnTo0SaI0TuaSBUyNS9vxUUFYFbDpgUgo

To claim this, I am signing this object:

Avaq

Fluture v12 Upgrade Guide

Modular version made compatible with Node 12

The modular version of Fluture no longer works with Node version 9, 10, and 11 using --experimental-modules. In order to load the modular version into those runtimes, one has to use the esm loader.

Furthermore, the modular code must now be "deep" imported from fluture/index.js. That is, import 'fluture/index.js' for EcmaScript modules, or require ('fluture') for CommonJS modules.

Future constructor no longer overloaded

Avaq

-- Create our directories table.
CREATE TABLE `directories` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `lft` int(11) NOT NULL,
  `rgt` int(11) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `directory_lft` (`lft`),
  UNIQUE KEY `directory_rgt` (`rgt`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Avaq

//    pipe :: Array (Any -> Any) -> Any -> Any
const pipe = fs => x => fs.reduce ((y, f) => f (y), x)

//    lmap :: (a -> b) -> Array a -> Array b
const lmap = f => xs => xs.map (f)

//    append :: a -> Array a -> Array a
const append = x => xs => [...xs, x]

Avaq

# Exit with code 1 if the FILE has *modified* lines
git diff --quiet $FILE || [ $(git diff --numstat $FILE | cut -f 2) = '0' ]

# Output a visual graph of commits
git log --all --graph --pretty='format:%C(auto)%h% D%Creset %Cgreen%an, %ar%Creset %C(white)(%s)%Creset'

Avaq

const after = t => x => cont => {
  const id = setTimeout (cont, t, x)
  return () => clearTimeout (id)
}

const map = f => run => cont => run(x => cont (f (x)))
const chain = f => run => cont => run(x => f (x) (cont))

const run = chain (x => after (2000) (`${x}C`))
                  (map (x => `${x}B`)

Avaq

//
// utils
//

const thrush = x => f => f(x);

const indexBy = k => xs => xs.reduce((index, x) => {
  if(index[x[k]] != null) index[x[k]].push(x);
  else index[x[k]] = [x];
  return index;

Avaq

const after = (n, x) => Future((l, r) => setTimeout(r, n, x));

const Do = (f, of) => {
  return of(undefined).chain(() => {
    const g = f()
    const step = value => {
    const result = g.next(value)
    return result.done ?
           of(result.value) :
           result.value.chain(step)

Avaq

Ramda	Sanctuary
add(a, b)	add(b, a)
addIndex(f)	``
adjust(f, i, xs)	``
all(f, xs)	``
allPass(fs, x)	allPass(fs, x)
always(x)	K(x)
and(a, b)	and(a, b)
any(f, x)	``