Lowercase enum cases

davedelong · Aug 11, 2016 · 59e64da · 59e64da
1 parent 2db9b8c
commit 59e64da
Show file tree

Hide file tree

Showing 13 changed files with 33 additions and 36 deletions.
diff --git a/MathParser/Either.swift b/MathParser/Either.swift
@@ -9,23 +9,20 @@
 import Foundation
 
 internal enum Either<T, E: Error> {
-    case Value(T)
-    case Error(E)
+    case value(T)
+    case error(E)
 
     var value: T? {
         switch self {
-            case .Value(let v): return v
+            case .value(let v): return v
             default: return nil
         }
     }
 
     var error: E? {
         switch self {
-            case .Error(let e): return e
+            case .error(let e): return e
             default: return nil
         }
     }
-
-    var hasValue: Bool { return value != nil }
-    var hasError: Bool { return error != nil }
 }
diff --git a/MathParser/ExponentExtractor.swift b/MathParser/ExponentExtractor.swift
@@ -46,10 +46,10 @@ internal struct ExponentExtractor: TokenExtractor {
         let range: Range<Int> = start ..< buffer.currentIndex
 
         if length > 0 {
-            return .Value(RawToken(kind: .exponent, string: exponent, range: range))
+            return .value(RawToken(kind: .exponent, string: exponent, range: range))
         } else {
             let error = MathParserError(kind: .cannotParseExponent, range: range)
-            return .Error(error)
+            return .error(error)
         }
     }
 

diff --git a/MathParser/HexNumberExtractor.swift b/MathParser/HexNumberExtractor.swift
@@ -19,7 +19,7 @@ internal struct HexNumberExtractor: TokenExtractor {
 
         guard buffer.peekNext() == "0" && buffer.peekNext(1, lowercase: true) == "x" else {
             let error = MathParserError(kind: .cannotParseHexNumber, range: start ..< start)
-            return .Error(error)
+            return .error(error)
         }
 
 
@@ -40,11 +40,11 @@ internal struct HexNumberExtractor: TokenExtractor {
         if buffer.currentIndex - start > 0 {
             let range: Range<Int> = indexBeforeHexNumbers ..< buffer.currentIndex
             let raw = buffer[range]
-            result = .Value(RawToken(kind: .hexNumber, string: raw, range: range))
+            result = .value(RawToken(kind: .hexNumber, string: raw, range: range))
         } else {
             let range: Range<Int> = start ..< buffer.currentIndex
             let error = MathParserError(kind: .cannotParseHexNumber, range: range)
-            result = .Error(error)
+            result = .error(error)
         }
 
         return result

diff --git a/MathParser/IdentifierExtractor.swift b/MathParser/IdentifierExtractor.swift
@@ -33,10 +33,10 @@ internal struct IdentifierExtractor: TokenExtractor {
 
         if buffer.currentIndex - start > 0 {
             let raw = buffer[range]
-            result = .Value(RawToken(kind: .identifier, string: raw, range: range))
+            result = .value(RawToken(kind: .identifier, string: raw, range: range))
         } else {
             let error = MathParserError(kind: .cannotParseIdentifier, range: range)
-            result = .Error(error)
+            result = .error(error)
         }
 
         return result

diff --git a/MathParser/LocalizedNumberExtractor.swift b/MathParser/LocalizedNumberExtractor.swift
@@ -53,11 +53,11 @@ internal struct LocalizedNumberExtractor: TokenExtractor {
 
         guard indexAfterNumber - start > 0 else {
             let error = MathParserError(kind: .cannotParseNumber, range: range)
-            return .Error(error)
+            return .error(error)
         }
 
         let token = RawToken(kind: .localizedNumber, string: soFar, range: range)
-        return .Value(token)
+        return .value(token)
     }
 
     private func canParseString(_ string: String) -> Bool {

diff --git a/MathParser/NumberExtractor.swift b/MathParser/NumberExtractor.swift
@@ -56,11 +56,11 @@ internal struct NumberExtractor: TokenExtractor {
         let range: Range<Int> = start ..< buffer.currentIndex
         let error = MathParserError(kind: .cannotParseNumber, range: range)
 
-        var result = TokenIterator.Element.Error(error)
+        var result = TokenIterator.Element.error(error)
         if length > 0 {
             if length != 1 || buffer[start] != "." {
                 let raw = buffer[range]
-                result = .Value(RawToken(kind: .number, string: raw, range: range))
+                result = .value(RawToken(kind: .number, string: raw, range: range))
             }
         }
         return result

diff --git a/MathParser/OctalNumberExtractor.swift b/MathParser/OctalNumberExtractor.swift
@@ -19,7 +19,7 @@ internal struct OctalNumberExtractor: TokenExtractor {
 
         guard buffer.peekNext() == "0" && buffer.peekNext(1, lowercase: true) == "o" else {
             let error = MathParserError(kind: .cannotParseHexNumber, range: start ..< start)
-            return .Error(error)
+            return .error(error)
         }
 
 
@@ -40,11 +40,11 @@ internal struct OctalNumberExtractor: TokenExtractor {
         if buffer.currentIndex - start > 0 {
             let range: Range<Int> = indexBeforeOctalNumbers ..< buffer.currentIndex
             let raw = buffer[range]
-            result = .Value(RawToken(kind: .octalNumber, string: raw, range: range))
+            result = .value(RawToken(kind: .octalNumber, string: raw, range: range))
         } else {
             let range: Range<Int> = start ..< buffer.currentIndex
             let error = MathParserError(kind: .cannotParseOctalNumber, range: range)
-            result = .Error(error)
+            result = .error(error)
         }
 
         return result

diff --git a/MathParser/OperatorExtractor.swift b/MathParser/OperatorExtractor.swift
@@ -54,10 +54,10 @@ internal struct OperatorExtractor: TokenExtractor {
 
         if buffer.currentIndex - start > 0 {
             let raw = buffer[range]
-            result = .Value(RawToken(kind: .operator, string: raw, range: range))
+            result = .value(RawToken(kind: .operator, string: raw, range: range))
         } else {
             let error = MathParserError(kind: .cannotParseOperator, range: range)
-            result = .Error(error)
+            result = .error(error)
         }
 
         return result

diff --git a/MathParser/QuotedVariableExtractor.swift b/MathParser/QuotedVariableExtractor.swift
@@ -49,17 +49,17 @@ internal struct QuotedVariableExtractor: TokenExtractor {
         if buffer.peekNext() != quoteCharacter {
             let errorRange: Range<Int> = start ..< buffer.currentIndex
             let error = MathParserError(kind: .cannotParseQuotedVariable, range: errorRange)
-            result = .Error(error)
+            result = .error(error)
         } else {
             buffer.consume()
             let range: Range<Int> = start ..< buffer.currentIndex
             // check to make sure we don't have an empty string
             if cleaned.characters.isEmpty {
                 let error = MathParserError(kind: .zeroLengthVariable, range: range)
-                result = .Error(error)
+                result = .error(error)
             } else {
                 let token = RawToken(kind: .variable, string: cleaned, range: range)
-                result = .Value(token)
+                result = .value(token)
             }
         }
 

diff --git a/MathParser/SpecialNumberExtractor.swift b/MathParser/SpecialNumberExtractor.swift
@@ -42,7 +42,7 @@ internal struct SpecialNumberExtractor: TokenExtractor {
 
         let range: Range<Int> = start ..< buffer.currentIndex
         let raw = buffer[range]
-        return .Value(RawToken(kind: .number, string: raw, range: range))
+        return .value(RawToken(kind: .number, string: raw, range: range))
     }
 
 }
diff --git a/MathParser/TokenIterator.swift b/MathParser/TokenIterator.swift
@@ -62,9 +62,9 @@ internal class TokenIterator: IteratorProtocol {
             let result = extractor.extract(buffer)
 
             switch result {
-                case .Value(_):
+                case .value(_):
                     return result
-                case .Error(_):
+                case .error(_):
                     errors.append(result)
             }
         }

diff --git a/MathParser/Tokenizer.swift b/MathParser/Tokenizer.swift
@@ -25,8 +25,8 @@ public struct Tokenizer {
 
         while let next = g.next() {
             switch next {
-                case .Error(let e): throw e
-                case .Value(let t): tokens.append(t)
+                case .error(let e): throw e
+                case .value(let t): tokens.append(t)
             }
         }
 

diff --git a/MathParser/VariableExtractor.swift b/MathParser/VariableExtractor.swift
@@ -28,22 +28,22 @@ internal struct VariableExtractor: TokenExtractor {
             // the stuff that follow "$" must be a valid identifier
             let range: Range<Int> = start ..< start
             let error = MathParserError(kind: .cannotParseVariable, range: range)
-            return TokenIterator.Element.Error(error)
+            return TokenIterator.Element.error(error)
         }
 
         let identifierResult = identifierExtractor.extract(buffer)
 
         let result: TokenIterator.Element
 
         switch identifierResult {
-            case .Error(let e):
+            case .error(let e):
                 let range: Range<Int> = start ..< e.range.upperBound
                 let error = MathParserError(kind: .cannotParseVariable, range: range)
-                result = .Error(error)
-            case .Value(let t):
+                result = .error(error)
+            case .value(let t):
                 let range: Range<Int> = start ..< t.range.upperBound
                 let token = RawToken(kind: .variable, string: t.string, range: range)
-                result = .Value(token)
+                result = .value(token)
         }
 
         return result