import Foundation

public struct Tagged<Tag, RawValue> {
  var rawValue: RawValue

  init(rawValue: RawValue) {
    self.rawValue = rawValue
  }

  func map<B>(_ f: (RawValue) -> B) -> Tagged<Tag, B> {
    return .init(rawValue: f(self.rawValue))
  }
}

struct Info {
  typealias Id = Tagged<Info, UUID>
}

struct S {
  var id: Info.Id?
}

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

struct EitherIO<E, A> {}

func throwE<E, A>(_ x: E) -> EitherIO<E, A> {
  fatalError()
}

infix operator >>>
func >>> <A, B, C>(f: @escaping (A) -> B, g: @escaping (B) -> C) -> ((A) -> C) {
  fatalError()
}

func mapExcept<E, F, A, B>(_ f: @escaping (Either<E, A>) -> Either<F, B>) -> (EitherIO<E, A>) -> EitherIO<F, B> {
  fatalError()
}

func requireSome<A>(_ e: Either<Error, A?>) -> Either<Error, A> {
  fatalError()
}

struct Unit : Error {}

var unit = Unit()

func test(_ s: S, _ arg: @escaping (Info.Id) -> EitherIO<Error, Info?>) {
  let _ = s.id.map(arg >>> mapExcept(requireSome)) ?? throwE(unit)
}