diff --git a/Sources/Errors.swift b/Sources/Errors.swift
index e885ab3..91e617b 100644
--- a/Sources/Errors.swift
+++ b/Sources/Errors.swift
@@ -37,15 +37,8 @@ public struct TemplateSyntaxError : Error, Equatable, CustomStringConvertible {
   public init(_ description: String) {
     self.init(reason: description)
   }
-    
-  public static func ==(lhs: TemplateSyntaxError, rhs: TemplateSyntaxError) -> Bool {
-    return lhs.reason == rhs.reason &&
-    lhs.description == rhs.description &&
-    lhs.token == rhs.token &&
-    lhs.stackTrace == rhs.stackTrace &&
-    lhs.templateName == rhs.templateName &&
-    lhs.allTokens == rhs.allTokens
-  }
+  
+  
 }
 
 extension Error {
diff --git a/Sources/IfTag.swift b/Sources/IfTag.swift
index 4fd6974..125f55f 100644
--- a/Sources/IfTag.swift
+++ b/Sources/IfTag.swift
@@ -118,12 +118,7 @@ final class IfExpressionParser {
   private init(components: ArraySlice<String>, tokenParser: TokenParser, token: Token) throws {
     var parsedComponents = Set<Int>()
     var bracketsBalance = 0
-    #if swift(>=4.1)
-    self.tokens = try zip(components.indices, components).compactMap { try parseComponent(index: $0.0, component: $0.1) }
-    #else
-    self.tokens = try zip(components.indices, components).flatMap { try parseComponent(index: $0.0, component: $0.1) }
-    #endif
-    func parseComponent(index: Int, component: String) throws -> IfToken? {
+    self.tokens = try zip(components.indices, components).compactMap { (index, component) in
       guard !parsedComponents.contains(index) else { return nil }
 
       if component == "(" {
diff --git a/Sources/Inheritence.swift b/Sources/Inheritence.swift
index 1507f1f..f72f7ae 100644
--- a/Sources/Inheritence.swift
+++ b/Sources/Inheritence.swift
@@ -63,11 +63,7 @@ class ExtendsNode : NodeType {
     guard (parsedNodes.any { $0 is ExtendsNode }) == nil else {
       throw TemplateSyntaxError("'extends' cannot appear more than once in the same template")
     }
-    #if swift(>=4.1)
-        let blockNodes = parsedNodes.compactMap { $0 as? BlockNode }
-    #else
-        let blockNodes = parsedNodes.flatMap { $0 as? BlockNode }
-    #endif
+    let blockNodes = parsedNodes.compactMap { $0 as? BlockNode }
     let nodes = blockNodes.reduce([String: BlockNode]()) { (accumulator, node) -> [String: BlockNode] in
       var dict = accumulator
       dict[node.name] = node
diff --git a/Sources/Lexer.swift b/Sources/Lexer.swift
index 77e956a..a64b05c 100644
--- a/Sources/Lexer.swift
+++ b/Sources/Lexer.swift
@@ -22,17 +22,10 @@ struct Lexer {
   init(templateName: String? = nil, templateString: String) {
     self.templateName = templateName
     self.templateString = templateString
-    #if swift(>=4.1)
-      self.lines = templateString.components(separatedBy: .newlines).enumerated().compactMap {
-        guard !$0.element.isEmpty else { return nil }
-        return (content: $0.element, number: UInt($0.offset + 1), templateString.range(of: $0.element)!)
-      }
-    #else
-      self.lines = templateString.components(separatedBy: .newlines).enumerated().flatMap {
-        guard !$0.element.isEmpty else { return nil }
-        return (content: $0.element, number: UInt($0.offset + 1), templateString.range(of: $0.element)!)
-      }
-    #endif
+    self.lines = templateString.components(separatedBy: .newlines).enumerated().compactMap {
+      guard !$0.element.isEmpty else { return nil }
+      return (content: $0.element, number: UInt($0.offset + 1), templateString.range(of: $0.element)!)
+    }
   }
 
   /// Create a token that will be passed on to the parser, with the given
diff --git a/Sources/Variable.swift b/Sources/Variable.swift
index 203ecc8..797cd8a 100644
--- a/Sources/Variable.swift
+++ b/Sources/Variable.swift
@@ -117,12 +117,8 @@ public struct Variable : Equatable, Resolvable {
     return normalize(current)
   }
     
-  public static func ==(lhs: Variable, rhs: Variable) -> Bool {
-    return lhs.variable == rhs.variable
-  }
 }
 
-#if swift(>=4.1)
 private func resolveCollection<T: Collection>(_ collection: T, bit: String) -> Any? {
   if let index = Int(bit) {
     if index >= 0 && index < collection.count {
@@ -140,25 +136,6 @@ private func resolveCollection<T: Collection>(_ collection: T, bit: String) -> A
     return nil
   }
 }
-#else
-private func resolveCollection<T: Collection>(_ collection: T, bit: String) -> Any? where T.IndexDistance == Int {
-  if let index = Int(bit) {
-    if index >= 0 && index < collection.count {
-      return collection[collection.index(collection.startIndex, offsetBy: index)]
-    } else {
-      return nil
-    }
-  } else if bit == "first" {
-    return collection.first
-  } else if bit == "last" {
-    return collection[collection.index(collection.endIndex, offsetBy: -1)]
-  } else if bit == "count" {
-    return collection.count
-  } else {
-    return nil
-  }
-}
-#endif
 
 /// A structure used to represet range of two integer values expressed as `from...to`.
 /// Values should be numbers (they will be converted to integers).
diff --git a/Sources/_SwiftSupport.swift b/Sources/_SwiftSupport.swift
new file mode 100644
index 0000000..fcaa007
--- /dev/null
+++ b/Sources/_SwiftSupport.swift
@@ -0,0 +1,42 @@
+import Foundation
+
+#if swift(>=4.1)
+#else
+  public extension Sequence {
+    func compactMap<ElementOfResult>(_ transform: (Element) throws -> ElementOfResult?) rethrows -> [ElementOfResult] {
+      return try flatMap(transform)
+    }
+  }
+#endif
+
+#if swift(>=4.1)
+#else
+  public extension Collection {
+    func index(_ i: Self.Index, offsetBy n: Int) -> Self.Index {
+        let indexDistance = Self.IndexDistance(n)
+        return index(i, offsetBy: indexDistance)
+    }
+  }
+#endif
+
+#if swift(>=4.1)
+#else
+public extension TemplateSyntaxError {
+  public static func ==(lhs: TemplateSyntaxError, rhs: TemplateSyntaxError) -> Bool {
+    return lhs.reason == rhs.reason &&
+      lhs.description == rhs.description &&
+      lhs.token == rhs.token &&
+      lhs.stackTrace == rhs.stackTrace &&
+      lhs.templateName == rhs.templateName
+  }
+}
+#endif
+
+#if swift(>=4.1)
+#else
+public extension Variable {
+  public static func ==(lhs: Variable, rhs: Variable) -> Bool {
+    return lhs.variable == rhs.variable
+  }
+}
+#endif