enum Either<T, U> {
  case first(T)
  case second(U)
}

@resultBuilder
struct TupleBuilder {
  static func buildBlock() -> () { }

  static func buildEither<T: Tuple, U: Tuple>(first value: T) -> Either<T,U> {
    return .first(value)
  }
  static func buildEither<T: Tuple, U: Tuple>(second value: U) -> Either<T,U> {
    return .second(value)
  }
}

protocol Tuple {
  associatedtype Body: Tuple

  @TupleBuilder var body: Body { get }
}

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

extension Never: Tuple {
  var body: Never {
    return make()
  }
}

struct OneTuple: Tuple {
  var body: Never {
    return make()
  }
}

extension Either: Tuple where T: Tuple, U: Tuple {
  var body: Never {
    return make()
  }
}

struct NTuple<Element: Tuple>: Tuple {
  init(@TupleBuilder _ body: () -> Element) {

  }

  var body: some Tuple {
    return make() as OneTuple
  }
}

enum Kind {
  case first
}

struct Foo: Tuple {
  var constant: Kind

  var body: some Tuple {
    NTuple {
      OneTuple().
      OneTuple()
    }
  }
}