Swift Pattern Matching, Part 4: if case, guard case, for case. Shakyo practice.

PatternMatchingPart4.swift

/*
 From http://alisoftware.github.io/swift/pattern-matching/2016/05/16/pattern-matching-4/
 
 Shakyo practice
 
 Pattern Matching, Part 4: if case, guard case, for case
 */


import XCPlayground
import Foundation
import UIKit

protocol Medium {
    var title: String {get}
    var year : Int {get}
}

struct Book: Medium {
    let title: String
    let author: String
    let year: Int
}

struct Movie: Medium {
    let title: String
    let director: String
    let year: Int
}

struct WebSite: Medium {
    let title: String
    let url: String
    let year:Int
}

enum Media {
    case Book(title: String, author: String, year: Int)
    case Movie(title: String, director: String, year: Int)
    case WebSite(title: String, url:String, year:Int)
}

// MARK: - if case let

let medium = Media.Movie(title: "Stalker", director: "Andrei Tarkovsky", year: 1979)

if case let Media.Movie(title, _, _) = medium {
    print("movie title : \(title)")
}

switch medium {
    case let Media.Movie(title, _, _):
        print("movie title : \(title)")
    default:
        print("default")
}

// MARK: - if case let where

if case let Media.Movie(_, _, year) = medium where year > 1900 {
    print("20th Century")
}


// MARK: - guard case let where

enum NetworkResponse {
    case Response(NSURLResponse, NSData)
    case Error(NSError)
}

func processRequestResponse(response: NetworkResponse) {

    // unwrap →　cast → check statuss
    guard case let .Response(urlResponse, data) = response,
    let httpResponse = urlResponse as? NSHTTPURLResponse
        where 200..<300 ~= httpResponse.statusCode else {
            print("Invalid Response!!")
            return
    }
    
    print("Processing \(data.length) bytes")
}


// MARK: - for case

let media: [Medium] = [
    Book(title: "Neuromancer", author: "William Gibson", year: 1984),
    Movie(title: "Back to the Future", director: "Robert Zemeckis", year: 1985),
    Book(title: "Count Zero", author: "William Gibson", year: 1986),
    Movie(title: "Back to the Future Part II", director: "Robert Zemeckis", year: 1989),
    Book(title: "Mona Lisa Overdrive", author: "William Gibson", year: 1988),
    Movie(title: "Back to the Future Part III ", director: "Robert Zemeckis", year: 1990)
]

print("MoviesOnly")

for case let Media.Movie(title,director,year) in media where director == "Robert Zemeckis" {
    print(" \(title) ")
}

// MARK: - using filter

let filterdMedia = media.filter { (medium) -> Bool in
    medium.year < 1990
}

print(filterdMedia)


// MARK: - Combining all !!

let media2: [Media] = [
    .Book(title: "Neuromancer", author: "William Gibson", year: 1984),
    .Movie(title: "Back to the Future", director: "Robert Zemeckis", year: 1985),
    .Book(title: "Count Zero", author: "William Gibson", year: 1986),
    .Movie(title: "Back to the Future Part II", director: "Robert Zemeckis", year: 1989),
    .Book(title: "Mona Lisa Overdrive", author: "William Gibson", year: 1988),
    .Movie(title: "Back to the Future Part III ", director: "Robert Zemeckis", year: 1990)
]

extension Media {

    var title: String? {
        switch self {
        case let .Book(title,_,_):return title
        case let .Movie(title,_,_):return title
        default:return nil
        }
    }
    
    
    var kind: String? {
        switch self {
        case .Book: return "Book"
        case .Movie: return "Movie"
        case .WebSite: return "WebSite"
        }
    }
}

for case let (title?, kind?) in media2.map({ ($0.title, $0.kind) })
    where title.hasPrefix("Back") {
        print("kind: \(kind), title: \(title)")
}

// ↓

for medium in media2 {

    guard let title = medium.title else {
        continue
    }
    
    guard let kind = medium.kind else {
        continue
    }
    
    guard title.hasPrefix("Back") else {
        continue
    }
    
    print("kind: \(kind), title: \(title)")
}