Mark McDonnell Integralist

On the PR branch
git rebase -i master (i.e. git rebase -i {parent_commit_of_first_commit_in_PR})
Change top commit (the oldest) to reword
Change all other commits to fixup
In commit message (line 1) change title to reflect entire PR
In commit message (line 2) add Closes #n and/or Fixes #n
In commit message (line 3) add Authors: @integralist
git checkout master
git merge {PR_branch} or git cherry-pick {new_rebased_commit}
git branch -D {PR_branch}

Update

This gist has been superseded by https://github.com/Integralist/Data-Structures and also https://www.integralist.co.uk/data-types-and-data-structures/

Note:
sequential == collection keeps order of population
ordered == collection is re-ordered (implements a Sequence interface)

This code is modified from the excellent O'Reilly book "Functional JavaScript". You should buy it, I highly recommend it! Don't kid yourself into thinking this gist even remotely covers the great content from a 200+ page technical book on the subject; it doesn't. Buy the book and get the in-depth knowledge for yourself. It's worth it.

Composability through higher order functions
Parsing CSV (ES5 version)
Parsing CSV (LoDash version)
Abstract away conditionals
Data construction
[Currying and Partial Application](https://gist.github.com/Integralist/b7ed2e337a0b5cbbecce/#file-06-currying-and-parti

Dynamic Dispatch
Dynamic Method
Ghost Methods
Dynamic Proxies
Blank Slate
Kernel Method
Flattening the Scope (aka Nested Lexical Scopes)
Context Probe
Class Eval (not really a 'spell' more just a demonstration of its usage)
Class Macros

Below is an example of trying to protect against a request for data failing to return the expected data structure (in this case an Array)...

expect_an_array_back = SomeClass.make_a_request_for_data

if expect_an_array_back.any?
  expect_an_array_back.each do |user|
    # ...
  end
end

	// The Monad design pattern functions
	// i.e. compose, bind, unit, lift

	// These are functions that are part of the design pattern's "interface"
	// Their implementation can change (well, maybe not `compose`)
	// but these function identifiers should be implemented
	// as other devs will use those identifiers as a common language
	// when discussing the Monad pattern

	// compose = returns a function that takes a data structure (accepted data structure argument is passed to `g` and then result of that is passed to `f`)

	git show HEAD HEAD~1 # (or use a hash instead: `git show {commit} {commit} {commit}`)

	git diff --cached \| gist -p -f test.diff

	curl https://gist.githubusercontent.com/anonymous/x/raw/x/test.diff \| git apply

	curl https://gist.githubusercontent.com/anonymous/x/raw/x/test.diff \| git apply --reverse

	# Examples taken from ThoughtBot's Weekly Iteration
	# We need to implement a solution that allows us to cleanly use two separate APIs

	# Our fake APIs
	PayPal.charge!(auth_code, 25)
	Stripe::CreditCard.new(credit_card_token).charge(25)

	// Copied from http://javascriptweblog.wordpress.com/2010/06/14/dipping-into-wu-js-autocurry/
	var autoCurry = (function () {

	var toArray = function toArray(arr, from) {
	return Array.prototype.slice.call(arr, from \|\| 0);
	},

	curry = function curry(fn /* variadic number of args */) {
	var args = toArray(arguments, 1);
	return function curried() {

	\|— Gruntfile
	\|— package.json
	\|— grunt
	\| – contrib-requirejs.js