- First

* Adds `materialize()` operator for RxBlocking's `BlockingObservable`. #1383

* Adds `first` operator to ObservableType.

Using `RxBlocking`'s `toBlocking()` method, you can block the current thread and wait for the sequence to complete, allowing you to synchronously access its result.

A simple way to test the result of your sequence is using the `toArray` method. It will return an array of all elements emitted once a sequence has completed successfully, or `throw` if an error caused the sequence to terminate.

Another option would be to use the `materialize` operator which lets you more granularly examine your sequence. It will return a `MaterializedSequenceResult` enumeration that could be either `.completed` along with the emitted elements if the sequence completed successfully, or `failed` if the sequence terminated with an error, along with the emitted error.

let result = try fetchResource(location)

.toBlocking()

.materialize()

switch result {

case .completed:

XCTFail("Expected result to complete with error, but result was successful.")

case .failed(let elements, let error):

XCTAssertEqual(elements, expectedResult)

XCTAssertErrorEqual(error, expectedError)

}

switch result {

case .completed(let elements):

XCTAssertEqual(elements, expectedResult)

case .failed(_, let error):

XCTFail("Expected result to complete without error, but received \(error).")

}

819C2F091F2FBC7F009104B6 /* First.swift in Sources */ = {isa = PBXBuildFile; fileRef = 819C2F081F2FBC7F009104B6 /* First.swift */; };

819C2F0A1F2FBC88009104B6 /* First.swift in Sources */ = {isa = PBXBuildFile; fileRef = 819C2F081F2FBC7F009104B6 /* First.swift */; };

819C2F0B1F2FBC88009104B6 /* First.swift in Sources */ = {isa = PBXBuildFile; fileRef = 819C2F081F2FBC7F009104B6 /* First.swift */; };

819C2F0C1F2FBC89009104B6 /* First.swift in Sources */ = {isa = PBXBuildFile; fileRef = 819C2F081F2FBC7F009104B6 /* First.swift */; };

819C2F081F2FBC7F009104B6 /* First.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = First.swift; sourceTree = "<group>"; };

819C2F081F2FBC7F009104B6 /* First.swift */,

819C2F0A1F2FBC88009104B6 /* First.swift in Sources */,

819C2F091F2FBC7F009104B6 /* First.swift in Sources */,

819C2F0B1F2FBC88009104B6 /* First.swift in Sources */,

819C2F0C1F2FBC89009104B6 /* First.swift in Sources */,

/// The `MaterializedSequenceResult` enum represents the materialized

/// output of a BlockingObservable.

///

/// If the sequence terminates successfully, the result is represented

/// by `.completed` with the array of elements.

///

/// If the sequence terminates with error, the result is represented

/// by `.failed` with both the array of elements and the terminating error.

public enum MaterializedSequenceResult<T> {

case completed(elements: [T])

case failed(elements: [T], error: Error)

let results = materializeResult()

return try elementsOrThrow(results)

let results = materializeResult(max: 1)

return try elementsOrThrow(results).first

let results = materializeResult()

return try elementsOrThrow(results).last

let results = materializeResult(max: 2, predicate: predicate)

let elements = try elementsOrThrow(results)

/// Blocks current thread until sequence terminates.

///

/// The sequence is materialized as a result type capturing how the sequence terminated (completed or error), along with any elements up to that point.

///

/// - returns: On completion, returns the list of elements in the sequence. On error, returns the list of elements up to that point, along with the error itself.

public func materialize() -> MaterializedSequenceResult<E> {

return materializeResult()

}

extension BlockingObservable {

fileprivate func materializeResult(max: Int? = nil, predicate: @escaping (E) throws -> Bool = { _ in true }) -> MaterializedSequenceResult<E> {

return MaterializedSequenceResult.failed(elements: elements, error: error)

return MaterializedSequenceResult.completed(elements: elements)

}

fileprivate func elementsOrThrow(_ results: MaterializedSequenceResult<E>) throws -> [E] {

switch results {

case .failed(_, let error):

throw error

case .completed(let elements):

return elements

}