In type theory, linguistic expressions are assigned types (e.g., t for truth values, e for individuals, ⟨e,t⟩ for properties). Meaning is computed by applying typed functions systematically, ensuring only well-typed combinations are possible.
If you have studied compositional semantics, you already know the core principle: the meaning of a complex expression is built from the meanings of its parts plus the rules for combining them. Semantic type theory is the formal scaffolding that makes this precise. Every expression in the language is assigned a type, and types determine what can combine with what — just as type systems in programming languages prevent you from multiplying a string by a boolean.
The basic types are just two: e (entities — individuals in the domain of discourse, like people, places, or objects) and t (truth values — true or false). Everything else is a function type built from these. A one-place predicate like "runs" has type ⟨e,t⟩: give it an entity and you get a truth value. The sentence "Maria runs" composes by applying the ⟨e,t⟩ function to the entity Maria (type e), returning a truth value — which is exactly what a sentence denotes.
Quantifier phrases reveal why higher-order types are necessary. "Every student" does not denote an individual; it denotes a relation between sets. Formally, it has type ⟨⟨e,t⟩,t⟩ — a function that takes a property (type ⟨e,t⟩) and returns a truth value. "Every student runs" is parsed as applying the ⟨⟨e,t⟩,t⟩ quantifier to the ⟨e,t⟩ predicate. The type-matching rule licenses this combination and predicts the output type (t), confirming that the result is a truth-evaluable sentence. This is the key insight you would miss if you treated quantifiers as ordinary noun phrases.
Composition proceeds by function application: wherever you have a function of type ⟨σ,τ⟩ adjacent to an argument of type σ, apply the function to the argument and obtain something of type τ. The type system is what lets you track this mechanically across an arbitrarily complex sentence. If a combination fails type-checking — say, you try to apply a truth value to a predicate — that is a formal signal that the expressions do not compose in the intended way, which may indicate a scope ambiguity or a syntactic mismatch.
Building from compositional semantics, the type-theoretic framework extends naturally to tense, modality, and quantifier scope — topics you will encounter next. In each case, the strategy is the same: assign types carefully to new expression classes, specify the composition rules, and let the machinery derive sentence meanings bottom-up from lexical entries. The power of the approach lies in its generativity: a small set of types and rules can produce meanings for an unlimited range of sentences.