d-date

func prop<Root, Value>(
    _ kp: WritableKeyPath<Root, Value>
    )
    -> (@escaping (Value) -> Value)
    -> (Root) -> Root {
        return { transformPart in
            return { root in
                var root = root
                root[keyPath: kp] = transformPart(root[keyPath: kp])
                return root

d-date

struct User {
    var name: String
    var location: String
    var age: Int
}

var user = User(name: "Blob", location: "NYC", age: 42)

\User.name
// WritableKeyPath<User, String>

d-date

func mapFirst<A, B, C>(
    _ f: @escaping (A) -> B)
    -> ((A, C)) -> (B, C) {
        return { pair in (f(pair.0), pair.1) }
}

let incrFirst2: ((Int, String)) -> (Int, String) = mapFirst(incr)

pair |> mapFirst(incr)

d-date

// Currying:
// curry((A, B) _> C) -> ((A) -> ((B) -> C)

func map<A, B>(
    _ f: @escaping (A) -> B)
    -> ([A]) -> [B] {
    return { xs in xs.map(f) }
}

map(incr) // (Array<Int>) -> Array<Int>

d-date

precedencegroup FunctionApplication {
    associativity: left
    higherThan: AssignmentPrecedence
}

infix operator |>: FunctionApplication

func |> <A,B>(a: A, f: (A) -> B) -> B {
    return f(a)
}

d-date

private extension UIActivityType {
    static let postToLINE = UIActivityType("jp.naver.line.Share")
    static let gmail = UIActivityType("com.google.Gmail.ShareExtension")
    static let postToSlack = UIActivityType("com.tinyspeck.chatlyio.share")
    static let facebookMessanger = UIActivityType("com.facebook.Messenger.ShareExtension")
    static let tweetbot4 = UIActivityType("com.tapbots.Tweetbot4.shareextension")
    static let evernote = UIActivityType("com.evernote.iPhone.Evernote.EvernoteShare")
    static let bear = UIActivityType("net.shinyfrog.bear-iOS.Bear-iPhone-Sharing-Extension")
}

d-date

enum Hoge {
    case oneValue(one: String)
    case twoValue(one: String, two: String)

    var description: String {
        switch self {
        case .oneValue(let one): return "\(one)"
        case .twoValue(let one): return "\(one)" // `one` is treated as tuple, unexpectedly
        }
    }

d-date

extension String {
    func split(_ size: Int) -> [String] {
        return stride(from: 0, to: self.count, by: size).map { i -> String in
            let startIndex = self.index(self.startIndex, offsetBy: i)
            let endIndex = self.index(startIndex, offsetBy: size, limitedBy: self.endIndex) ?? self.endIndex
            return String(self[startIndex..<endIndex])
        }
    }
}
print("あけましておめでとうございます。今年もどうぞよろしくお願いします。".split(5))

d-date

public struct Identifier {

    fileprivate let _rawValue: RawValue

    public typealias RawValue = Int

    public init(_ rawValue: RawValue) {
        self._rawValue = rawValue
    }

d-date

let data: Data = """
{
"id": 1,
"url": ""
}
""".data(using: .utf8)!

struct Hoge: Codable {
    let id: Int
    private let jsonUrl: String?