     
     // Expression
     enum Expression : Codable {
-        case element(element:Element)
         case sequence(sequence:Sequence)
         case choice(choice:Choice)
+        case element(element:Element)
         
         enum CodingKeys : Swift.String, CodingKey {
-            case element,sequence,choice
+            case sequence,choice,element
         }
         
         init(from decoder: Decoder) throws {
             let container = try decoder.container(keyedBy: CodingKeys.self)
             
-            if let element = try? container.decode(Element.self, forKey: .element){
-            	self = .element(element: element)
-            	return
-            } else if let sequence = try? container.decode(Sequence.self, forKey: .sequence){
+            if let sequence = try? container.decode(Sequence.self, forKey: .sequence){
             	self = .sequence(sequence: sequence)
             	return
             } else if let choice = try? container.decode(Choice.self, forKey: .choice){
             	self = .choice(choice: choice)
             	return
-            }
-            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of Element,Sequence,Choice but found none of those types"))
+            } else if let element = try? container.decode(Element.self, forKey: .element){
+            	self = .element(element: element)
+            	return
+            }
+            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of Sequence,Choice,Element but found none of those types"))
         }
         func encode(to encoder:Encoder) throws {
             var container = encoder.container(keyedBy: CodingKeys.self)
             switch self {
-            case .element(let element):
-                try container.encode(element, forKey: .element)
             case .sequence(let sequence):
                 try container.encode(sequence, forKey: .sequence)
             case .choice(let choice):
                 try container.encode(choice, forKey: .choice)
+            case .element(let element):
+                try container.encode(element, forKey: .element)
             }
         }
     }
     
     /// Rule 
     struct Rule : Codable {
-        let identifier: Swift.String
-        let annotations: Annotations?
-        let expression: Expression
         let transient: Swift.String?
         let assignmentOperators: AssignmentOperators
         let void: Swift.String?
+        let expression: Expression
+        let annotations: Annotations?
+        let identifier: Swift.String
     }
     
     /// ModuleImport 
     struct ModuleImport : Codable {
         let moduleName: Swift.String
-        let `import`: Swift.String
     }
     
     typealias Modules = [ModuleImport] 

		// lookahead
		case .lookahead:
			return ">>".terminal(token: T.lookahead, annotations: annotations)
		// stringQuote
		case .stringQuote:
			return "\"".terminal(token: T.stringQuote, annotations: annotations)
		// terminalBody
		case .terminalBody:
			return ScannerRule.regularExpression(token: T.terminalBody, regularExpression: T.regularExpression("^(\\\\.|[^\"\\\\\\n])+"), annotations: annotations)

		// string
		case .string:
			return [
					"\"".terminal(token: T._transient, annotations: [RuleAnnotation.void : RuleAnnotationValue.set]),
					T.stringBody._rule(),
					"\"".terminal(token: T._transient, annotations: [RuleAnnotation.error : RuleAnnotationValue.string("Missing terminating quote"),RuleAnnotation.void : RuleAnnotationValue.set]),
					].sequence(token: T.string, annotations: annotations.isEmpty ? [ : ] : annotations)
		// terminalString
		case .terminalString:
			return [
					"\"".terminal(token: T._transient, annotations: [RuleAnnotation.void : RuleAnnotationValue.set]),
					T.terminalBody._rule([RuleAnnotation.error : RuleAnnotationValue.string("Terminals must have at least one character")]),
					"\"".terminal(token: T._transient, annotations: [RuleAnnotation.error : RuleAnnotationValue.string("Missing terminating quote"),RuleAnnotation.void : RuleAnnotationValue.set]),
					].sequence(token: T.terminalString, annotations: annotations.isEmpty ? [ : ] : annotations)
		// characterSetName
		case .characterSetName:
