PrintingParser version of Arithmetic.swift example?

[jessegrosjean]

I'm finding this library intriguing, but I'm also having a hard time figuring how to use it. In particular I'm having trouble building recursive parsers with infix operators while getting the benefit of PrintingParser.

I think most of my questions would be answered if there was a PrintingParser version of the Arithmetic parser. Does such an example exist? And if not can anyone outline the steps needed to make a PrintingParser version of the Arithmetic example that worked on this enum:

indirect enum Arithmetic: Equatable {
    case add(Self, Self)
    case subtract(Self, Self)
    case multiply(Self, Self)
    case divide(Self, Self)
    case exponent(Self, Self)
    case factor(Self)
    case value(Int)
}

[jessegrosjean]

I've made related progress (boolean parser instead of Arithmetic).

I think I have everything working, but the code needs simplification. In particular I'm having to use a custom converter for BooleanOrExpression, BooleanAndExpression, and BooleanNotExpression.

The converter code is repetitive. I think I can get rid of the repetition with a custom converter, but I'm not understanding the type system well enough to create the converter.

Could someone help me with a converter to remove the duplicate code.

I think it would look like this when used:

ParsePrint(.optionalInfix(BooleanExpression.and)) {
  ...
}

And it will take two params of BooleanExpression type. The second one optional. Then run the same logic that I'm using in the BooleanOrExpression, BooleanAndExpression custom converters.

import Parsing

indirect enum BooleanExpression: Equatable {
    case or(BooleanExpression, BooleanExpression)
    case and(BooleanExpression, BooleanExpression)
    case not(BooleanExpression)
    case group(BooleanExpression)
    case value(Bool)
}

struct BooleanExpressionParser: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        Whitespace()
        OneOf {
            BooleanOrExpression()
        }
        Whitespace()
    }
}

struct BooleanOrExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.convert(
            apply: { expr1, expr2 -> BooleanExpression in
                if let expr2 {
                    return .or(expr1, expr2)
                } else {
                    return expr1
                }
            },
            unapply: { expr in
                if case .or(let expr1, let expr2) = expr {
                    return (expr1, expr2)
                } else {
                    return (expr, nil)
                }
            }
        )) {
            BooleanAndExpression()
            Optionally {
                Whitespace(1...)
                "or".utf8
                Whitespace(1...)
                BooleanOrExpression()
            }
        }
    }
}

struct BooleanAndExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.convert(
            apply: { expr1, expr2 -> BooleanExpression in
                if let expr2 {
                    return .and(expr1, expr2)
                } else {
                    return expr1
                }
            },
            unapply: { expr in
                if case .and(let expr1, let expr2) = expr {
                    return (expr1, expr2)
                } else {
                    return (expr, nil)
                }
            }
        )) {
            BooleanNotExpression()
            Optionally {
                Whitespace(1...)
                "and".utf8
                Whitespace(1...)
                BooleanAndExpression()
            }
        }
    }
}

struct BooleanNotExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.convert(
            apply: { not, expr -> BooleanExpression in
                if not != nil {
                    return .not(expr)
                } else {
                    return expr
                }
            },
            unapply: { expr in
                if case .not(let inner) = expr {
                    return ((), inner)
                } else {
                    return (nil, expr)
                }
            }
        )) {
            Optionally {
                "not".utf8
                Whitespace(1..., .horizontal)
            }
            OneOf {
                BooleanValueExpression()
                BooleanGroupExpression()
            }
        }
    }
}

struct BooleanGroupExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.case(BooleanExpression.group)) {
            Whitespace()
            "(".utf8
            BooleanExpressionParser()
            ")".utf8
        }
    }
}

struct BooleanValueExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.case(BooleanExpression.value)) {
            Bool.parser()
        }
    }
}

func testBooleanParser() throws {
    try roundTrip("true")
    try roundTrip("true and false")
    try roundTrip("(true and false)")
    try roundTrip("true or false")
    try roundTrip("(true or false)")
    try roundTrip("(true or false) or true")
    try roundTrip("false or (true or false)")
    try roundTrip("(false) and true or false")
    try roundTrip("true and true and true")
    try roundTrip("not true")
    try roundTrip("not true and not false")
}

func roundTrip(_ input: String) throws {
    let predicate = try BooleanExpressionParser().parse(input.utf8)
    let predicateString = try BooleanExpressionParser().print(predicate)
    assert(input == String(predicateString)!)
}

[jessegrosjean]

Ok, I've got something!

This isn't the Arithmetic printer parser, but it's a boolean expression printer parser, which is the same thing as far as I'm concerned. Again, my goal was to learn the best way to build recursive parsers, with infix operators, while getting the benefit of printing parser.

From what I can tell this is fully working, while also avoiding redundant code and fitting into the swift-parsing design. Before I go and implement a full parser based on this design I would love any feedback that you might have.

• General improvements?
• Any specific improvements to the caseOptionalCombine and caseOptionalEmbed Conversions? That's the code that I'm least confident in. I wonder if anyone else has created similar conversions? Seems like there might be a more generic option that could cover all these cases, but at least I have something working.

Thanks,
Jesse

import Parsing
import CasePaths

indirect enum BooleanExpression: Equatable {
    case or(BooleanExpression, BooleanExpression)
    case and(BooleanExpression, BooleanExpression)
    case not(BooleanExpression)
    case group(BooleanExpression)
    case value(Bool)
}

struct BooleanExpressionParser: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        Whitespace()
        OneOf {
            BooleanOrExpression()
        }
        Whitespace()
    }
}

struct BooleanOrExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.caseOptionalCombine(BooleanExpression.or)) {
            BooleanAndExpression()
            Optionally {
                Whitespace(1...)
                "or".utf8
                Whitespace(1...)
                BooleanOrExpression()
            }
        }
    }
}

struct BooleanAndExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.caseOptionalCombine(BooleanExpression.and)) {
            BooleanNotExpression()
            Optionally {
                Whitespace(1...)
                "and".utf8
                Whitespace(1...)
                BooleanAndExpression()
            }
        }
    }
}

struct BooleanNotExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.caseOptionalEmbed(BooleanExpression.not)) {
            Optionally {
                "not".utf8
                Whitespace(1..., .horizontal)
            }
            OneOf {
                BooleanValueExpression()
                BooleanGroupExpression()
            }
        }
    }
}

struct BooleanGroupExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.case(BooleanExpression.group)) {
            Whitespace()
            "(".utf8
            BooleanExpressionParser()
            ")".utf8
        }
    }
}

struct BooleanValueExpression: ParserPrinter {
    var body: some ParserPrinter<Substring.UTF8View, BooleanExpression> {
        ParsePrint(.case(BooleanExpression.value)) {
            Bool.parser()
        }
    }
}

extension Conversion {
    @inlinable
    public static func caseOptionalCombine<Enum>(
        _ initializer: @escaping ((Enum, Enum)) -> Enum
    ) -> Self where Self == Conversions.CaseOptionalCombine<Enum> {
        .init(casepath: /initializer)
    }

    @inlinable
    public static func caseOptionalEmbed<Enum>(
        _ initializer: @escaping (Enum) -> Enum
    ) -> Self where Self == Conversions.CaseOptionalEmbed<Enum> {
        .init(casepath: /initializer)
    }
}

extension Conversions {
    public struct CaseOptionalCombine<Enum>: Conversion {
        @usableFromInline
        let casepath: CasePath<Enum, (Enum, Enum)>
        
        @usableFromInline
        init(casepath: CasePath<Enum, (Enum, Enum)>) {
            self.casepath = casepath
        }
        
        @inlinable
        public func apply(_ input: (Enum, Enum?)) -> Enum {
            let (v1, v2) = input
            if let v2 {
                return casepath.embed((v1, v2))
            } else {
                return v1
            }
        }
        
        @inlinable
        public func unapply(_ output: Enum) throws -> (Enum, Enum?) {
            if let (v1, v2) = casepath.extract(from: output) {
                return (v1, v2)
            } else {
                return (output, nil)
            }
        }
    }
    
    public struct CaseOptionalEmbed<Enum>: Conversion {
        @usableFromInline
        let casepath: CasePath<Enum, Enum>
        
        @usableFromInline
        init(casepath: CasePath<Enum, Enum>) {
            self.casepath = casepath
        }

        @inlinable
        public func apply(_ input: (()?, Enum)) -> Enum {
            if input.0 != nil {
                return casepath.embed(input.1)
            } else {
                return input.1
            }
        }
        
        @inlinable
        public func unapply(_ output: Enum) throws -> (()?, Enum) {
            if let v = casepath.extract(from: output) {
                return ((), v)
            } else {
                return (nil, output)
            }
        }
    }
}

func testBooleanParser() throws {
    try roundTrip("true")
    try roundTrip("true and false")
    try roundTrip("(true and false)")
    try roundTrip("true or false")
    try roundTrip("(true or false)")
    try roundTrip("(true or false) or true")
    try roundTrip("false or (true or false)")
    try roundTrip("(false) and true or false")
    try roundTrip("true and true and true")
    try roundTrip("not true")
    try roundTrip("not true and not false")
}

func roundTrip(_ input: String) throws {
    let predicate = try BooleanExpressionParser().parse(input.utf8)
    let predicateString = try BooleanExpressionParser().print(predicate)
    assert(input == String(predicateString)!)
}

[jessegrosjean]

Closing this, what I have seems to be working well.