ukitaka

protocol BodyParameters { }
struct JSONBodyParameters: BodyParameters { }
struct MultipartFormDataBodyParameters: BodyParameters { }

protocol Request {
    var bodyParameters: BodyParameters? { get }
}

extension Request {
    var bodyParameters: BodyParameters? {

ukitaka

typealias Contravariant<A> = (A) -> ()

class Hoge { }
class Fuga: Hoge { }

let fuga: Fuga = Fuga()
let hoge: Hoge = Hoge()

let fugaC: Contravariant<Fuga> = { _ in }
let hogeC: Contravariant<Hoge> = { _ in }

ukitaka

struct Prism<S, A> {
    private let getOption: (S) -> A?
    private let reverseGet: (A) -> S

    init(getOption: @escaping (S) -> A?, reverseGet: @escaping (A) -> S) {
        self.getOption = getOption
        self.reverseGet = reverseGet
    }
}

ukitaka

struct Lens<S, A> {
    typealias Getter = (S) -> A
    typealias Setter = (S, A) -> S
    
    fileprivate let _get: Getter
    fileprivate let _set: Setter

    init(get: @escaping Getter, set: @escaping Setter) {
        self._get = get
        self._set = set

ukitaka

public final class _TO {
    lazy var DO: Never = { fatalError() }()
}

public let TO = _TO()

ukitaka

func fatalErrorT<T>() -> T {
    fatalError()
}

func fatalErrorT<T>(_ message: String) -> T {
    fatalError(message)
}

ukitaka

enum Error: Swift.Error {
    case castError
}

func toInt(_ string: String) throws -> Int {
    guard let i = Int(string) else {
        throw Error.castError
    }
    return i
}

ukitaka

enum Either<L, R> {
    case left(L)
    case right(R)
}

extension Either {
    var rightProjection: RightProjection<L, R> {
        return RightProjection(either: self)
    }

ukitaka

protocol HList {
    associatedtype Head
    associatedtype Tail
}

struct HCons<H, T: HList>: HList {
    typealias Head = H
    typealias Tail = T

    let head: H

ukitaka

func map2<A, B, C>(_ fa: Optional<A>, _ fb: Optional<B>, _ f: (A, B) -> C) -> Optional<C> {
    switch (fa, fb) {
    case (.some(let a), .some(let b)): // ここできると思わなかった...
        return .some(f(a, b))
    default:
        return .none
    }
}