 
     let _seq : SequenceOf<T>
 
-    typealias GeneratorType = SequenceOf<T>.GeneratorType
-    func generate() -> GeneratorType { return _seq.generate() }
+    func generate() -> GeneratorOf<T> { return _seq.generate() }
     
     init<G : Generator where G.Element == T>(_ generate: () -> G) {
         _seq = SequenceOf(generate)

            typealias C = S.GeneratorType.Element
            
            var gen1 = self.generate()
            var gen2: SequenceOf<C>.GeneratorType = SinqSequence<C>(C[]()).generate()
            var counter = 0
            
            return GeneratorOf {

        ) -> SinqSequence<R>
    {
        return SinqSequence<R> { () -> GeneratorOf<R> in
            var innerGrouping = Dictionary<K, [S.GeneratorType.Element]>()
            for element in inner {
                let key = innerKey(element)
                if var group = innerGrouping[key] {
