landonf

A result type (based on swiftz) that can represent either an error or success:

enum Result<X, T> {
  case Err(() -> X)
  case Ok(() -> T)
}

Now we need a way to chain multiple results together without lots of nesting of if statements -- or exceptions. To do so, we can define a new bind (result, next) operator (implementation borrowed from swiftz) that operates on Result types (a.k.a flatMap or >>=):

• If the result is Err, the result is immediately returned.

alyssais

import Darwin

let isLittleEndian = Int(OSHostByteOrder()) == OSLittleEndian

let htons  = isLittleEndian ? _OSSwapInt16 : { $0 }
let htonl  = isLittleEndian ? _OSSwapInt32 : { $0 }
let htonll = isLittleEndian ? _OSSwapInt64 : { $0 }
let ntohs  = isLittleEndian ? _OSSwapInt16 : { $0 }
let ntohl  = isLittleEndian ? _OSSwapInt32 : { $0 }
let ntohll = isLittleEndian ? _OSSwapInt64 : { $0 }

andyshep

#import <Foundation/Foundation.h>

#import "PASConstants.h"
#import "PASViewController.h"

@interface PASHideDetailAnimator : NSObject <UIViewControllerAnimatedTransitioning>

@end

@implementation PASHideDetailAnimator

patrickt

enum Either<A, B> {
    case Left(A)
    case Right(B)
}

func isLeft<A,B>(it : Either<A,B>) -> Bool {
    switch it { case .Left: return true; case .Right: return false }
}

func isRight<A,B>(it : Either<A,B>) -> Bool {

intrepidmatt

operator infix ^= {
}

operator infix *= {
}

operator infix * {
}

operator infix % {

how_to_use_swift_in_terminal.md

How to use swift in your terminal

setup

First, install Xcode 6 beta.

And run it.

sudo xcode-select -switch /Applications/Xcode6-Beta.app/Contents/Developer

jfager

//! Monad chain macro in Rust
//!
//! A typical usage is to avoid nested match expressions.
//!
//! Supports:
//! - Pattern matching
//! - Or expressions (A | B => ...)
//! - Guarded statements (x if <cond> => ...)

#[feature(macro_rules)];

bvssvni

//! Chain macro in Rust
//!
//! A typical usage is to avoid nested match expressions.
//!
//! Supports:
//! - Pattern matching
//! - Or expressions (A | B => ...)
//! - Guarded statements (x if <cond> => ...)
//! - Implicit else (requires all arms to return same type)

brendanzab

//! Leveraging tuples to make a statically typed, concatenative EDSL in Rust.
//!
//! I'm not sure how practical it really is – Rust's syntax can make it a little
//! hard to read, but it's fun to play around with it. The neat thing is how
//! little copying occurs. Everything is moved in and out by-value in a pipeline.
//!
//! Thanks goes to [Tekmo on reddit](http://www.reddit.com/r/programming/
//! comments/1zzom4/using_functionlength_to_implement_a_stack_language/cfyibsr)
//! for the idea.
//!

seanlilmateus

module AsyncAwait

  class Task < NSOperation

    def self.new(&block)
      alloc.initWithBlock(block)
    end

    def initWithBlock(block)
      init.tap do