Signals Glossary

Canonical terminology for this course. All lessons and reference documents use these definitions. Updated as new concepts are introduced.

Angular Signals (Core)

Signal:
A reactive value wrapper that notifies consumers when it changes. Read by calling it as a function. Always has a current value. Always synchronous.
Avoid: observable, stream, subject

Writable signal:
A signal created with signal() that can be mutated via .set() or .update(). Type: WritableSignal<T>.
Avoid: mutable signal

Computed signal:
A read-only signal whose value is derived from other signals via a computation function. Created with computed(). Lazily evaluated and memoized.
Avoid: derived signal (technically accurate but less specific)

Reactive context:
A runtime state where Angular tracks signal reads to establish dependencies. Exists inside computed(), effect(), linkedSignal(), resource() params/loader, and template rendering.
Avoid: subscription context, tracking scope

Consumer:
Code that reads a signal within a reactive context. The consumer is re-evaluated when its dependencies change.
Avoid: subscriber, listener

Producer:
A signal being read by a consumer. The thing that produces the value.
Avoid: source (too generic)

Effect:
A side-effect function that runs whenever its signal dependencies change. Created with effect(). Not for derivation - for non-reactive API interactions (logging, localStorage, DOM manipulation).
Avoid: watcher, subscription

linkedSignal:
A writable signal whose value is initialised and reset by a reactive computation, but can also be manually overridden with .set()/.update(). A writable computed, essentially.
Avoid: writable computed (not an official name)

Resource:
A reactive wrapper for async data. Exposes the loading state and resolved value as signals. Created with resource() or httpResource().
Avoid: async signal

Equality function:
A function passed to signal() or computed() via { equal: fn } that determines whether a new value is considered different from the old. Default: Object.is().
Avoid: comparator

untracked:
A utility that reads a signal without registering a dependency. Used inside reactive contexts when you want to access a value without creating a reactive link.
Avoid: peek (used in some other frameworks but not Angular)

NgRx SignalStore

SignalStore:
A composable, signal-based state management container created with signalStore(). Replaces the classic NgRx Store for new code. Injectable as a service.
Avoid: store (too generic - qualify as SignalStore or classic store)

signalState:
A lightweight alternative to SignalStore for simple state slices. Created with signalState(). No store composition - just state + signals.
Avoid: mini-store

patchState:
The primary function for updating SignalStore state. Accepts partial state objects or updater functions. Immutable update semantics.
Avoid: setState (that's a different concept in other frameworks)

Store feature:
A composable unit of store functionality added via with* functions (withState, withComputed, withMethods, withEntities, etc.). Features compose left-to-right in signalStore().
Avoid: plugin, middleware

rxMethod:
A reactive method that accepts a signal, observable, or static value and processes it through RxJS operators. The bridge between SignalStore and async/stream-based logic.
Avoid: effect (that's Angular's effect()), side-effect handler

Entity collection:
A normalised collection of entities managed by withEntities(). Provides ids, entities, and entityMap signals plus updater functions.
Avoid: entity state (the old @ngrx/entity term - still valid but context-specific)

Signal Forms

Signal Form:
A form created with form() that manages state via Angular signals. The model is a plain signal; the form provides a FieldTree for binding and validation.
Avoid: reactive form (that's the old FormGroup/FormControl system)

FieldTree:
The object returned by form(). Mirrors the shape of the model. Each node is callable to get state signals (value, valid, touched, dirty, errors, etc.).
Avoid: form group (that's the reactive forms concept)

formField:
The directive ([formField]) that binds an HTML input to a FieldTree node. Creates two-way binding between the DOM and the signal model.
Avoid: formControlName, formControl (reactive forms directives)

Schema function:
The second argument to form() that configures validation rules for fields. Receives a schema path object for addressing fields.
Avoid: validator config