line and column

Author: ay42

Package.swift

@@ -27,7 +27,11 @@ let package = Package(
     ],
     targets: [
         .target(
-            name: "Coder"),
+            name: "Coder",
+            dependencies: [
+                .product(name: "Binary", package: "swift-binary")
+            ]
+        ),
         .testTarget(
             name: "CoderTests",
             dependencies: ["Coder"]),

Sources/Coder/Coder.swift

@@ -1 +1 @@
-
+@_exported import Binary

Sources/StringDecoder/Combinators/StringDecoder+Chain.swift

@@ -12,4 +12,16 @@ public extension StringDecoder {
 
         return flatMap(rest)
     }
+    
+    func chainRight(_ op: StringDecoder<(Element, Element) -> Element, Failure>) -> Self {
+        func rest(_ x: Element) -> Self {
+            op.flatMap { f in
+                self.chainRight(op).map { y in
+                    f(x, y)
+                }
+            }.or(pure(x))
+        }
+
+        return self.flatMap(rest)
+    }
 }

Sources/StringDecoder/Combinators/StringDecoder+LookAhead.swift

@@ -7,7 +7,7 @@ public extension StringDecoder {
             case .success:
                 return self.decode(input)
             case .failure:
-                return self.decode(State(string: "", offset: input.offset))
+                return self.decode(State(string: "", offset: input.offset, line: input.line, column: input.column))
             }
         }
     }

Sources/StringDecoder/Combinators/StringDecoder+TryAhead.swift

@@ -5,7 +5,7 @@ public extension StringDecoder {
         StringDecoder { input in
             switch forwardEncoder(input) {
             case .success:
-                return self.decode(State(string: "", offset: input.offset))
+                return self.decode(State(string: "", offset: input.offset, line: input.line, column: input.column))
             case .failure:
                 return self.decode(input)
             }

Sources/StringDecoder/Decoders/StringDecoder+Indent.swift

@@ -3,3 +3,16 @@ import Foundation
 public let leftParentheses: StringDecoder<Character, StringDecoderFailure> = match(Character("("))
 
 public let rightParentheses: StringDecoder<Character, StringDecoderFailure> = match(Character(")"))
+
+
+public let leftCurlyBracket: StringDecoder<Character, StringDecoderFailure> = match(Character("{"))
+public let rightCurlyBracket: StringDecoder<Character, StringDecoderFailure> = match(Character("}"))
+
+public extension StringDecoder where Failure == StringDecoderFailure {
+    var insideCurlyBrackets: Self {
+        self.between(
+            open: leftCurlyBracket.discard(whitespace()),
+            close: whitespace().discardThen(rightCurlyBracket)
+        )
+    }
+}

Sources/StringDecoder/Decoders/StringDecoder+Parentheses.swift

@@ -0,0 +1,5 @@
+import Foundation
+
+public func isSigil(_ c: Character) -> Bool {
+    c == "$"
+}

Sources/StringDecoder/Decoders/StringDecoder+Sigil.swift

@@ -15,3 +15,11 @@ public func space() -> StringDecoder<String, StringDecoderFailure> {
 public func newline() -> StringDecoder<String, StringDecoderFailure> {
     match("\n")
 }
+
+public let horizontalWhitespace: StringDecoder<String, StringDecoderFailure> = tab().or(space()).many.map { String($0.flatMap { $0 }) }
+
+public extension StringDecoder where Failure == StringDecoderFailure {
+    var insideHorizontalWhitespace: Self {
+        self.between(horizontalWhitespace)
+    }
+}

Sources/StringDecoder/Decoders/StringDecoder+Whitespace.swift

@@ -3,34 +3,66 @@ import Foundation
 public struct State: Equatable {
     public let string: String
     public var offset: UInt64
-    public internal(set) var indentation: Int
-    
-    public init(string: String, offset: UInt64, indentation: Int = 0) {
+    public var line: UInt
+    public var column: UInt
+
+    public init(string: String, offset: UInt64, line: UInt, column: UInt) {
         self.string = string
         self.offset = offset
-        self.indentation = indentation
+        self.line = line
+        self.column = column
     }
-    
+
     public var head: Character? {
         guard string.characters.indices.contains(Int(offset)) else { return nil }
         return string.characters[Int(offset)]
     }
-    
+
     public var next: State {
         advanced(by: 1)
     }
-    
+
     public func advanced(by count: Int) -> State {
-        State(string: string, offset: offset + UInt64(count), indentation: indentation)
+        var newLine = line
+        var newColumn = column
+        var newOffset = offset
+
+        for _ in 0..<count {
+            if let character = head {
+                if character == "\n" {
+                    newLine += 1
+                    newColumn = 1
+                } else {
+                    newColumn += 1
+                }
+                newOffset += 1
+            } else {
+                break
+            }
+        }
+
+        return State(string: string, offset: newOffset, line: newLine, column: newColumn)
     }
-    
-    public func indent(by count: Int) -> State {
-        State(string: string, offset: offset, indentation: indentation + count)
+
+    public var positionMetadata: PositionMetadata {
+        PositionMetadata(offset: offset, line: line, column: column)
     }
 }
 
 extension State: ExpressibleByArrayLiteral {
     public init(arrayLiteral elements: Character...) {
-        self = State(string: String(elements), offset: 0)
+        self = State(string: String(elements), offset: 0, line: 1, column: 1)
+    }
+}
+
+public struct PositionMetadata: Equatable {
+    public let offset: UInt64
+    public let line: UInt
+    public let column: UInt
+
+    public init(offset: UInt64, line: UInt, column: UInt) {
+        self.offset = offset
+        self.line = line
+        self.column = column
     }
 }