{"article":{"slug":"parser-combinators","title":"Parser Combinators","subtitle":"Better than regex!","summary":"A hands-on TypeScript introduction to parser combinators: starting from a partial parser type, chaining parsers with sequencing and mapping, and building up a hand-rolled combinator library that parses real ping output into structured data, as a cleaner middle ground between regex and tree-sitter.","content_type":"tutorial","language":"en","canonical_url":"https://t3.at/blog/2026-10-17-parser-combinators/","author":{"name":"Florian","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"T3","url":"https://t3.at/","listing_slug":null,"listing":null},"topics":[{"name":"Programming","slug":"programming","url":"https://listedarticles.com/topics/programming"},{"name":"Tutorials","slug":"tutorials","url":"https://listedarticles.com/topics/tutorials"},{"name":"JavaScript","slug":"javascript","url":"https://listedarticles.com/topics/javascript"},{"name":"Programming Languages","slug":"programming-languages","url":"https://listedarticles.com/topics/programming-languages"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":1661,"reading_minutes":7,"published_at":"2026-10-17T00:00:00.000Z","added_at":"2026-10-18T11:13:05.274Z","updated_at":"2026-10-18T11:13:05.274Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/parser-combinators","markdown_url":"https://listedarticles.com/articles/parser-combinators.md","example":false,"citation":"Florian, T3. \"Parser Combinators.\" 17 Oct 2026. https://t3.at/blog/2026-10-17-parser-combinators/ (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://t3.at/blog/2026-10-17-parser-combinators/"},"body_markdown":"## Parser Combinators\n\n**Parsing** is the act of taking less structured input like text, and turning it into more structured data, like objects.\n\nMany of you will be familiar with using regex to parse text, and some of you might know about tree-sitter, a heavy-duty parsing library which powers the syntax highlighting in your code editor.\n\nBut regex gets messy on complex tasks, and tree-sitter often is overkill — for this middle ground, **parser combinators** are perfect. Not many people know about them, so allow me to show you!\n\n## The partial parser\n\nThe smallest unit of parsing we’ll be looking at is the **partial parser**. It gets to decide where to cut the input string, and then it returns a tuple consisting of *whatever* and the rest of the string.\n\nIt can be any old function, as long as it returns such a tuple! It can even use regex inside.\n\n▸Code definition·`pInteger`\n\n```\nconst pInteger: Parser = (input: string) => {\n const match = input.match(/^\\d+/);\n if (match == null) throw new Error();\n\n const digits = match[0];\n return [Number(digits), input.substring(digits.length)];\n};\n```\n\n## Chaining\n\nA single parser function won’t do much on its own; but by applying multiple parsers in sequence, we can consume the entire input step by step.\n\n▸Code definition·`pHello`\n\n```\nconst pHello: Parser = (input: string) => {\n if (!input.startsWith(\"Hello\")) throw new Error();\n\n return [\"Hello\", input.substring(5)];\n};\n```\n\n▸Code definition·`pIgnoreWhitespace`\n\n```\nconst pIgnoreWhitespace: Parser = (input: string) => {\n const match = input.match(/^\\s+/);\n if (match == null) throw new Error();\n\n const spaces = match[0];\n return [null, input.substring(spaces.length)];\n};\n```\n\n▸Code definition·`pInteger`\n\n```\nconst pInteger: Parser = (input: string) => {\n const match = input.match(/^\\d+/);\n if (match == null) throw new Error();\n\n const digits = match[0];\n return [Number(digits), input.substring(digits.length)];\n};\n```\n\n```\nconst [token1, input2] = pHello(\"Hello 100\");\nconst [token2, input3] = pIgnoreWhitespace(input2);\nconst [token3, input4] = pInteger(input3);\n\nconsole.log(token1, token2, token3); // \"Hello\", null, 100\nconsole.log(input4); // empty!\n```\n\n## Chaining\n\nOr, and this is where the real power of partial parsers comes in: we wrap the chain up as a new parser of its own.\n\n▸Code definition·`pHello100`\n\n```\nconst pHello100: Parser<[string, null, number]> = (input: string) => {\n const [hello, rest1] = pHello(input);\n const [space, rest2] = pIgnoreWhitespace(rest1);\n const [number, rest3] = pInteger(rest2);\n\n return [[hello, space, number], rest3];\n};\n```\n\n## pSeq\n\nOr we generalize even further and provide a function that does the chaining! “Feeding the rest of the string into the next parser” is super generic after all, and doesn’t really depend on what any single parser does.\n\nGetting the types right is tricky, but TypeScript is perfectly capable of expressing these complex variadic types.\n\n▸Code definition·`pSeq`\n\n```\ntype Parsers = { [K in keyof T]: Parser };\n\nconst pSeq = (...parsers: Parsers): Parser =>\n (input) => {\n const results = [] as unknown as T;\n let rest = input;\n for (const p of parsers) {\n const [val, next] = (p as Parser)(rest);\n results.push(val);\n rest = next;\n }\n return [results, rest];\n };\n```\n\n## Combinators\n\nSince `pSeq` combines many parsers into a new parser, we call it a **parser combinator**.\n\nTake a moment to appreciate the functional madness going on: `pSeq` is a function that takes parsers, which are functions, and it returns another parser, which is also a function.\n\nAnd only then do we actually start the parsing, by calling the resulting function with data.\n\nIt’s like we are building up this construct of nested functions to create a complex program. Kinda cool!\n\n## By the way\n\nIf splitting a string into many tokens feels somehow related to `.reduce` then you have good instincts. What we are doing here is actually the dual, which is called an *unfold* in functional circles (`reduce` is referred to as a *fold*).\n\nWhile a fold uses intermediate state — the accumulator — to combine\na list of things into one, an unfold uses intermediate state to split one thing into many.\n\nYay, maths!\n\n## Tuples are unwieldy\n\nIf the point of parsing is to get structured, often human-readable data out of raw strings, then a tuple of values like `[\"Hello\", null, 100]` can hardly be the end goal.\n\nWe could of course map over the result to transform it into a more convenient shape.\n\n```\nconst pHello100 = pSeq(...);\nconst [result, rest] = pHello100(\"Hello 100\");\n\nconsole.log(result); // [\"Hello\", null, 100]\n\nconst parsed = {\n greeting: result[0],\n who: result[2],\n};\n```\n\n## pMap\n\nBut this is not in the spirit of parser combinators! Like before, we can also wrap the mapping into a new parser combinator itself.\n\n`pMap` takes a parser and a function; the function will be applied\nto the eventual result after parsing.\n\n▸Code definition·`pMap`\n\n```\nconst pMap = (parser: Parser, fn: (value: T) => R): Parser =>\n (input: string) => {\n const [value, rest] = parser(input);\n return [fn(value), rest];\n };\n```\n\n```\nconst pGreeting = pMap(\n pHello100,\n ([greeting, _, who]) => ({ greeting, who }),\n);\n\nconst [parsed, rest] = pGreeting(\"Hello 100\");\n\nconsole.log(parsed); // { greeting: \"Hello\", who: 100 }\n```\n\n## pRepeat\n\nBefore we hop into a practical example, let me show the third fundamental parser combinator: `pRepeat` — it takes a given\nparser and applies it over and over again until it can’t.\n\nIt’s the `*` of regex, as a combinator!\n\n▸Code definition·`pRepeat`\n\n```\nconst pRepeat = (parser: Parser): Parser =>\n (input: string) => {\n const values: T[] = [];\n let rest = input;\n while (true) {\n try {\n const [value, next] = parser(rest);\n values.push(value);\n rest = next;\n } catch {\n return [values, rest];\n }\n }\n };\n```\n\n▸Code definition·`pNumber`\n\n```\nconst pNumber: Parser = (input: string) => {\n const match = input.match(/^\\d+/);\n if (match == null) throw new Error();\n\n const digits = match[0];\n return [Number(digits), input.substring(digits.length)];\n};\n```\n\n▸Code definition·`pSemicolon`\n\n```\nconst pSemicolon: Parser = (input: string) => {\n if (!input.startsWith(\";\")) throw new Error();\n\n return [\";\", input.substring(1)];\n};\n```\n\n```\nconst pNumberCsv = pRepeat(pSeq(pNumber, pSemicolon));\n\npNumberCsv(\"10;20;30;\");\n// [[[10, \";\"], [20, \";\"], [30, \";\"]], \"\"]\n```\n\n## Let’s build a parser!\n\nWe have enough tools now to start parsing actual, real-world data!\n\nAbove is a sample output of me pinging Cloudflare. There’s tons\nof useful info in there, so let’s parse it into structured data —\nhow about this:\n\n```\ntype PingResult = {\n header: PingHeader;\n packets: IcmpPacket[];\n statistics: PingStatistics;\n};\n\ntype IcmpPacket = {\n byteCount: number; from: string;\n seq: number; ttl: number; time: number;\n};\n\ntype PingHeader = {\n targetIp: string; // 1.1.1.1\n resolvedIp: string; // 1.1.1.1 but in parentheses\n icmpPayloadSize: number; // 56\n totalPacketSize: number; // 84\n};\n\ntype PingStatistics = {\n packetsTransmitted: number; packetsReceived: number;\n packetLoss: number; time: number;\n rtt: { min: number; avg: number; max: number; mdev: number };\n};\n```\n\n## Bits and Bobs\n\nWe have some recurring things in this output like decimal numbers or IP addresses. So let’s set those up first.\n\n▸Code definition·`pString`\n\n```\n// Exact text, like \"PING\"\nconst pString = (text: string): Parser => (input: string) => {\n if (!input.startsWith(text)) throw new Error();\n\n return [text, input.substring(text.length)];\n};\n```\n\n▸Code definition·`pInteger`\n\n```\n// Whole numbers, like 64\nconst pInteger: Parser = (input: string) => {\n const match = input.match(/^\\d+/);\n if (match == null) throw new Error();\n\n const digits = match[0];\n return [Number(digits), input.substring(digits.length)];\n};\n```\n\n▸Code definition·`pDecimal`\n\n```\n// Numbers with an optional fraction, like 68.7\nconst pDecimal: Parser = (input: string) => {\n const match = input.match(/^\\d+(\\.\\d+)?/);\n if (match == null) throw new Error();\n\n const digits = match[0];\n return [Number(digits), input.substring(digits.length)];\n};\n```\n\n▸Code definition·`pIpV4Address`\n\n```\n// Four bytes and three dots, like 1.1.1.1\nconst pByte = pMap(pInteger, (n) => {\n if (n > 255) throw new Error();\n return n;\n});\n\nconst pDot = pString(\".\");\n\nconst pIpV4Address = pMap(\n pSeq(pByte, pDot, pByte, pDot, pByte, pDot, pByte),\n ([a, _1, b, _2, c, _3, d]) => `${a}.${b}.${c}.${d}`,\n);\n```\n\n▸Code definition·`pWhitespace`\n\n```\n// At least one space\nconst pWhitespace: Parser = (input: string) => {\n const match = input.match(/^\\s+/);\n if (match == null) throw new Error();\n\n return [null, input.substring(match[0].length)];\n};\n```\n\n## The header\n\nThe first line should be easy, it’s just some `pSeq` of parsers and then a `pMap` to finagle it into `PingHeader` shape.\n\n▸Code definition·`pPingHeaderParts`\n\n```\nconst pPingHeaderParts = pSeq(\n pString(\"PING\"), pWhitespace, pIpV4Address, pWhitespace,\n pString(\"(\"), pIpV4Address, pString(\")\"), pWhitespace,\n pInteger, pString(\"(\"), pInteger, pString(\")\"),\n pString(\" bytes of data.\"),\n);\n```\n\n▸Code definition·`pPingHeader`\n\n```\nconst pPingHeader = pMap(\n pPingHeaderParts,\n ([a, b, c, d, e, f, g, h, i, j, k, l, m]) => ({\n targetIp: c,\n resolvedIp: f,\n icmpPayloadSize: i,\n totalPacketSize: k,\n }),\n);\n```\n\n## A packet\n\nActually the packets are also a `pSeq` of parsers, followed by a\n`pMap`. This parsing stuff is really easy, hey!\n\n▸Code definition·`pIcmpPacketParts`\n\n```\nconst pIcmpPacketParts = pSeq(\n pInteger, pString(\" bytes from \"), pIpV4Address,\n pString(\": icmp_seq=\"), pInteger,\n pString(\" ttl=\"), pInteger,\n pString(\" time=\"), pDecimal, pString(\" ms\"),\n);\n```\n\n▸Code definition·`pIcmpPacket`\n\n```\nconst pIcmpPacket = pMap(\n pIcmpPacketParts,\n ([a, b, c, d, e, f, g, h, i, j]) => ({\n byteCount: a, from: c, seq: e, ttl: g, time: i,\n }),\n);\n```\n\n## The statistics\n\nCould you imagine doing this in regex by the way?\n\n▸Code definition·`pUselessLine`\n\n```\nconst pUselessLine = pSeq(\n pString(\"--- \"), pIpV4Address, pString(\" ping statistics ---\"),\n);\n```\n\n▸Code definition·`pStatsLine1`\n\n```\nconst pStatsLine1 = pSeq(\n pInteger, pString(\" packets transmitted, \"),\n pInteger, pString(\" received, \"),\n pDecimal, pString(\"% packet loss, time \"),\n pInteger, pString(\"ms\"),\n);\n```\n\n▸Code definition·`pStatsLine2`\n\n```\nconst pStatsLine2 = pSeq(\n pString(\"rtt min/avg/max/mdev = \"),\n pDecimal, pString(\"/\"), pDecimal, pString(\"/\"),\n pDecimal, pString(\"/\"), pDecimal,\n pString(\" ms\"),\n);\n```\n\n▸Code definition·`pPingStatistics`\n\n```\nconst pPingStatistics = pMap(\n pSeq(pUselessLine, pWhitespace, pStatsLine1, pWhitespace, pStatsLine2),\n ([_1, _2, [a, b, c, d, e, f, g, h], _3, [i, j, k, l, m, n, o, p, q]]) => ({\n packetsTransmitted: a, packetsReceived: c,\n packetLoss: e, time: g,\n rtt: { min: j, avg: l, max: n, mdev: p },\n }),\n);\n```\n\n## Ping packets, parsed!\n\nAnd boom, that’s pretty much it! Just one more `pSeq` and `pMap` to wrap all the parts together, and we have built a complete parser for the ping command.\n\nThat was super easy, right?\n\n▸Code definition·`pPingSummary`\n\n```\nconst pPingSummary: Parser = pMap(\n pSeq(\n pPingHeader,\n pRepeat(pMap(pSeq(pWhitespace, pIcmpPacket), ([_, packet]) => packet)),\n pWhitespace,\n pPingStatistics,\n ),\n ([header, packets, _, statistics]) => ({ header, packets, statistics }),\n);\n```\n\n## Go give it a try\n\nIn a single post we built a fairly complicated parser from literally zero, and a hand-rolled parser combinator library along the way!\n\nIt’s much easier to create correct and maintainable parsers this way than with a regex; once you start nesting `pSeq` calls, the equivalent regex would become an unreadable mess, while the combinator approach gives you something squeaky clean.\n\nIn case you are missing fancier features like backtracking or lookahead, rest assured that parser combinators can handle those scenarios as well, since at the end of the day it’s all just functions composed together.\n\nGo give them a try next time you have to parse something — parser combinators are a really elegant solution to the parser problem, and many more people should use them!\n","body_html":"

Parser Combinators

\n

Parsing is the act of taking less structured input like text, and turning it into more structured data, like objects.

\n

Many of you will be familiar with using regex to parse text, and some of you might know about tree-sitter, a heavy-duty parsing library which powers the syntax highlighting in your code editor.

\n

But regex gets messy on complex tasks, and tree-sitter often is overkill — for this middle ground, parser combinators are perfect. Not many people know about them, so allow me to show you!

\n

The partial parser

\n

The smallest unit of parsing we’ll be looking at is the partial parser. It gets to decide where to cut the input string, and then it returns a tuple consisting of whatever and the rest of the string.

\n

It can be any old function, as long as it returns such a tuple! It can even use regex inside.

\n

▸Code definition·pInteger

\n
const pInteger: Parser<number> = (input: string) => {\n  const match = input.match(/^\\d+/);\n  if (match == null) throw new Error();\n\n  const digits = match[0];\n  return [Number(digits), input.substring(digits.length)];\n};
\n

Chaining

\n

A single parser function won’t do much on its own; but by applying multiple parsers in sequence, we can consume the entire input step by step.

\n

▸Code definition·pHello

\n
const pHello: Parser<string> = (input: string) => {\n  if (!input.startsWith("Hello")) throw new Error();\n\n  return ["Hello", input.substring(5)];\n};
\n

▸Code definition·pIgnoreWhitespace

\n
const pIgnoreWhitespace: Parser<null> = (input: string) => {\n  const match = input.match(/^\\s+/);\n  if (match == null) throw new Error();\n\n  const spaces = match[0];\n  return [null, input.substring(spaces.length)];\n};
\n

▸Code definition·pInteger

\n
const pInteger: Parser<number> = (input: string) => {\n  const match = input.match(/^\\d+/);\n  if (match == null) throw new Error();\n\n  const digits = match[0];\n  return [Number(digits), input.substring(digits.length)];\n};
\n
const [token1, input2] = pHello("Hello 100");\nconst [token2, input3] = pIgnoreWhitespace(input2);\nconst [token3, input4] = pInteger(input3);\n\nconsole.log(token1, token2, token3); // "Hello", null, 100\nconsole.log(input4); // empty!
\n

Chaining

\n

Or, and this is where the real power of partial parsers comes in: we wrap the chain up as a new parser of its own.

\n

▸Code definition·pHello100

\n
const pHello100: Parser<[string, null, number]> = (input: string) => {\n  const [hello, rest1] = pHello(input);\n  const [space, rest2] = pIgnoreWhitespace(rest1);\n  const [number, rest3] = pInteger(rest2);\n\n  return [[hello, space, number], rest3];\n};
\n

pSeq

\n

Or we generalize even further and provide a function that does the chaining! “Feeding the rest of the string into the next parser” is super generic after all, and doesn’t really depend on what any single parser does.

\n

Getting the types right is tricky, but TypeScript is perfectly capable of expressing these complex variadic types.

\n

▸Code definition·pSeq

\n
type Parsers<T extends unknown[]> = { [K in keyof T]: Parser<T[K]> };\n\nconst pSeq = <T extends unknown[]>(...parsers: Parsers<T>): Parser<T> =>\n  (input) => {\n    const results = [] as unknown as T;\n    let rest = input;\n    for (const p of parsers) {\n      const [val, next] = (p as Parser<unknown>)(rest);\n      results.push(val);\n      rest = next;\n    }\n    return [results, rest];\n  };
\n

Combinators

\n

Since pSeq combines many parsers into a new parser, we call it a parser combinator.

\n

Take a moment to appreciate the functional madness going on: pSeq is a function that takes parsers, which are functions, and it returns another parser, which is also a function.

\n

And only then do we actually start the parsing, by calling the resulting function with data.

\n

It’s like we are building up this construct of nested functions to create a complex program. Kinda cool!

\n

By the way

\n

If splitting a string into many tokens feels somehow related to .reduce then you have good instincts. What we are doing here is actually the dual, which is called an unfold in functional circles (reduce is referred to as a fold).

\n

While a fold uses intermediate state — the accumulator — to combine\na list of things into one, an unfold uses intermediate state to split one thing into many.

\n

Yay, maths!

\n

Tuples are unwieldy

\n

If the point of parsing is to get structured, often human-readable data out of raw strings, then a tuple of values like ["Hello", null, 100] can hardly be the end goal.

\n

We could of course map over the result to transform it into a more convenient shape.

\n
const pHello100 = pSeq(...);\nconst [result, rest] = pHello100("Hello 100");\n\nconsole.log(result); // ["Hello", null, 100]\n\nconst parsed = {\n  greeting: result[0],\n  who: result[2],\n};
\n

pMap

\n

But this is not in the spirit of parser combinators! Like before, we can also wrap the mapping into a new parser combinator itself.

\n

pMap takes a parser and a function; the function will be applied\nto the eventual result after parsing.

\n

▸Code definition·pMap

\n
const pMap = <T, R>(parser: Parser<T>, fn: (value: T) => R): Parser<R> =>\n  (input: string) => {\n    const [value, rest] = parser(input);\n    return [fn(value), rest];\n  };
\n
const pGreeting = pMap(\n  pHello100,\n  ([greeting, _, who]) => ({ greeting, who }),\n);\n\nconst [parsed, rest] = pGreeting("Hello 100");\n\nconsole.log(parsed); // { greeting: "Hello", who: 100 }
\n

pRepeat

\n

Before we hop into a practical example, let me show the third fundamental parser combinator: pRepeat — it takes a given\nparser and applies it over and over again until it can’t.

\n

It’s the * of regex, as a combinator!

\n

▸Code definition·pRepeat

\n
const pRepeat = <T>(parser: Parser<T>): Parser<T[]> =>\n  (input: string) => {\n    const values: T[] = [];\n    let rest = input;\n    while (true) {\n      try {\n        const [value, next] = parser(rest);\n        values.push(value);\n        rest = next;\n      } catch {\n        return [values, rest];\n      }\n    }\n  };
\n

▸Code definition·pNumber

\n
const pNumber: Parser<number> = (input: string) => {\n  const match = input.match(/^\\d+/);\n  if (match == null) throw new Error();\n\n  const digits = match[0];\n  return [Number(digits), input.substring(digits.length)];\n};
\n

▸Code definition·pSemicolon

\n
const pSemicolon: Parser<string> = (input: string) => {\n  if (!input.startsWith(";")) throw new Error();\n\n  return [";", input.substring(1)];\n};
\n
const pNumberCsv = pRepeat(pSeq(pNumber, pSemicolon));\n\npNumberCsv("10;20;30;");\n// [[[10, ";"], [20, ";"], [30, ";"]], ""]
\n

Let’s build a parser!

\n

We have enough tools now to start parsing actual, real-world data!

\n

Above is a sample output of me pinging Cloudflare. There’s tons\nof useful info in there, so let’s parse it into structured data —\nhow about this:

\n
type PingResult = {\n  header: PingHeader;\n  packets: IcmpPacket[];\n  statistics: PingStatistics;\n};\n\ntype IcmpPacket = {\n  byteCount: number; from: string;\n  seq: number; ttl: number; time: number;\n};\n\ntype PingHeader = {\n  targetIp: string;        // 1.1.1.1\n  resolvedIp: string;      // 1.1.1.1 but in parentheses\n  icmpPayloadSize: number; // 56\n  totalPacketSize: number; // 84\n};\n\ntype PingStatistics = {\n  packetsTransmitted: number; packetsReceived: number;\n  packetLoss: number; time: number;\n  rtt: { min: number; avg: number; max: number; mdev: number };\n};
\n

Bits and Bobs

\n

We have some recurring things in this output like decimal numbers or IP addresses. So let’s set those up first.

\n

▸Code definition·pString

\n
// Exact text, like "PING"\nconst pString = (text: string): Parser<string> => (input: string) => {\n  if (!input.startsWith(text)) throw new Error();\n\n  return [text, input.substring(text.length)];\n};
\n

▸Code definition·pInteger

\n
// Whole numbers, like 64\nconst pInteger: Parser<number> = (input: string) => {\n  const match = input.match(/^\\d+/);\n  if (match == null) throw new Error();\n\n  const digits = match[0];\n  return [Number(digits), input.substring(digits.length)];\n};
\n

▸Code definition·pDecimal

\n
// Numbers with an optional fraction, like 68.7\nconst pDecimal: Parser<number> = (input: string) => {\n  const match = input.match(/^\\d+(\\.\\d+)?/);\n  if (match == null) throw new Error();\n\n  const digits = match[0];\n  return [Number(digits), input.substring(digits.length)];\n};
\n

▸Code definition·pIpV4Address

\n
// Four bytes and three dots, like 1.1.1.1\nconst pByte = pMap(pInteger, (n) => {\n  if (n > 255) throw new Error();\n  return n;\n});\n\nconst pDot = pString(".");\n\nconst pIpV4Address = pMap(\n  pSeq(pByte, pDot, pByte, pDot, pByte, pDot, pByte),\n  ([a, _1, b, _2, c, _3, d]) => `${a}.${b}.${c}.${d}`,\n);
\n

▸Code definition·pWhitespace

\n
// At least one space\nconst pWhitespace: Parser<null> = (input: string) => {\n  const match = input.match(/^\\s+/);\n  if (match == null) throw new Error();\n\n  return [null, input.substring(match[0].length)];\n};
\n

The header

\n

The first line should be easy, it’s just some pSeq of parsers and then a pMap to finagle it into PingHeader shape.

\n

▸Code definition·pPingHeaderParts

\n
const pPingHeaderParts = pSeq(\n  pString("PING"), pWhitespace, pIpV4Address, pWhitespace,\n  pString("("), pIpV4Address, pString(")"), pWhitespace,\n  pInteger, pString("("), pInteger, pString(")"),\n  pString(" bytes of data."),\n);
\n

▸Code definition·pPingHeader

\n
const pPingHeader = pMap(\n  pPingHeaderParts,\n  ([a, b, c, d, e, f, g, h, i, j, k, l, m]) => ({\n    targetIp: c,\n    resolvedIp: f,\n    icmpPayloadSize: i,\n    totalPacketSize: k,\n  }),\n);
\n

A packet

\n

Actually the packets are also a pSeq of parsers, followed by a\npMap. This parsing stuff is really easy, hey!

\n

▸Code definition·pIcmpPacketParts

\n
const pIcmpPacketParts = pSeq(\n  pInteger, pString(" bytes from "), pIpV4Address,\n  pString(": icmp_seq="), pInteger,\n  pString(" ttl="), pInteger,\n  pString(" time="), pDecimal, pString(" ms"),\n);
\n

▸Code definition·pIcmpPacket

\n
const pIcmpPacket = pMap(\n  pIcmpPacketParts,\n  ([a, b, c, d, e, f, g, h, i, j]) => ({\n    byteCount: a, from: c, seq: e, ttl: g, time: i,\n  }),\n);
\n

The statistics

\n

Could you imagine doing this in regex by the way?

\n

▸Code definition·pUselessLine

\n
const pUselessLine = pSeq(\n  pString("--- "), pIpV4Address, pString(" ping statistics ---"),\n);
\n

▸Code definition·pStatsLine1

\n
const pStatsLine1 = pSeq(\n  pInteger, pString(" packets transmitted, "),\n  pInteger, pString(" received, "),\n  pDecimal, pString("% packet loss, time "),\n  pInteger, pString("ms"),\n);
\n

▸Code definition·pStatsLine2

\n
const pStatsLine2 = pSeq(\n  pString("rtt min/avg/max/mdev = "),\n  pDecimal, pString("/"), pDecimal, pString("/"),\n  pDecimal, pString("/"), pDecimal,\n  pString(" ms"),\n);
\n

▸Code definition·pPingStatistics

\n
const pPingStatistics = pMap(\n  pSeq(pUselessLine, pWhitespace, pStatsLine1, pWhitespace, pStatsLine2),\n  ([_1, _2, [a, b, c, d, e, f, g, h], _3, [i, j, k, l, m, n, o, p, q]]) => ({\n    packetsTransmitted: a, packetsReceived: c,\n    packetLoss: e, time: g,\n    rtt: { min: j, avg: l, max: n, mdev: p },\n  }),\n);
\n

Ping packets, parsed!

\n

And boom, that’s pretty much it! Just one more pSeq and pMap to wrap all the parts together, and we have built a complete parser for the ping command.

\n

That was super easy, right?

\n

▸Code definition·pPingSummary

\n
const pPingSummary: Parser<PingResult> = pMap(\n  pSeq(\n    pPingHeader,\n    pRepeat(pMap(pSeq(pWhitespace, pIcmpPacket), ([_, packet]) => packet)),\n    pWhitespace,\n    pPingStatistics,\n  ),\n  ([header, packets, _, statistics]) => ({ header, packets, statistics }),\n);
\n

Go give it a try

\n

In a single post we built a fairly complicated parser from literally zero, and a hand-rolled parser combinator library along the way!

\n

It’s much easier to create correct and maintainable parsers this way than with a regex; once you start nesting pSeq calls, the equivalent regex would become an unreadable mess, while the combinator approach gives you something squeaky clean.

\n

In case you are missing fancier features like backtracking or lookahead, rest assured that parser combinators can handle those scenarios as well, since at the end of the day it’s all just functions composed together.

\n

Go give them a try next time you have to parse something — parser combinators are a really elegant solution to the parser problem, and many more people should use them!

","headings":[{"level":2,"text":"Parser Combinators","id":"parser-combinators"},{"level":2,"text":"The partial parser","id":"the-partial-parser"},{"level":2,"text":"Chaining","id":"chaining"},{"level":2,"text":"Chaining","id":"chaining-2"},{"level":2,"text":"pSeq","id":"pseq"},{"level":2,"text":"Combinators","id":"combinators"},{"level":2,"text":"By the way","id":"by-the-way"},{"level":2,"text":"Tuples are unwieldy","id":"tuples-are-unwieldy"},{"level":2,"text":"pMap","id":"pmap"},{"level":2,"text":"pRepeat","id":"prepeat"},{"level":2,"text":"Let’s build a parser!","id":"let-s-build-a-parser"},{"level":2,"text":"Bits and Bobs","id":"bits-and-bobs"},{"level":2,"text":"The header","id":"the-header"},{"level":2,"text":"A packet","id":"a-packet"},{"level":2,"text":"The statistics","id":"the-statistics"},{"level":2,"text":"Ping packets, parsed!","id":"ping-packets-parsed"},{"level":2,"text":"Go give it a try","id":"go-give-it-a-try"}]}}