mbrandonw

Copy and paste the swift code below into a playground to experiment.

This is a very close emulation of Functor and Monad typeclasses in swift. However, it is very fragile (i.e. easy to crash the compiler).

For example, instance methods of fmap will run fine, but attempting to use a globally defined fmap that acts on Functor types will cause a crash. Similarly for bind. Unfortunately this means we cannot define the nice infix operator versions of these functions.

radex

import Foundation

struct Stream {
    let string: NSString
    var position: Int
    
    var matchingRange: NSRange {
        return NSRange(location: position, length: string.length - position)
    }
}

ningsuhen

import Foundation

struct Regex {
    var pattern: String {
        didSet {
            updateRegex()
        }
    }
    var expressionOptions: NSRegularExpressionOptions {
        didSet {

lucamarrocco

import Cocoa


class WindowController: NSWindowController {
}

class AppDelegate: NSObject {
  var mainWindow: NSWindow?
  var mainController: NSWindowController?
}

gist:007bd54b7ed4635014aa

// Some global place
class CollisionMapping
{
    enum Layer : Uint32 {
        Terrain,
        Actors,
    }

    // Maps individual collision types (bird, pipe etc) to a smaller set of
    // more generic types to make them more manageable

steipete

            // This ensures that the automaticallyAdjustsScrollViewInsets magic works
            // On our newly added view controller as well.
            // This triggers _layoutViewController which then triggers
            // _computeAndApplyScrollContentInsetDeltaForViewController:
            // which finally updates our content inset of the scroll view (if any)
            // rdar://19053416
            [self.navigationController.view setNeedsLayout];

JaviLorbada

Videos

• Introduction to Functional Programming Johannes Weiß - https://vimeo.com/100786088
• ReactiveCocoa at MobiDevDay Andrew Sardone - https://vimeo.com/65637501
• The Future Of ReactiveCocoa Justin Spahr-Summers - https://www.youtube.com/watch?v=ICNjRS2X8WM
• Enemy of the State Justin Spahr-Summers - https://www.youtube.com/watch?v=7AqXBuJOJkY
• WWDC 2014 Session 229 - Advanced iOS Application Architecture and Patterns Andy Matuschak - https://developer.apple.com/videos/play/wwdc2014/229/
• Functioning as a Functionalist Andy Matuschak - https://www.youtube.com/watch?v=rJosPrqBqrA
• Controlling Complexity in Swift Andy Matuschak - https://realm.io/news/andy-matuschak-controlling-complexity/

harlanhaskins

Copy and paste the swift code below into a playground to experiment.

This is a very close emulation of Functor and Monad typeclasses in swift. As of Swift 1.2 and Xcode 6.3, this is no longer very fragile.

Unfortunately, the compiler cannot verify the types when passing a function to (>>=). We have to wrap the function in a closure and call it with an explicit argument to compile.

optionalDoubles >>= squareRoot // doesn't compile
optionalDoubles >>= { squareRoot($0) } // compiles

justinwoo

Reposted from Qiita

For almost a year now, I've been using this "flux" architecture to organize my React applications and to work on other people's projects, and its popularity has grown quite a lot, to the point where it shows up on job listings for React and a lot of people get confused about what it is.

Why I'm tired of using and teaching flux

There are a billion explainations on the internet, so I'll skip explaining the parts. Instead, let's cut to the chase -- the main parts I hate about flux are the Dispatcher and the Store's own updating mechanism.

If you use a setup similar to the examples in facebook/flux, and you use flux.Dispatcher, you probably have this kind of flow:

rnapier

// This is pretty clean, but I often dislike chains of temporary variables
// They tend to lead to little bugs when you use the wrong one. Swift's warnings
// and 'let' reduce problems, though.
func pagesFromOpenSearchData(data: NSData) throws -> [Page] {
    let json = try NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions())

    guard      let array  = json as? [JSON]                 else { throw JSONError.BadArray(json) }
    guard case let value  = array[1] where array.count >= 2 else { throw JSONError.OutOfRange }
    guard      let titles = value as? [String]              else { throw JSONError.BadStringList(json) }