EvanDotPro

####################################################################################
##                                                                                ##
##  gittyup() - Easily keep master in sync with upstream.                         ##
##                                                                                ##
##         Author: Evan Coury, http://blog.evan.pro/                              ##
##            URL: https://gist.github.com/1506822                                ##
##                                                                                ##
##  This bash function is a simple shortcut for keeping your local (and public    ##
##  fork / origin remote) master branch up to date and in sync with the upstream  ##
##  master. To use gittyup(), simply drop this in your ~/.bashrc.                 ##

digitaljhelms

Branching

Quick Legend

Description, Instructions, Notes

Instance	Branch

JamieMason

Unfollow everyone on twitter.com

1. Go to https://twitter.com/YOUR_USER_NAME/following
2. Open the Developer Console. (COMMAND+ALT+I on Mac)
3. Paste this into the Developer Console and run it

// Unfollow everyone on twitter.com, by Jamie Mason (https://twitter.com/fold_left)
// https://gist.github.com/JamieMason/7580315
//

CodaFi

##A (Haskell) Monad Is...

A monoid in the category of endofunctors...

Such that the following diagrams commute

##Mu Reduction

 μT

henryboldi

  'GET /api/notifications': 'NotificationController.show',
  
  'GET /hacks/isEncoded/:id': 'HacksController.isEncoded',

  'POST /api/notifications': 'APNSUserController.subscribe',

  'PUT /api/notifications/:id': 'NotificationController.see',

  'DELETE /api/notifications/:id': 'NotificationController.destroy',

mattdenner

I’ve been writing a load of Swift code recently for work and this has lead me into the world of typed functional programming. The app needs to build certain objects from a comma separated string, and this lead me to applicative functors, which lead me to brain ache but enlightenment. So here’s my thoughts on how I got to understand these a little better.

All of the code is in Swift, so less clean than Haskell. I’m also only a about 6 weeks into Swift development so I probably haven’t got all of the idioms right. I’ve avoided the optional shorthand wherever possible here, preferring Optional<Type> over Type? because I believe the latter is hiding something that helps understand this code in the context of other generic classes.

It’s also long! I think it’s probably the longest blog post I’ve ever written but I found it interesting and useful, for myself, to write. If you’re one of those people who skip to the end of a book to find out whodunit then I’ve included

NSStringVariations.m

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        void (^benchmark)(const char *str) = ^(const char *str) {
            const long count = 10000000;
            NSDate *start = [NSDate date];
            for (long i = 0; i < count; i++) {
                (void)[[NSString alloc] initWithUTF8String:str];
            }

JadenGeller

/*
 * attempt takes a function that does not accept optional values
 * and returns a new function that will work as usual with non-optional values
 * and return nil when passed an optional value
 */
 
func attempt<T,U>(f: T -> U)-> T? -> U? {
    return { y in
        if let x = y {
            return f(x)

JadenGeller

/*
 * chain takes in any number of 1-argument functions as arguments
 * and returns a function that executes each function in order
 */

func chain<T>(all: T -> () ...) -> T -> () {
    return { x in
        for f in all { f(x) }
    }
}

JadenGeller

extension Bool {
    init<T : IntegerType>(_ integer: T){
        self.init(integer != 0)
    }
}

// Now you can do this
let x = Bool(5)  // true
let y = Bool(-1) // true
let z = Bool(0)  // false