Add XCTUnimplemented for non-function values

[lucamegh]

How about adding an XCTUnimplemented overload that returns a Result instead of a (Parameters) -> Result? This way we would be able to create unimplemented instances of dependencies built from non-function values (usually reference types).

struct AuthenticationClient {
  var authenticationState: CurrentValuePublisher<AuthenticationState, Never> // ⬅️
  var signIn: (Credential) async throws -> User
  var signOut: () throws -> Void
}

extension AuthenticationClient {
  static let unimplemented = Self(
    authenticationState: XCTUnimplemented("\(Self.self).authenticationState"), // ⬅️
    signIn: XCTUnimplemented("\(Self.self).signIn"),
    signOut: XCTUnimplemented("\(Self.self).signOut")
  )
}

[stephencelis]

@lucamegh Definitely an interesting topic!

We've experimented with value endpoints on dependencies in the past (and a few still exist in our isowords app), but we've found more flexibility (and consistency) in preferring closures. For example, we'd probably define your endpoint as:

var authenticationState: () -> CurrentValuePublisher<AuthenticationState, Never>

And this would allow you to use XCTUnimplemented as currently vended from this library.

If you prefer, you can still define static endpoints on types that have "unimplemented" instances. For example you could define something like CurrentValuePublisher.unimplemented, which calls XCTFail under the hood.

But as for defining XCTUnimplemented to return the Result directly, I'm not quite sure I see how this could work. Do you have an idea? @iampatbrown has a fun exploration of expanding the default "placeholder" values in #25, but it's hard to see how to extend such functionality very broadly, e.g. with the CurrentValuePublisher example.

[lucamegh]

Adding static unimplemented endpoints to types sounds very good. I didn't think of it.
As for turning properties into closures, that's how I'm doing in my codebase at the moment.

My idea was to add a new API implemented this way:

public func XCTUnimplemented<Result>(
  _ description: @autoclosure @escaping @Sendable () -> String = "",
  placeholder: @autoclosure @escaping @Sendable () -> Result? = nil,
  file: StaticString = #file,
  line: UInt = #line
) -> Result {
  let description = description()
  _fail(description, nil)
  guard let placeholder = placeholder() ?? _generatePlaceholder()
  else { _unimplementedFatalError(description, file: file, line: line) }
  return placeholder
}

I do however agree that such overload would make for a less consistent use of the "unimplemented" pattern.