Swift Pattern Matching, Part 1: switch, enums & where clauses. Shakyo practice.

PatternMatchingPart1.swift

/*
 From http://alisoftware.github.io/swift/pattern-matching/2016/03/27/pattern-matching-1/
 
 Shakyo practice
 
 Pattern Matching, Part 1: switch, enums & where clauses
 */

import Foundation

// MARK: - simplest

enum Direction {
    case North, South, East, West
}

extension Direction: CustomStringConvertible {
    var description: String {
        switch self {
        case North: return "↑"
        case South: return "↓"
        case East:  return "→"
        case West:  return "←"
        }
    }
}

print(Direction.North)


// MARK: - associated values

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

extension Media {
    
    var mediaTitle: String {
        switch self {
        case  let .Book(title: bookTitle, author: _, year: _):
            return bookTitle
        case  .Movie(title: let movieTitle, director: _, year: _):
            return movieTitle
        case .WebSite(url: _, title: let siteTitle):
            return siteTitle
        }
    }
    
    var mediaTitle2: String {
        switch self {
        case  let .Book(title,_,_):
            return title
        case  let .Movie(title,_,_):
            return title
        case  let .WebSite(_, title):
            return title
        }
    }
    
    var mediaTitle3: String {
        switch self {
        case  let .Book(tuple):
            return tuple.title
        case  let .Movie(tuple):
            return tuple.title
        case  let .WebSite(tuple):
            return tuple.title
        }
    }
    
    
}

let book = Media.Book(title: "Neuromancer", author: "William Gibson", year: 1984)
print(book.mediaTitle)
print(book.mediaTitle2)
print(book.mediaTitle3)

// MARK: - fixed values

extension Media {
    
    var isFromWilliamGibson: Bool {
        switch self {
        case .Book(title: _, author: "William Gibson", year: _):
            return true
        case .Movie(title: _, director: "Andrei Tarkovsky", year: _):
            return true
        default: return false
        }
    }
    
    func checkAuthor(author: String) -> Bool {
        switch self {
        case .Book(title: _, author: author, year: _):
            return true
        case .Movie(title: _, director: author, year: _):
            return true
        default: return false
        }
    }
    
    
    
}

book.isFromWilliamGibson
book.checkAuthor("William Gibson")

/* Anothor Example */

enum Response {
    case HTTPResponse(statusCode: Int)
    case NetworkError(NSError)
}

let response: Response = Response.HTTPResponse(statusCode: 200)
switch response {
case .HTTPResponse(200):
    print("success")
case .HTTPResponse(400):
    print("error")
default: print("default")
}


// MARK: - Using Where clauses

extension Media {
    var isPublishedAfter1930: Bool {
        switch self {
        case let .Book(_,_,year) where year > 1930:
            return true
        case let .Movie(_,_,year) where year > 1930:
            return true
        default: return false
        }
    }
}

book.isPublishedAfter1930