// foo.swift
import Foundation

public enum Foo<Success, Failure: Error> {

  case success(Success)

  case failure(Failure)

  @inline(__always)
  public func map<NewSuccess>(
    _ transform: (Success) -> NewSuccess
  ) -> Foo<NewSuccess, Failure> {
    switch self {
    case let .success(success):
      return .success(transform(success))
    case let .failure(failure):
      return .failure(failure)
    }
  }

  @inline(__always)
  public func mapContext<T, NewSuccess>(
    _ context: inout T,
    _ transform: (Success, inout T) -> NewSuccess
  ) -> Foo<NewSuccess, Failure> {
    switch self {
    case let .success(success):
      return .success(transform(success, &context))
    case let .failure(failure):
      return .failure(failure)
    }
  }
}

#if swift(>=5.0)
#else
extension Never: Error {}
#endif

// main.swift
import Foundation
import Darwin
import foo

#if swift(>=5.0)
dump("swift-5.0")
#else
dump("swift-4.2")
#endif

func measureMiliseconds(_ work: () -> Void) -> Double {
  var info = mach_timebase_info()
  guard mach_timebase_info(&info) == KERN_SUCCESS else {
     return -1
  }

  let start = mach_absolute_time()
  work()
  let end = mach_absolute_time()

  let elapsed = end - start
  let nano = elapsed * UInt64(info.numer) / UInt64(info.denom)
  return TimeInterval(nano) / TimeInterval(NSEC_PER_MSEC)
}

@discardableResult @inline(never)
func sink<T>(_ val: T) -> T { return val }

@discardableResult @inline(never)
func sink<T>(_ val: inout T) -> T { return val }

func bench(times: Int = 10, _ work: () -> Void) -> TimeInterval {
  guard times > 0 else {
     return 0
  }

  return (0 ..< times).reduce(TimeInterval(0), { result, _ in
    return result + measureMiliseconds(work)
  }) / TimeInterval(times)
}

let n = 1000000

func doHeap() {
  var val = Foo<Int, Never>.success(10)

  for var i in 0 ..< n {
    val = val.map { _ in
      return sink(&i)
    }
  }

  sink(val)
}

func doStack() {
  var val = Foo<Int, Never>.success(10)

  for var i in 0 ..< n {
    val = val.mapContext(&i) {
      return sink(&$1)
    }
  }

  sink(val)
}

print("Bench heap: \(bench(doHeap))")
print("Bench stack: \(bench(doStack))")