Extract Operator?

[jessegrosjean]

Maybe this is already possible with existing operators, but I couldn't figure it out...

Extract allows you to run a parser, but discard that parser's output and instead return the Input.Subsequence that was consumed.

I'm using it to parse "unquoted text" in a query language that I'm working on. Unquoted text means you that instead of typing "My query" you can instead type My query (without quotes) as long as the text doesn't contain any keywords or other query syntax characters. I use it like this:

struct TextParser: ParserPrinter {
    var body: some ParserPrinter<Substring, Substring> {
        Parse {
            UnquotedParser()
            Many {
                Whitespace()
                UnquotedParser()
            }
        }.extract()
    }
}

struct UnquotedParser: ParserPrinter {
    var body: some ParserPrinter<Substring, Substring> {
        UnquotedSafeCharSet.filter {
            !$0.isEmpty && !keywords.contains($0.lowercased())
        }.trace("Text")
    }
}

import Parsing
import Foundation

extension Parser where Input: Collection {
    @inlinable
    public func extract() -> Parsers.Extract<Input, Self> {
        .init(upstream: self)
    }
}

extension Parsers {
    public struct Extract<Input, Upstream: Parser>: Parser where Upstream.Input == Input, Input: Collection {
        @usableFromInline
        let upstream: Upstream

        @inlinable
        public init(upstream: Upstream) {
            self.upstream = upstream
        }
        
        @inlinable
        public func parse(_ input: inout Upstream.Input) rethrows -> Input.SubSequence {
            let original = input
            let startIndex = input.startIndex
            _ = try upstream.parse(&input)
            return original[startIndex..<input.startIndex]
        }
    }
}

extension Parsers.Extract: ParserPrinter where Input: PrependableCollection {
    @inlinable
    public func print(_ output: Input.SubSequence, into input: inout Input) throws {
        input.prepend(contentsOf: output)
    }
}

[iampatbrown]

discard that parser's output and instead return the Input.Subsequence that was consumed.

Hey @jessegrosjean, this sounds like it might be the Consumed parser.

Your implementation above looks pretty similar.

swift-parsing/Sources/Parsing/ParserPrinters/Consumed.swift

Lines 16 to 20 in a0e7d73

	public func parse(_ input: inout Upstream.Input) rethrows -> Upstream.Input {
	let original = input
	_ = try self.upstream.parse(&input)
	return original[..<input.startIndex]
	}

[jessegrosjean]

Thank you, I missed that one. I think you are right that they are same ... saved me some code :)