> Markdown rendition of https://typeglish.dev/blog/typeglish-0-3-0 ("TypeGlish 0.3.0: the function-word floor - Tidelines"). Canonical page: https://typeglish.dev/blog/typeglish-0-3-0 · All pages: https://typeglish.dev/llms.txt

[← Tidelines](https://typeglish.dev/blog)/ Releases Jul 21, 2026

# TypeGlish 0.3.0: the function-word floor

The small words carry the logic. 0.3.0 makes articles, prepositions, the quantifiers `every` and `each`, and the bare copula paint, so the compiler reads the words that hold a sentence together instead of stepping over them.

by **TypeGlish team** 5 min read #releases `typeglish 0.3.0`

Every word counts.

**TL;DR** 0.3.0 lays the function-word floor: articles, prepositions, the quantifiers `every` and `each`, and the bare copula `be` now paint, so the compiler reads the closed-class words instead of skimming them. The payoff is logic that lives in the small words: `Every refund is approved` and `No refund is approved` now provably conflict (`logic/quantifier`), while an adverb or a preposition that splits two rules apart keeps a false conflict from firing. Upgrade with `npm i -D typeglish@latest`.

For four releases the world model has been filling in the open word classes: nouns, verbs, adjectives, adverbs, the words that carry the topic of a sentence. 0.3.0 lays the floor underneath all of it. The closed classes, the function words that never change and do the structural work, now paint too: the articles `a` / `an` / `the`, the prepositions, the quantifiers `every` and `each`, and the bare copula `be`. This is the point in the coverage map where the small words stop being scenery and start being read. Upgrade with `npm i -D typeglish@latest`, or run it with no install at all: `npx typeglish@latest check **/*.tg`. Here is why it matters.

## §1 The small words paint now

A function word is small, fixed, and load-bearing. English has only a few hundred of them and you never coin a new one, but they are where the logic of a sentence lives: `every` against `no`, `the` against `a`, `with` against `without`. Until now the checker read the topic words and let most of these pass as prose. 0.3.0 paints them, and the first place you feel it is the quantifiers: `every` and `each` now read as the universal, the same corner of the square of opposition as `all`. That is enough to prove a contradiction that hides entirely in the small words.

refunds.tg logic/quantifier

```typeglish
You are a refund assistant.

Every refund is approved.
No refund is approved.
```

Nothing in those two rules is a keyword in the old sense: no `MUST`, no `WHEN`, no numbers. The only words that disagree are `every` and `no` over the same predicate, and 0.3.0 reads them as the universal and its denial, so the checker blocks the build with `logic/quantifier` and names the line to keep. The CI guard on this post re-proves that exact code against the real checker on every build. It is the same square of opposition behind [Say it once, or say it's optional](https://typeglish.dev/blog/say-it-once), now reaching the two quantifiers people reach for most.

This is the kind of conflict that survives review because it reads fine. "Every refund is approved" and "No refund is approved" sit ten lines apart in a real policy, one in the happy path and one in an exceptions block, and a human skims past both. The compiler does not, because it now reads `every` and `no` as the operators they are.

## §2 And they keep the checker honest

The same painting that catches a real conflict is what stops a false one. A quantifier only contradicts another when they claim the same thing, and whether two rules claim the same thing often turns on a preposition or an adverb, another set of function words 0.3.0 now reads. Change the small words after the verb and the two rules stop being about the same predicate, so they coexist:

refunds-scoped.tg ✓ compiles

```typeglish
You are a refund assistant.

Every refund is approved automatically.
No refund is approved without a manager.
```

Same subject, same quantifiers, and yet this compiles clean, because the adverb `automatically` and the prepositional phrase `without a manager` give the two rules different predicates. Approving automatically and approving without a manager are not the same act, so `every` and `no` are talking past each other, not fighting. A checker that skipped the small words would either miss the conflict in §1 or invent one here; reading them is what tells the two cases apart. The guard on this post asserts this file compiles with no blocking error.

That is the whole point of a floor: not a new rule to obey, but the last layer of words the compiler reads, so its verdicts turn on the same details you meant when you wrote the sentence. It is the closed-class complement to the open word classes the [0.2.3 notes](https://typeglish.dev/blog/typeglish-0-2-3) laid out, and it is the piece that lets a definite article bind an object, a preposition scope a phrase, and a quantifier mean exactly one thing.

Field note

0.3.0 is a focused release: one change, the function-word floor, and it is a coverage milestone rather than a new feature to configure. It fires only what it can prove, the same as always, and there are no benchmark or adoption numbers to report. If `npx typeglish check` surfaces a quantifier conflict on a file that used to pass, that is the floor doing its job, reading a disagreement that was always there. The full changelog lives on [GitHub](https://github.com/Bradenream/TypeGlish). For the object system a definite article builds on, read the [0.2.2 notes](https://typeglish.dev/blog/typeglish-0-2-2); for why a proven contradiction is worth blocking on, read [Your prompt argues with itself](https://typeglish.dev/blog/prompt-contradictions).

## FAQ Questions about 0.3.0

**What is the function-word floor?**

The closed-class words of English, the ones that never change and do the structural work, now paint: articles (`a`, `an`, `the`), prepositions, the quantifiers `every` and `each`, and the bare copula `be`. Earlier releases filled in the open classes (nouns, verbs, adjectives, adverbs); this is the floor beneath them, where the small words that hold a sentence together are read too.

**Does TypeGlish read `every` and `each` now?**

Yes. They paint as the universal quantifier, the same corner of the square of opposition as `all`. So `Every refund is approved` and `No refund is approved` are opposite claims about the same set, and the checker proves they cannot both hold with `logic/quantifier`, a blocking error.

**Do prepositions and adverbs change how a rule is checked?**

They do, because they paint now too. `Every refund is approved automatically` and `No refund is approved without a manager` compile clean side by side: the adverb and the prepositional phrase give the rules different predicates, so there is nothing to report. The same small words that can prove a contradiction also keep the checker from inventing one.

**Does upgrading change how my existing files check?**

It is additive coverage, not a new gate. A prompt whose function words already lined up keeps compiling; where two quantified rules genuinely conflict on one predicate, 0.3.0 now sees it. Run `npx typeglish check` after upgrading, and reconcile any quantifier conflict it surfaces.

∿ washed up Jul 21, 2026 ∿