 
     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 delay: a generator with Delay element.
     - parameter generator: a generator with T element.
     */
    public convenience init<D, G where D: GeneratorType, D.Element == Delay, G: GeneratorType, G.Element == T>(maxCount max: Int? = .None, delay: D, generator: G) {
        let tuple = TupleGenerator(primary: generator, secondary: delay)
        self.init(maxCount: max, generator: anyGenerator(tuple))
    }

    /**
     A convenience 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.
     

        }

        current = operation
        generator = RepeatedOperation<T>.createPayloadGeneratorWithMaxCount(max, generator: gen)
        
        super.init(operations: [])
        name = "Repeated Operation <\(T.self)>"
    }

    /**
     An initializer, which accepts two generators, one for the delay and another for
     the operation.

     - parameter maxCount: an optional Int, which defaults to .None. If not nil, this is
