 
     internal private(set) var configure: T -> Void = { _ in }
 
-    /**
-     The designated initializer.
+    static func createPayloadGeneratorWithMaxCount(max: Int? = .None, generator gen: AnyGenerator<Payload>) -> AnyGenerator<Payload> {
+        switch max {
+        case .Some(let max):
+            // Subtract 1 to account for the 1st attempt
+            return anyGenerator(FiniteGenerator(gen, limit: max - 1))
+        case .None:
+            return gen
+        }
+    }
+    
+    /**
+     The most basic initializer.
 
      - parameter maxCount: an optional Int, which defaults to .None. If not nil, this is
      the maximum number of operations which will be executed.

     - parameter strategy: a WaitStrategy which defaults to a 0.1 second fixed interval.
     - parameter generator: a generic generator which has an Element equal to T.
     */
    public convenience init<G where G: GeneratorType, G.Element == T>(maxCount max: Int? = .None, strategy: WaitStrategy = .Fixed(0.1), generator: G) {
        self.init(maxCount: max, delay: MapGenerator(strategy.generator()) { Delay.By($0) }, generator: generator)
    }

    /// Public override of execute which configures and adds the first operation

     - parameter delay: a generator with Delay element.
     - parameter generator: a generator with T element.
     */
    public init<D, G where D: GeneratorType, D.Element == Delay, G: GeneratorType, G.Element == T>(maxCount max: Int? = .None, delay: D, generator gen: G) {

        var tuple = TupleGenerator(primary: gen, secondary: delay)
        
        guard let (_, operation) = tuple.next() else {
            preconditionFailure("Operation Generator must return an instance initially.")
        }
        
        current = operation
        generator = RepeatedOperation<T>.createPayloadGeneratorWithMaxCount(max, generator: anyGenerator(tuple))

        super.init(operations: [])
        name = "Repeated Operation <\(T.self)>"
    }

    /**
     An initializer with wait strategy and generic operation generator.
     This is useful where another system can be responsible for vending instances of 
     the custom operation. Typically there may be some state involved in such a Generator. e.g.
     
