 	///
 	/// The resulting producer will complete only when the producer-of-producers
 	/// and the latest producer has completed.
-	case latest
+	public static let latest = FlattenStrategy(kind: .latest)
 
 	/// Only the events from the "first input producer to send an event" (winning producer)
 	/// should be considered for the output.

	/// - parameters:
	///	  - strategy: Strategy used when flattening signals.
	public func flatten(_ strategy: FlattenStrategy) -> Signal<Value.Value, Error> {
		switch strategy {
		case .concurrent(let limit):
			return self.concurrent(limit: limit)


import enum Result.NoError

/// Describes how multiple producers should be joined together.
public struct FlattenStrategy {
	fileprivate enum Kind {
		case concurrent(limit: UInt)
		case latest
		case race
	}

	fileprivate let kind: Kind

	private init(kind: Kind) {
		self.kind = kind
	}

	/// The producers should be merged, so that any value received on any of the
	/// input producers will be forwarded immediately to the output producer.
	///
	/// The resulting producer will complete only when all inputs have
	/// completed.
	public static let merge = FlattenStrategy(kind: .concurrent(limit: .max))

	/// The producers should be concatenated, so that their values are sent in
	/// the order of the producers themselves.
	///
	/// The resulting producer will complete only when all inputs have
	/// completed.
	public static let concat = FlattenStrategy(kind: .concurrent(limit: 1))

	/// The producers should be merged, but only up to the given limit at any
	/// point of time, so that any value received on any of the input producers
