swift,Code片段,代码实例,代码示例,代码片段库

swift Swift null合并运算符

Swift null合并运算符

gistfile1.swift

operator infix || {}
@infix func ||<T>(lhs: T?, rhs: T) -> T {
    return lhs ? lhs! : rhs
}

swift 加工风格测试 - 斯威夫特

加工风格测试 - 斯威夫特

GameScene.swift

//Source : http://www.gamefromscratch.com/post/2014/06/13/Game-development-tutorial-Swift-and-SpriteKit-Part-2-Using-Sprites-and-by-default-SKNodes.aspx

import SpriteKit

class GameScene: SKScene {
    
    var shipSpeed = CGFloat()
    let sprite = SKSpriteNode(imageNamed: "sprite1")
    
    override func didMoveToView(view: SKView) {
        
        let backGroundSprite = SKSpriteNode(imageNamed: "background")
        backGroundSprite.position = CGPoint(x:0,y:0)
        backGroundSprite.anchorPoint = CGPoint(x:0.0,y:0.0)
        backGroundSprite.size = view.bounds.size
        self.addChild(backGroundSprite)
        
        sprite.anchorPoint = CGPoint(x:0.5,y:0.5)
        sprite.position.x = 100;
        sprite.position.y = 100;
        sprite.xScale = 1
        sprite.yScale = 1
        self.addChild(sprite)
        
        
        var shapeArr : Array<SKNode> = []
        for index in 0...5 {
            var shapeE = RectE().simpleView(CGFloat(index)*100)
            shapeArr.append(shapeE)
            self.addChild(shapeArr[index])
        }
        
    }
    
    override func update(currentTime: NSTimeInterval) {
        
        if ((sprite.position.x>0)&&(sprite.position.x < view.bounds.width)) {
            shipSpeed = 5
        } else {
            shipSpeed = 0
            sprite.position.x = 0
        }
        
        sprite.position.x += shipSpeed
        
    }
    
    override func mouseDown(theEvent: NSEvent!) {
        self.sprite.position = CGPoint(x:theEvent.locationInWindow.x,y:theEvent.locationInWindow.y)
    }
    
}


class RectE: SKScene  {
    
    let shapeEle = SKSpriteNode()
    
    func simpleView(_x: CGFloat) -> SKNode {
        shapeEle.color = SKColor.redColor()
        shapeEle.position = CGPointMake(_x, 400)
        shapeEle.size = CGSizeMake(50, 50)
        return shapeEle
    }
    
}

AppDelegate.swift

import Cocoa
import SpriteKit

class AppDelegate: NSObject, NSApplicationDelegate {
    
    @IBOutlet var window: NSWindow
    @IBOutlet var skView: SKView
    
    func applicationDidFinishLaunching(aNotification: NSNotification?) {
        let scene = GameScene(size:self.skView.bounds.size)
        scene.scaleMode = .AspectFill
        
        self.skView!.presentScene(scene)
    }
    func applicationShouldTerminateAfterLastWindowClosed(sender: NSApplication) -> Bool {
        return true;
    }
}

swift ATPLogoView.swift

ATPLogoView.swift

// Source for the Accidental Tech Podcast (ATP) T-Shirt:
//  http://www.marco.org/2014/04/29/atp-shirts
//
// By Troy Gaul, June 2, 2014.
//
// Based on Obj-C veresion by Marco Arment, April 28, 2014. MIT license.
//  https://gist.github.com/marcoarment/2542cd28cb5df0aa97d8

import UIKit

class ATPLogoView: UIView {
    
    override func drawRect(rectIgnored: CGRect)
    {
        let fontName = "MyriadPro-Semibold"
        let title = NSLocalizedString("Accidental Tech Podcast", comment: "")
        let initials = NSLocalizedString("ATP", comment: "") as NSString
 
        let rect = CGRect(origin: CGPointZero, size: self.bounds.size)
        let w = rect.size.width
        let offsetY = w * -0.07
        
        var ringRect = CGRectInset(rect, w * 0.08, w * 0.08)
        ringRect.origin.y += offsetY
        let ring = UIBezierPath(ovalInRect: ringRect)
        ring.lineWidth = ceil(w * 0.012)
        UIColor(white: 0.3, alpha: 1.0).setStroke()
        ring.stroke()
        
        var innerRingRect = CGRectInset(rect, w * 0.21, w * 0.21)
        innerRingRect.origin.y += offsetY
        let inner = UIBezierPath(ovalInRect: innerRingRect)
        inner.lineWidth = ceil(w * 0.007)
        UIColor(white: 0.7, alpha: 1.0).setStroke()
        inner.stroke()
        
        let pStyle = NSMutableParagraphStyle()
        pStyle.alignment = .Center
        let titleAttributes = [
            NSFontAttributeName: UIFont(name: fontName, size: w * 0.068),
            NSParagraphStyleAttributeName: pStyle,
            NSForegroundColorAttributeName: UIColor.whiteColor(),
            NSKernAttributeName: w * 0.0037
        ]
        let t = title.uppercaseString as NSString
        let titleRect = CGRect(x: 0, y: w * 0.91, width: w, height: w * 0.09)
        let o = NSStringDrawingOptions.UsesLineFragmentOrigin
        t.drawWithRect(titleRect, options: o, attributes: titleAttributes, context: nil)
        
        let bs = CGSize(width: w * 0.44, height: w * 0.19)
        var bOrigin = CGPoint(x: (w - bs.width) / 2.0, y: (w - bs.height) / 2.0)
        bOrigin.y += offsetY
        let b = CGRect(origin: bOrigin, size: bs)
        
        let cX = CGRectGetMidX(b), cY = CGRectGetMidY(b)
        var transform = CGAffineTransformMakeTranslation(cX, cY)
        transform = CGAffineTransformRotate(transform, 0.5236)
        transform = CGAffineTransformTranslate(transform, -cX, -cY)
        CGContextConcatCTM(UIGraphicsGetCurrentContext(), transform)
        UIColor(red: 0.12, green: 0.25, blue: 0.4, alpha: 1.0).setFill()
        UIBezierPath(roundedRect: b, cornerRadius: bs.height * 0.15).fill()
        
        let a = titleAttributes.mutableCopy() as NSMutableDictionary
        a[NSFontAttributeName] = UIFont(name: fontName, size: bs.height * 0.84)
        a[NSKernAttributeName] = bs.height * 0.04
        let r = CGRectInset(b, 0, 0.17 * bs.height)
        initials.drawWithRect(r, options: o, attributes: a, context: nil)
    }

}

swift Swift&Monads

Swift&Monads

maybe.swift

// Make Optional a monad
extension Optional {
    // Scala style, define `flatMap` directly
    func flatMap<U>(f: (a: T) -> Optional<U>) -> Optional<U> {
        switch (self) {
            case .None: return nil
            case .Some(let value): return f(a: value)
        }
    }

    // Haskell style, define `join` and use existing `map` implementation (`fmap` in Haskell terms)
    static func join<U>(s: Optional<Optional<U>>) -> Optional<U> {
        switch (s) {
            case .None: return nil;
            case .Some(let value): return value;
        }
    }

    func bind<U>(f: (a: T) -> Optional<U>) -> Optional<U> {
        return Optional.join(self.map(f))
    }
}

swift Swift中的Quicksort

Swift中的Quicksort

gistfile1.swift

var randomNumbers = [42, 12, 88, 62, 63, 56, 1, 77, 88, 97, 97, 20, 45, 91, 62, 2, 15, 31, 59, 5]

func partition(v: Int[], left: Int, right: Int) -> Int {
    var i = left
    for j in (left + 1)..(right + 1) {
        if v[j] < v[left] {
            i += 1
            (v[i], v[j]) = (v[j], v[i])
        }
    }
    (v[i], v[left]) = (v[left], v[i])
    return i
}

func quicksort(v: Int[], left: Int, right: Int) {
    if right > left {
        let pivotIndex = partition(v, left, right)
        quicksort(v, left, pivotIndex - 1)
        quicksort(v, pivotIndex + 1, right)
    }
}

quicksort(randomNumbers, 0, randomNumbers.count-1)

swift 斯威夫特助手

斯威夫特助手

Typedefs.swift

// You can make aliases for closure types
typealias AccountStoreMultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
typealias AccountStoreSingleAccountCompletion = (ACAccount?, NSError?) -> ()

// Or embed them in a type
class AccountStore {
    typealias MultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
    typealias SingleAccountCompletion = (ACAccount?, NSError?) -> ()
}

StringHelpers.swift

@infix func * (template: String, count: Int) -> String {
    var string: String = ""
    for i in 0..count {
        string += template
    }
    return string
}

Singleton.swift

class func sharedClient() -> CanaryClient {
    struct Static {
        static var instance: CanaryClient?
        static var token: dispatch_once_t = 0
    }
    dispatch_once(&Static.token, {
        Static.instance = CanaryClient()
    })
    return Static.instance!
}

NotificationHelpers.swift

import UIKit

extension NSNotification {
   
    func cmd_beginKeyboardAnimation() {
        UIView.beginAnimations(nil, context: nil)
        UIView.setAnimationDuration(cmd_keyboardAnimationDuration())
        UIView.setAnimationCurve(cmd_keyboardAnimationCurve())
    }
    
    func cmd_commitKeyboardAnimation() {
        UIView.commitAnimations()
    }
    
    func cmd_performAnimationsWithKeyboardAnimation(block: (Void) -> Void) {
        cmd_beginKeyboardAnimation()
        block()
        cmd_commitKeyboardAnimation()
    }
    
    func cmd_keyboardFrameInView(view: UIView) -> CGRect {
        let keyboardFrame = cmd_keyboardFrameEnd()
        return view.convertRect(keyboardFrame, fromView: view);
    }
    
    func cmd_keyboardFrameEnd() -> CGRect {
        return userInfo[UIKeyboardFrameEndUserInfoKey].CGRectValue()
    }
    
    func cmd_keyboardAnimationDuration() -> NSTimeInterval {
        return userInfo[UIKeyboardAnimationDurationUserInfoKey] as NSTimeInterval
    }
    
    func cmd_keyboardAnimationCurve() -> UIViewAnimationCurve {
        var curve = UIViewAnimationCurve.Linear
        userInfo[UIKeyboardAnimationCurveUserInfoKey].getValue(&curve)
        return curve
    }
    
}

NSDateHelpers.swift

import Foundation

extension NSDate: Comparable {
    
}

func <=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs < rhs
}

func >=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs > rhs
}

func >(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedDescending
}

/**
 This method is not required by the Comparable protocol but Xcode 6 beta 3
 would not compile without it.
*/
func <(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedAscending
}

func ==(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.isEqualToDate(rhs)
}

/**
 Operators for incrementing dates.
*/

func +(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(interval)
}

@assignment func +=(inout date: NSDate, interval: NSTimeInterval) {
    date = date + interval
}

func -(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(-interval)
}

@assignment func -=(inout date: NSDate, interval: NSTimeInterval) {
    date = date - interval
}

DispatchAfter.swift

// Nice helper function for dispatch_after
func dispatch_after_delay(delay: NSTimeInterval, queue: dispatch_queue_t, block: dispatch_block_t) {
    let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
    dispatch_after(time, queue, block)
}

// Or you can do it the old way
let offset = 2.0
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(offset * Double(NSEC_PER_SEC))), dispatch_get_main_queue(), {
    // Do something
})

ArrayHelpers.swift

extension Array {
    
    func first() -> Element? {
        if isEmpty {
            return nil
        }
        return self[0]
    }
    
    func last() -> Element? {
        if isEmpty {
            return nil
        }
        let index = count - 1
        return self[index]
    }
    
    func head() -> Element? {
        return first()
    }
    
    func tail() -> [Element]? {
        if isEmpty || count == 1 {
            return nil
        }
        let range: Range<Int> = Range(start: 1, end: count)
        let slice = self[range]
        return Array(slice)
    }
    
}

swift 斯威夫特助手

斯威夫特助手

Typedefs.swift

// You can make aliases for closure types
typealias AccountStoreMultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
typealias AccountStoreSingleAccountCompletion = (ACAccount?, NSError?) -> ()

// Or embed them in a type
class AccountStore {
    typealias MultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
    typealias SingleAccountCompletion = (ACAccount?, NSError?) -> ()
}

StringHelpers.swift

@infix func * (template: String, count: Int) -> String {
    var string: String = ""
    for i in 0..count {
        string += template
    }
    return string
}

Singleton.swift

class func sharedClient() -> CanaryClient {
    struct Static {
        static var instance: CanaryClient?
        static var token: dispatch_once_t = 0
    }
    dispatch_once(&Static.token, {
        Static.instance = CanaryClient()
    })
    return Static.instance!
}

NotificationHelpers.swift

import UIKit

extension NSNotification {
   
    func cmd_beginKeyboardAnimation() {
        UIView.beginAnimations(nil, context: nil)
        UIView.setAnimationDuration(cmd_keyboardAnimationDuration())
        UIView.setAnimationCurve(cmd_keyboardAnimationCurve())
    }
    
    func cmd_commitKeyboardAnimation() {
        UIView.commitAnimations()
    }
    
    func cmd_performAnimationsWithKeyboardAnimation(block: (Void) -> Void) {
        cmd_beginKeyboardAnimation()
        block()
        cmd_commitKeyboardAnimation()
    }
    
    func cmd_keyboardFrameInView(view: UIView) -> CGRect {
        let keyboardFrame = cmd_keyboardFrameEnd()
        return view.convertRect(keyboardFrame, fromView: view);
    }
    
    func cmd_keyboardFrameEnd() -> CGRect {
        return userInfo[UIKeyboardFrameEndUserInfoKey].CGRectValue()
    }
    
    func cmd_keyboardAnimationDuration() -> NSTimeInterval {
        return userInfo[UIKeyboardAnimationDurationUserInfoKey] as NSTimeInterval
    }
    
    func cmd_keyboardAnimationCurve() -> UIViewAnimationCurve {
        var curve = UIViewAnimationCurve.Linear
        userInfo[UIKeyboardAnimationCurveUserInfoKey].getValue(&curve)
        return curve
    }
    
}

NSDate+Helpers.swift

import Foundation

extension NSDate: Comparable {
    
}

func <=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs < rhs
}

func >=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs > rhs
}

func >(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedDescending
}

/**
 This method is not required by the Comparable protocol but Xcode 6 beta 3
 would not compile without it.
*/
func <(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedAscending
}

func ==(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.isEqualToDate(rhs)
}

/**
 Operators for incrementing dates.
*/

func +(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(interval)
}

@assignment func +=(inout date: NSDate, interval: NSTimeInterval) {
    date = date + interval
}

func -(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(-interval)
}

@assignment func -=(inout date: NSDate, interval: NSTimeInterval) {
    date = date - interval
}

DispatchAfter.swift

// Nice helper function for dispatch_after
func dispatch_after_delay(delay: NSTimeInterval, queue: dispatch_queue_t, block: dispatch_block_t) {
    let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
    dispatch_after(time, queue, block)
}

// Or you can do it the old way
let offset = 2.0
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(offset * Double(NSEC_PER_SEC))), dispatch_get_main_queue(), {
    // Do something
})

ArrayHelpers.swift

extension Array {
    
    func first() -> Element? {
        if isEmpty {
            return nil
        }
        return self[0]
    }
    
    func last() -> Element? {
        if isEmpty {
            return nil
        }
        let index = count - 1
        return self[index]
    }
    
    func head() -> Element? {
        return first()
    }
    
    func tail() -> [Element]? {
        if isEmpty || count == 1 {
            return nil
        }
        let range: Range<Int> = Range(start: 1, end: count)
        let slice = self[range]
        return Array(slice)
    }
    
}

swift 斯威夫特助手

斯威夫特助手

Typedefs.swift

// You can make aliases for closure types
typealias AccountStoreMultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
typealias AccountStoreSingleAccountCompletion = (ACAccount?, NSError?) -> ()

// Or embed them in a type
class AccountStore {
    typealias MultipleAccountsCompletion = ([ACAccount]?, NSError?) -> ()
    typealias SingleAccountCompletion = (ACAccount?, NSError?) -> ()
}

StringHelpers.swift

@infix func * (template: String, count: Int) -> String {
    var string: String = ""
    for i in 0..count {
        string += template
    }
    return string
}

Singleton.swift

class func sharedClient() -> CanaryClient {
    struct Static {
        static var instance: CanaryClient?
        static var token: dispatch_once_t = 0
    }
    dispatch_once(&Static.token, {
        Static.instance = CanaryClient()
    })
    return Static.instance!
}

NotificationHelpers.swift

import UIKit

extension NSNotification {
   
    func cmd_beginKeyboardAnimation() {
        UIView.beginAnimations(nil, context: nil)
        UIView.setAnimationDuration(cmd_keyboardAnimationDuration())
        UIView.setAnimationCurve(cmd_keyboardAnimationCurve())
    }
    
    func cmd_commitKeyboardAnimation() {
        UIView.commitAnimations()
    }
    
    func cmd_performAnimationsWithKeyboardAnimation(block: (Void) -> Void) {
        cmd_beginKeyboardAnimation()
        block()
        cmd_commitKeyboardAnimation()
    }
    
    func cmd_keyboardFrameInView(view: UIView) -> CGRect {
        let keyboardFrame = cmd_keyboardFrameEnd()
        return view.convertRect(keyboardFrame, fromView: view);
    }
    
    func cmd_keyboardFrameEnd() -> CGRect {
        return userInfo[UIKeyboardFrameEndUserInfoKey].CGRectValue()
    }
    
    func cmd_keyboardAnimationDuration() -> NSTimeInterval {
        return userInfo[UIKeyboardAnimationDurationUserInfoKey] as NSTimeInterval
    }
    
    func cmd_keyboardAnimationCurve() -> UIViewAnimationCurve {
        var curve = UIViewAnimationCurve.Linear
        userInfo[UIKeyboardAnimationCurveUserInfoKey].getValue(&curve)
        return curve
    }
    
}

NSDate+Helpers.swift

import Foundation

extension NSDate: Comparable {
    
}

func <=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs < rhs
}

func >=(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs == rhs || lhs > rhs
}

func >(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedDescending
}

/**
 This method is not required by the Comparable protocol but Xcode 6 beta 3
 would not compile without it.
*/
func <(lhs: NSDate, rhs: NSDate) -> Bool {
    let result = lhs.compare(rhs)
    return result == NSComparisonResult.OrderedAscending
}

func ==(lhs: NSDate, rhs: NSDate) -> Bool {
    return lhs.isEqualToDate(rhs)
}

/**
 Operators for incrementing dates.
*/

func +(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(interval)
}

@assignment func +=(inout date: NSDate, interval: NSTimeInterval) {
    date = date + interval
}

func -(date: NSDate, interval: NSTimeInterval) -> NSDate {
    return date.dateByAddingTimeInterval(-interval)
}

@assignment func -=(inout date: NSDate, interval: NSTimeInterval) {
    date = date - interval
}

DispatchAfter.swift

// Nice helper function for dispatch_after
func dispatch_after_delay(delay: NSTimeInterval, queue: dispatch_queue_t, block: dispatch_block_t) {
    let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
    dispatch_after(time, queue, block)
}

// Or you can do it the old way
let offset = 2.0
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(offset * Double(NSEC_PER_SEC))), dispatch_get_main_queue(), {
    // Do something
})

ArrayHelpers.swift

extension Array {
    
    func first() -> Element? {
        if isEmpty {
            return nil
        }
        return self[0]
    }
    
    func last() -> Element? {
        if isEmpty {
            return nil
        }
        let index = count - 1
        return self[index]
    }
    
    func head() -> Element? {
        return first()
    }
    
    func tail() -> [Element]? {
        if isEmpty || count == 1 {
            return nil
        }
        let range: Range<Int> = Range(start: 1, end: count)
        let slice = self[range]
        return Array(slice)
    }
    
}

swift 概念证明类型安全的RAC包装器

概念证明类型安全的RAC包装器

RAC.swift

protocol ISubscriber {
    typealias Element

    func disposable() -> RACCompoundDisposable

    func sendNext(e: Element)
    func sendError(e: NSError)
    func sendCompleted()
}

/// Wraps RACSubscriber
class Subscriber<T: AnyObject> : ISubscriber {
    let subscriber: RACSubscriber

    init(wrapped: RACSubscriber) 
    {
        subscriber = wrapped
    }

    func disposable() -> RACCompoundDisposable
    {
        return subscriber.disposable
    }

    func sendNext(e: T)
    {
        subscriber.sendNext(e)
    }

    func sendError(e: NSError)
    {
        subscriber.sendError(e)
    }

    func sendCompleted()
    {
        subscriber.sendCompleted()
    }
}

/// Wraps RACSignal
class Signal<T: AnyObject> {
    let signal: RACSignal

    init(wrapped: RACSignal)
    {
        signal = wrapped
    }

    convenience init(didSubscribe: Subscriber<T> -> ())
    {
        return self.init(wrapped: RACSignal.create { racSubscriber in
            let subscriber = Subscriber<T>(wrapped: racSubscriber)
            didSubscribe(subscriber)
        })
    }

    //TODO -[RACSignal return:] could not be called here directly because Swift hates keywords as selectors, hence this suboptimal implementation
    convenience init(value: T)
    {
        return self.init(didSubscribe: { s in
            s.sendNext(value)
            s.sendCompleted()
        })
    }

    // operations

    func flatMap<U: AnyObject>(f: T -> Signal<U>) -> Signal<U>
    {
        return Signal<U>(wrapped: signal.flattenMap { value in
            return f(value as T).signal
        })
    }

    func map<U: AnyObject>(f: T -> U) -> Signal<U>
    {
        return Signal<U>(wrapped: signal.map { value in
            return f(value as T)
        })
    }

    func filter(p: T -> Bool) -> Signal<T>
    {
        return Signal(wrapped: signal.filter { value in
            return p(value as T)
        })
    }

    // subscription

    func subscribe(next: T -> ()) -> RACDisposable
    {
        return signal.subscribeNext { value in next(value as T) }
    }

    func subscribe(next: T -> (), completed: () -> ()) -> RACDisposable
    {
        return signal.subscribeNext(
            { value in next(value as T) },
            completed: { completed() }
        )
    }
}

swift Swift同步请求

Swift同步请求

gistfile1.swift


class Request : NSObject {
    func send(url: String, f: (String)-> ()) {
        var request = NSURLRequest(URL: NSURL(string: url))
        var response: NSURLResponse?
        var error: NSErrorPointer = nil
        var data = NSURLConnection.sendSynchronousRequest(request, returningResponse: &response, error: error)
        var reply = NSString(data: data, encoding: NSUTF8StringEncoding)
        f(reply)
    }
}

var request = Request()
request.send("http://google.com", {(result: String)-> () in
    println(output)
})