Quick start
Parseff is a direct-style parser combinator library for OCaml 5 where parsers are plain functions (unit -> 'a), errors are typed via polymorphic variants, and the runtime handles control flow, backtracking, and streaming input. Designed for performance with zero-copy span APIs and fused operations. Build parsers with direct-style and compose with Parseff combinators API is designed to be expressiv
Ambiguity in C
If you’ve ever written a parser for C, you’ll know the most annoying part is the ambiguities. A well-designed language should let users map their high-level, abstract intentions to concrete constructs while expressing them with as little typing as possible. For that to happen, the language constructs need to be expressive and flexible, and their grammar should ideally be simple and context-free. A
Beta release: Predicated Recursive Descent for Rust
TL;DR: I made a Rust library where you can write BNF (Backus–Naur form) grammars that are as strong as manually-written recursive descent parsers. This is not a normal parser generator. The philosophy is different. I’ve been working on parsing-related things for several months at this point, and I ended up with a design where I have an actual working C parser that only took a few days to build and
Implementing Co, a Small Language With Coroutines #1: The Parser
Many major programming languages these days support some lightweight concurrency primitives. The most recent popular ones are Goroutines in Go, Coroutines in Kotlin and Async in Rust. Let’s explore some of these concepts in detail by implementing a programming language with support for coroutines and Go-style channels. Many major programming languages these days support some lightweight concurrenc
Resilient LL Parsing Tutorial
May 21, 2023 In this tutorial, I will explain a particular approach to parsing, which gracefully handles syntax errors and is thus suitable for language servers, which, by their nature, have to handle incomplete and invalid code. Explaining the problem and the solution requires somewhat less than a trivial worked example, and I want to share a couple of tricks not directly related to resilience, s
Parsing Advances
I find myself writing yet another toy parser, as one does during a Christmas break. It roughly follows Resilient LL Parsing Tutorial. Not because I need resilience, but mostly because I find producing a syntax tree and a collection of diagnostics a more natural fit for the problem than bailing out on the first error. One practical pitfall with the approach is infinite loops/recursion. Resilience s
A practical introduction to parsing
If you're reading this, you probably know how to program a computer. You write some text, and use a special thing called a "compiler" (sometimes also "interpreter") to turn that text into instructions for your computer. I want to attempt to explain a small part of the process of transforming text into those instructions, usually referred to as "parsing", by implementing a parser in Rust in an opin
Super-flat ASTs
In my previous post, I introduced the simple programming language. Near the end of that post, I mentioned that the parser isn't very efficient. Let's try to optimize it! If you're just curious about the title of the article, you can skip ahead to that section. (Re-)introducing simp First, a quick recap on the programming language being implemented here: fn fibonacci(n) { if n < 2 { n } else { fib(
Writing an Asciidoc Parser in Rust: Asciidocr
I really only ever make something when I want something to exist that doesn’t already, or when I want something that does exist to more readily suit my (admittedly) idiosyncratic needs or thoughts about how it should exist. For better or worse, I have a lot of wants, and so I make a lot of things (e.g., Two Page Tuesday, or last night’s mostly-successful attempt at tapering a pair of pants I got a
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
GitHub - davesnx/parseff: Direct-style parser combinator library for OCaml 5
Your First Parser
Your First Parser
Ambiguity in C
GitHub - wareya/pred_recdec: Predicated LL (recursive descent) parser in pure rust
Beta release: Predicated Recursive Descent for Rust
I built a 2x faster lexer, then discovered I/O was the real bottleneck
I built a 2x faster lexer, then discovered I/O was the real bottleneck
Parsing Advances
Super-flat ASTs
Writing an Asciidoc Parser in Rust: Asciidocr