Integralist

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

Integralist

// 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`)

Integralist

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

Integralist

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)

Integralist

# 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)

Integralist

// 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() {

Integralist

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

Integralist

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

Integralist

• 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

Integralist

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