AoC Day 11: Monkey in the Middle - this framework made parsing it so simple! 🤩

[oliverfoggin]

I've been using swift-parsing for this year's AoC and it has been an excellent learning tool.

Until I came to this problem... https://adventofcode.com/2022/day/11

Which has an input like this...

Monkey 0:
  Starting items: 79, 98
  Operation: new = old * 19
  Test: divisible by 23
    If true: throw to monkey 2
    If false: throw to monkey 3

Monkey 1:
  Starting items: 54, 65, 75, 74
  Operation: new = old + 6
  Test: divisible by 19
    If true: throw to monkey 2
    If false: throw to monkey 0

Monkey 2:
  Starting items: 79, 60, 97
  Operation: new = old * old
  Test: divisible by 13
    If true: throw to monkey 1
    If false: throw to monkey 3

Monkey 3:
  Starting items: 74
  Operation: new = old + 3
  Test: divisible by 17
    If true: throw to monkey 0
    If false: throw to monkey 1

I was a bit apprehensive when I first saw this because this is the kind of input that is really hard to parse.

And I am not exaggerating when I say that swift-parsing made this trivial.

I worked through the parser and added types and properties as and when they were needed and it literally worked first time. 🤯

Anyway, up to then it was on a par with just raw parsing. In fact... I had done everything without using swift-parsing up to Day8. It was with this one that the power of this framework suddenly became apparent.

Anyway... here's my Parser (without any of the logic so no spoilers) but you can almost read through it and see what the input is from the parser. (Also, I'm still learning so this may not be optimal).

private enum Parsers {
	static let items = Many(1...) {
		Int.parser(of: Substring.self)
	} separator: {
		", "
	}

	static let function = Parse {
		Skip { "new = old " }
		OneOf {
			"+".map { OpType.add }
			"*".map { OpType.multiply }
		}
		Skip { " " }
		OneOf {
			Int.parser().map { OpValue.number($0) }
			"old".map { OpValue.old }
		}
	}

	static let monkey = Parse(Monkey.init) {
		"Monkey "; Int.parser(); ":"
		"\n  Starting items: "; items
		"\n  Operation: "; function
		"\n  Test: divisible by "; Int.parser()
		"\n    If true: throw to monkey "; Int.parser()
		"\n    If false: throw to monkey "; Int.parser()
	}

	static let input = Many {
		monkey
	} separator: {
		Whitespace(2, .vertical)
	} terminator: {
		Whitespace(1, .vertical)
	}
}

[lukeredpath]

Small tip - you don’t need the skip around the string literal parsers as these are void parsers anyway.

[oliverfoggin]

Thanks! I actually noticed that after posting and went back through my code to remove where I had added it.

Funnily, I started without it and then obvs had a brain fade and starting Skipping all the literally. 😂

[mbrandonw]

Really awesome @oliverfoggin. Exciting to see how simple that parser turned out to be!