Add code for Swift 2 update

Author: floriankugler

02-ThinkingFunctionally.playground/Contents.swift

@@ -0,0 +1,138 @@
+//: # Prelude
+
+import Foundation
+
+//: # Thinking Functionally
+//: ## Example: Battleship
+
+typealias Distance = Double
+
+struct Position {
+    var x: Double
+    var y: Double
+}
+
+
+extension Position {
+    func inRange(range: Distance) -> Bool {
+        return sqrt(x * x + y * y) <= range
+    }
+}
+
+
+struct Ship {
+    var position: Position
+    var firingRange: Distance
+    var unsafeRange: Distance
+}
+
+
+extension Ship {
+    func canEngageShip(target: Ship) -> Bool {
+        let dx = target.position.x - position.x
+        let dy = target.position.y - position.y
+        let targetDistance = sqrt(dx * dx + dy * dy)
+        return targetDistance <= firingRange
+    }
+}
+
+
+extension Ship {
+    func canSafelyEngageShip(target: Ship) -> Bool {
+        let dx = target.position.x - position.x
+        let dy = target.position.y - position.y
+        let targetDistance = sqrt(dx * dx + dy * dy)
+        return targetDistance <= firingRange && targetDistance > unsafeRange
+    }
+}
+
+
+extension Ship {
+    func canSafelyEngageShip1(target: Ship, friendly: Ship) -> Bool {
+        let dx = target.position.x - position.x
+        let dy = target.position.y - position.y
+        let targetDistance = sqrt(dx * dx + dy * dy)
+        let friendlyDx = friendly.position.x - target.position.x
+        let friendlyDy = friendly.position.y - target.position.y
+        let friendlyDistance = sqrt(friendlyDx * friendlyDx +
+            friendlyDy * friendlyDy)
+        return targetDistance <= firingRange
+            && targetDistance > unsafeRange
+            && (friendlyDistance > unsafeRange)
+    }
+}
+
+
+extension Position {
+    func minus(p: Position) -> Position {
+        return Position(x: x - p.x, y: y - p.y)
+    }
+    var length: Double {
+        return sqrt(x * x + y * y)
+    }
+}
+
+
+extension Ship {
+    func canSafelyEngageShip2(target: Ship, friendly: Ship) -> Bool {
+        let targetDistance = target.position.minus(position).length
+        let friendlyDistance = friendly.position.minus(target.position).length
+        return targetDistance <= firingRange
+            && targetDistance > unsafeRange
+            && (friendlyDistance > unsafeRange)
+    }
+}
+
+//: ## First-Class Functions
+
+typealias Region = Position -> Bool
+
+
+func circle(radius: Distance) -> Region {
+    return { point in point.length <= radius }
+}
+
+
+func circle2(radius: Distance, center: Position) -> Region {
+    return { point in point.minus(center).length <= radius }
+}
+
+
+func shift(region: Region, offset: Position) -> Region {
+    return { point in region(point.minus(offset)) }
+}
+
+
+func invert(region: Region) -> Region {
+    return { point in !region(point) }
+}
+
+
+func intersection(region1: Region, _ region2: Region) -> Region {
+    return { point in region1(point) && region2(point) }
+}
+
+func union(region1: Region, _ region2: Region) -> Region {
+    return { point in region1(point) || region2(point) }
+}
+
+
+func difference(region: Region, minus: Region) -> Region {
+    return intersection(region, invert(minus))
+}
+
+
+extension Ship {
+    func canSafelyEngageShip(target: Ship, friendly: Ship) -> Bool {
+        let rangeRegion = difference(circle(firingRange),
+            minus: circle(unsafeRange))
+        let firingRegion = shift(rangeRegion, offset: position)
+        let friendlyRegion = shift(circle(unsafeRange),
+            offset: friendly.position)
+        let resultRegion = difference(firingRegion, minus: friendlyRegion)
+        return resultRegion(target.position)
+    }
+}
+
+//: ## Type-Driven Development
+//: ## Notes

02-ThinkingFunctionally.playground/contents.xcplayground

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='osx'></playground>

03-Wrapping-Core-Image.playground/Contents.swift

@@ -0,0 +1,120 @@
+//: # Prelude
+
+import Cocoa
+
+//: # Case Study: Wrapping Core Image {#wrapping-core-image}
+//: ## The Filter Type
+
+typealias Filter = CIImage -> CIImage
+
+//: ## Building Filters
+//: ### Blur
+
+func blur(radius: Double) -> Filter {
+    return { image in
+        let parameters = [
+            kCIInputRadiusKey: radius,
+            kCIInputImageKey: image
+        ]
+        guard let filter = CIFilter(name: "CIGaussianBlur",
+            withInputParameters: parameters) else { fatalError() }
+        guard let outputImage = filter.outputImage else { fatalError() }
+        return outputImage
+    }
+}
+
+//: ### Color Overlay
+
+func colorGenerator(color: NSColor) -> Filter {
+    return { _ in
+        guard let c = CIColor(color: color) else { fatalError() }
+        let parameters = [kCIInputColorKey: c]
+        guard let filter = CIFilter(name: "CIConstantColorGenerator",
+            withInputParameters: parameters) else { fatalError() }
+        guard let outputImage = filter.outputImage else { fatalError() }
+        return outputImage
+    }
+}
+
+
+func compositeSourceOver(overlay: CIImage) -> Filter {
+    return { image in
+        let parameters = [
+            kCIInputBackgroundImageKey: image,
+            kCIInputImageKey: overlay
+        ]
+        guard let filter = CIFilter(name: "CISourceOverCompositing",
+            withInputParameters: parameters) else { fatalError() }
+        guard let outputImage = filter.outputImage else { fatalError() }
+        let cropRect = image.extent
+        return outputImage.imageByCroppingToRect(cropRect)
+    }
+}
+
+
+func colorOverlay(color: NSColor) -> Filter {
+    return { image in
+        let overlay = colorGenerator(color)(image)
+        return compositeSourceOver(overlay)(image)
+    }
+}
+
+//: ## Composing Filters
+
+let url = NSURL(string: "http://www.objc.io/images/covers/16.jpg")!
+let image = CIImage(contentsOfURL: url)!
+
+
+let blurRadius = 5.0
+let overlayColor = NSColor.redColor().colorWithAlphaComponent(0.2)
+let blurredImage = blur(blurRadius)(image)
+let overlaidImage = colorOverlay(overlayColor)(blurredImage)
+
+//: ### Function Composition
+
+let result = colorOverlay(overlayColor)(blur(blurRadius)(image))
+
+
+func composeFilters(filter1: Filter, _ filter2: Filter) -> Filter {
+    return { image in filter2(filter1(image)) }
+}
+
+
+let myFilter1 = composeFilters(blur(blurRadius), colorOverlay(overlayColor))
+let result1 = myFilter1(image)
+
+
+infix operator >>> { associativity left }
+
+func >>> (filter1: Filter, filter2: Filter) -> Filter {
+    return { image in filter2(filter1(image)) }
+}
+
+
+let myFilter2 = blur(blurRadius) >>> colorOverlay(overlayColor)
+let result2 = myFilter2(image)
+
+//: ## Theoretical Background: Currying
+
+func add1(x: Int, _ y: Int) -> Int {
+    return x + y
+}
+
+
+func add2(x: Int) -> (Int -> Int) {
+    return { y in return x + y }
+}
+
+
+add1(1, 2)
+add2(1)(2)
+
+
+func add3(x: Int)(_ y: Int) -> Int {
+    return x + y
+}
+
+
+add3(1)(2)
+
+//: ## Discussion

03-Wrapping-Core-Image.playground/contents.xcplayground

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='osx'></playground>