         case "\\":
             return (RegularBackslash(), r)
         default:
-            return (RegularBase(regular: next), r);
-        }
-    }
-    /*
-    
-    - (NSString *)string {
-    NSMutableString *string = [NSMutableString string];
-    for (RegularBase *rb in strings[arc4random_uniform((u_int32_t)strings.count)]) {
-    [string appendString:[rb string]];
-    }
-    return string;
-    }
-*/
+            return (RegularOneString(string: next), r);
+        }
+    }
 }
 
 class RegularOr: RegularBase {
 }
-class RegularAlphabet: RegularBase {
-}
-class RegularWords: RegularBase {
-}
-class RegularSpaceSet: RegularBase {
-}
-class RegularHorizontalTab: RegularBase {
-}
-class RegularVerticalTab: RegularBase {
-}
-class RegularNewline: RegularBase {
-}
-class RegularReturn: RegularBase {
-}
-class RegularBackSpace: RegularBase {
-}
-class RegularFormFeed: RegularBase {
-}
-class RegularBell: RegularBase {
-}
-class RegularEscape: RegularBase {
-}
-class RegularNumber: RegularBase {
-}
-class RegularBackslash: RegularBase {
-}
+class RegularOneString: RegularBase {
+    let s: String
+    init(string: String) {
+        s = string
+        super.init()
+    }
+}
+class RegularWord: RegularBase {
+    override init() {
+        super.init()
+    }
+}
+class RegularAlphabet: RegularWord {
+}
+class RegularWords: RegularWord {
+}
+class RegularSpaceSet: RegularWord {
+}
+class RegularHorizontalTab: RegularWord {
+}
+class RegularVerticalTab: RegularWord {
+}
+class RegularNewline: RegularWord {
+}
+class RegularReturn: RegularWord {
+}
+class RegularBackSpace: RegularWord {
+}
+class RegularFormFeed: RegularWord {
+}
+class RegularBell: RegularWord {
+}
+class RegularEscape: RegularWord {
+}
+class RegularNumber: RegularWord {
+}
+class RegularBackslash: RegularWord {
+}
+class RegularRepeat: RegularBase {
+    let r: RegularBase
+    init(regular :RegularBase) {
+        r = regular
+        super.init()
+    }
+}
+class RegularRepeatZero: RegularRepeat {
+}
+class RegularRepeatOne: RegularRepeat {
+}
+class RegularQuestion: RegularRepeat {
+}
+class RegularAll: RegularBase {
+}
+class RegularGroupStart: RegularBase {
+}
+class RegularOR: RegularBase {
+}
+class RegularGroup: RegularBase {
+    let group: Array<RegularBase>
+    init(group: Array<RegularBase>) {
+        self.group = group
+        super.init()
+    }
+}
+
 /*
-//
-//  AKURegularString.m
-//  AKTestFreamework
-//
-//  Created by P.I.akura on 2013/09/20.
-//  Copyright (c) 2013年 P.I.akura. All rights reserved.
-//
-
-#import "AKURegularString.h"
-#import "AKURandString.h"
-
-@interface RegularBase : NSObject
-- (NSString *)string;
-@end
-@interface RegularOneString : RegularBase
-@end
-@interface RegularWord : RegularBase
-+ (RegularBase *)generat;
-@end
-@interface RegularAlphabet : RegularWord
-@end
-@interface RegularWords : RegularWord
-@end
-@interface RegularAll : RegularWord
-@end
-@interface RegularSpaceSet : RegularWord
-@end
-@interface RegularNumber : RegularWord
-@end
-@interface RegularHorizontalTab : RegularWord
-@end
-@interface RegularVerticalTab : RegularWord
-@end
-@interface RegularNewline : RegularWord
-@end
-@interface RegularReturn : RegularWord
-@end
-@interface RegularBackSpace : RegularWord
-@end
-@interface RegularFormFeed : RegularWord
-@end
-@interface RegularBell : RegularWord
-@end
-@interface RegularEscape : RegularWord
-@end
-@interface RegularBackslash : RegularWord
-@end
-@interface RegularRepeatZero : RegularBase
-+ (RegularBase *)generat:(RegularBase *)regurla;
-@end
-@interface RegularRepeatOne : RegularRepeatZero
-@end
-@interface RegularQuestion : RegularRepeatZero
-@end
-
-@interface RegularGroupStart : RegularBase
-+ (RegularBase *)generate;
-@end
-@interface RegularGroup : RegularBase
-+ (RegularBase *)generate:(NSArray *)_str;
-@end
-@interface RegularOR : RegularBase
-+ (RegularBase *)generate;
-@end
-
-
-@implementation RegularBase {
-}
-                }
-@end
 
 @implementation RegularOneString {
     NSString *string;

        while (0 < regular.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)) {
            var (s, r) = self.push(regular)
            regular = r
        }
    }
    func push(var strings: String) -> (String, String) {
        let result = strings[strings.startIndex..<strings.startIndex.successor()]
        strings.removeAtIndex(strings.startIndex)
        return (result, strings)
    }
    /*
    NSString *result = [string substringToIndex:1];
    [string deleteCharactersInRange:(NSRange){0, 1}];
    return result;
    }
    
    str = [NSMutableArray array];
    while (regular.length != 0) {
    NSMutableString *s = [self push:regular].mutableCopy;
    if ([s isEqualToString:@"\\"]) {
    id next = [self slishWord:regular];
    if ([next isKindOfClass:[NSMutableString class]]) {
    [str addObject:[RegularOneString generat:s]];
    [str addObject:[RegularOneString generat:next]];
    } else {
    [str addObject:next];
    }
    } else if ([s isEqualToString:@"*"]) {
    str[str.count - 1] = [RegularRepeatZero generat:str.lastObject];
    } else if ([s isEqualToString:@"+"]) {
    str[str.count - 1] = [RegularRepeatOne generat:str.lastObject];
    } else if ([s isEqualToString:@"?"]) {
    str[str.count - 1] = [RegularQuestion generat:str.lastObject];
    } else if ([s isEqualToString:@"."]){
    [str addObject:[RegularAll generat]];
    } else if ([s isEqualToString:@"("]) {
    [str addObject:[RegularGroupStart generate]];
    } else if ([s isEqualToString:@"|"]) {
    [str addObject:[RegularOR generate]];
    } else if ([s isEqualToString:@")"]) {
    NSInteger i = str.count - 1;
    for (; 0 <= i; i--) {
    if ([str[i] isKindOfClass:[RegularGroupStart class]]) {
    break;
    }
    }
    [str removeObjectAtIndex:i];
    NSRange renge = (NSRange){i, str.count - i};
    NSArray *group = [str subarrayWithRange:renge];
    [str removeObjectsInRange:renge];
    [str addObject:[RegularGroup generate:group]];
    } else {
    [str addObject:[RegularOneString generat:s]];
    }
*/
    func spliteOr() {
        for var i = 0, _len = str.count; i < _len ; i++ {
            var regular = str[i]

            }
        }
        strings += str
    }
    func push(var strings: String) -> (String, String) {
        let result = strings[strings.startIndex..<strings.startIndex.successor()]
        strings.removeAtIndex(strings.startIndex)
        return (result, strings)
    }
    func slishWord(regular: String) -> (RegularBase, String) {
        var (next, r) = self.push(regular)
