127 codes, every one the compiler can emit. beck explain error B0341 prints one at the terminal.
| Code | | Meaning |
|---|
B0100 | error | unrecognised character — The character is not a Beck token. Lexing continues past it so that one stray character does not hide every other problem in the file. |
B0101 | error | inconsistent indentation — This line's indentation matches no enclosing block. Indentation is significant, and §2.6 fixes it as spaces only, four per level — a tab is a lint rather than a width question. Blank and comment-only lines have no indentation at all, so a comment at column zero does not close a block. |
B0102 | error | an invisible control character in the source — A bidirectional formatting character (UTS #39 §4.1; CVE-2021-42574) or a zero-width no-break space away from the start of the file. These change how the text after them is *displayed* without changing what it means, so a reviewer and the compiler can read the same file differently. Write `\u{...}` if a string genuinely needs one. |
B0103 | error | an identifier outside the ASCII profile — Beck's identifiers are `[A-Za-z_][A-Za-z0-9_]*`, which is UTS #39's ASCII-Only restriction level. Confusable and mixed-script identifiers are therefore not something the compiler checks for; they are something a program cannot contain. |
B0110 | error | expected a single form — `beck ast` and the macro-debugging paths read exactly one S-expression. A file with a second form at top level is a module, and is read with the module reader instead. |
B0111 | error | unbalanced closing delimiter — A `)`, `]` or `}` with no matching opening delimiter. |
B0112 | error | unclosed list — A list opened here and the file ended before it closed. The span points at the opening delimiter, which is the one worth looking at. |
B0113 | error | mismatched closing delimiter — The closing delimiter is not the one this form opened with — `(a]`. Both spans are reported: where it opened, and where it was closed wrongly. |
B0114 | error | empty application — `()` has no meaning: an application's head is its first element, and there is none. Write `unit` for the unit value. |
B0115 | error | unclosed string — A string literal opened and the line or file ended before the closing quote. Beck string literals do not span lines. |
B0116 | error | unreadable character — The S-expression reader cannot begin an atom with this character. |
B0120 | error | unexpected token — The Python-surface parser expected something else here; the message names what. One error per item: the parser recovers to the next top-level item, so a bad line does not make the rest of the file unparseable. |
B0121 | error | nesting is too deep to read — The source nests deeper than the front end follows — `beck_diag::depth::MAX_NESTING` levels of brackets, indentation or S-expression lists. The bound is a fixed count rather than a reading of the stack, so the same file is accepted or refused identically in every build; without it, deep enough input aborted the process with no span at all. |
B0122 | error | an expression chains more operators than the reader will follow — A left-associative chain — `1 + 1 + 1 + …` — is flat in source and builds a left-leaning tree of the same depth, one level per operator. The Pratt loop that reads it does not recurse, so none of the parser's recursion counters sees the depth, and a long enough chain reached the end of the host stack in whatever walked the tree afterwards. The bound is `beck_diag::depth::MAX_BLOCK` — the same ceiling a block of sequential bindings takes, because it is the same axis: a flat run of things that costs one tree level each. |
| Code | | Meaning |
|---|
B0300 | error | not a tier — `@on(…)` takes `client`, `server`, `data` or `any`. |
B0301 | warning | unsupported decorator — The compiler understands `@on(client|server|data|any)` and `@signal`. A warning rather than an error, so an unknown decorator does not stop a build — but it does nothing. |
B0302 | error | type is declared twice — Two declarations in this module share a type name. |
B0303 | error | a top-level parameter needs a type annotation — Inference is intra-module and boundaries are declared (§3.6): a top-level definition's parameters are part of its published signature, so they are written rather than guessed. |
B0304 | error | needs a return type — Same reason as B0303: a top-level definition's result type is part of its contract. |
B0305 | error | neither an effect nor a row — A `uses` clause names effect atoms and row aliases, and this is neither. `beck doc reference` lists the atom set; a `row Name = …` declaration in the module is what makes a name for a bundle of them. |
B0306 | error | is not a rendering mode — `@render` takes `server` (Mode A: the server renders and the wire carries DOM patches) or `client` (Mode B: the browser renders and the wire carries the state). |
B0307 | error | unsupported top-level item — This form is not something a module may contain at top level. |
B0308 | error | expected a type — A type position holds something that is not a type expression. |
B0310 | error | cannot find type — No declaration, import or builtin of that name is in scope. |
B0311 | error | wrong number of type arguments — A mention of a type carries one argument per declared parameter — `union Tree[T]` is written `Tree[Int]`, never bare `Tree`. |
B0312 | error | a type alias defined in terms of itself, or a name the language reserves — An alias is transparent, so a self-referential one describes no type — a `union` may be recursive, an alias may not. The same code covers a definition named after a reserved form such as `record`, which would compile and never be reachable. |
B0313 | error | a type parameter takes no type arguments — A type parameter of the definition or declaration being read names an unknown type, so it has no structure to apply arguments to: `T[Int]` says nothing, whatever `T` turns out to be at the call site. |
B0314 | error | a type parameter shadows an existing type — A type parameter is a name the definition or declaration invents, and one that shadowed an existing type would make its fields or its signature read as though they mentioned that type. |
B0315 | error | a type parameter is repeated — The same name appears twice in one type-parameter list, where the second would silently shadow the first. |
B0316 | error | a declaration cannot bound its type parameter — A bound says what a body may call, and a `model`, a `union`, a `newtype` and a `type` have no body. The definitions that take the type apart are where the bound belongs. |
B0317 | error | a declaration shadows a builtin type — `Int`, `Str`, `Bool`, `Float`, `Unit`, `Html`, `Attr`, `list`, `Map`, `Stream`, `Signal`, `Envelope`, `secret` and `internal` are the language's own type names, and a `model`, `union`, `newtype` or `type` may not take one. B0314 has refused the same shadowing for a type *parameter* since docs/36; a declaration was the production it did not cover, so the name meant the builtin in one signature and the declaration in the next (docs/87 §87.4). |
B0320 | error | type mismatch — Unification failed; the message names what was being unified — an argument, a field, a result, or the two branches of an `if`. The branches of an `if` are reported as two alternatives rather than as actual-and-expected: typing one as the other's expectation is what refused SICP exercise 1.43 (docs/27 §27.3). |
B0330 | warning | statements after `return` are unreachable — A `return` ends its block; anything after it never runs. |
B0331 | error | loops are not available in Phase 1 — Everything is an expression and `var` is not yet mutable, so a loop has nothing to accumulate into. Use `map_list`, `filter_list` or `fold`. |
B0332 | error | a `quote` survived macro expansion — A template reached the checker, which means it was never instantiated. Quoted forms are data for a macro, not code. |
B0333 | error | a keyword argument outside a call — `name=value` is call syntax and has no meaning as an expression on its own. |
B0334 | error | unsupported expression — This form has no meaning in expression position. |
B0335 | error | has no body — A bodyless `def` is a declaration, which is what a `.becki` interface file is made of; an ordinary module has to define what it declares. |
B0340 | error | cannot find name in this scope — No local, parameter, top-level definition, import or prelude name matches — after hygiene, which means a name a macro introduced is not visible to code the macro did not write. |
B0341 | error | match is not exhaustive — The missing variants are listed. This is deliberate and load-bearing: adding a variant must break every fold that consumes it, which is what makes a missed migration a compile error rather than a 3 a.m. page. |
B0342 | error | unsupported pattern — A `case` arm's pattern is a variant applied to field bindings, or `_`. This form is neither. |
B0343 | error | not a constructor — The head of a pattern must be a variant of the union being matched. |
B0344 | error | cannot tell which field this binds or sets — A pattern or record update names a field the compiler cannot resolve to the type in hand. |
B0345 | error | the tail of a list pattern is a name, not a pattern — The tail of a list pattern binds the rest of the list, so it takes a name or `_`. `[a, *[b, c]]` is `[a, b, c]` written twice over. |
B0346 | error | cannot tell which model this record builds — A record literal's type comes from what is expected of it, and nothing here says which model it is. |
B0347 | error | expected a field or method name — The right-hand side of a `.` must be a name. |
B0348 | error | `with` takes named fields — Functional record update is written `t.with(done=…)`. |
B0349 | error | no such field on this type — The field named in a `with` is not declared on the model being updated. |
B0350 | error | no field or function for this type — A `.` reached neither a field of the receiver nor a function that could take it. |
B0351 | error | wrong number of arguments — A call passes a different number of arguments than the function or constructor takes. |
B0352 | error | not callable — The callee's type is not a function type. |
B0353 | error | no such variant — The union being constructed or matched has no variant of that name. The type is named in the message. |
B0354 | error | cannot construct this type — The name is a type, but not one with a constructor — an alias or a builtin. |
B0355 | error | this case can never match — Every value the arm matches is already matched by an arm above it, so it cannot run. A warning rather than an error: `case _` written after every variant of a union is a habit rather than a mistake. |
B0356 | error | the alternatives of an or-pattern bind different names — Every alternative of `a | b` has to bind the same names at the same types, because the body reads them without knowing which one matched. |
B0357 | error | `|` and `@` are only meaningful in a `case` pattern — Beck has no bitwise operators. `|` separates the alternatives of an or-pattern, `@` names the value a pattern takes apart, and neither means anything anywhere else. |
B0358 | error | the left of `@` is a name — `whole @ Circle(r)` binds `whole` to the value the pattern matched. What stands to the left of `@` is the name being bound. |
B0359 | error | an identity declaration this compiler cannot derive a deployment from — `identity = external(issuer="https://login.acme.com")` and `identity = managed()` are the two forms, and a program declares at most one. An external issuer is an `https` URL — the key set's only integrity protection is the transport it arrives over — and its host has to be one an egress rule could name, because §6.5 derives the cluster's rule from it. `managed()` takes no arguments: it provisions a provider into the object graph, and the issuer is a Service the deployment names rather than the program. |
B0360 | error | cannot be called inside a fold — A fold must be replay-pure, and this would make replay non-deterministic. Time is data on the envelope (`env.at`) and entity ids are minted at the edge: mint the id in the client's command and read it from the event. |
B0370 | error | performs more than its signature declares — The undeclared atoms are listed. A `uses` clause is the published bound, and widening it is a breaking API change — so the compiler will not widen it for you. |
B0380 | error | a trait cannot be declared here — The name already belongs to a type, the trait is declared twice, or the file is a `.becki` — a trait does not cross a module boundary, so an interface may not hold one. |
B0381 | error | a trait declaration is wrong — A trait holds `def` signatures with no bodies, each mentioning `Self` in a parameter so that a call has something to dispatch on. A method name belongs to one trait only. |
B0382 | error | an impl does not match its trait — An impl writes bodies and parameter *names*; the types, the return type and the effect row are the trait's. Every method must be implemented, exactly once, and no others. |
B0383 | error | cannot find the trait or the type this impl names — Both halves of `impl Trait for Type` have to resolve before the impl can be registered. |
B0384 | error | conflicting implementations — Coherence: one impl per trait per type constructor, and no blanket impl over a type parameter — so what a call means never depends on which impls happen to be in scope. |
B0385 | error | orphan impl — An impl belongs with the trait or with the type. Implementing somebody else's trait for somebody else's type is what lets two modules supply one and disagree. |
B0386 | error | no implementation can be chosen here — An implementation comes from a concrete type or from a bound on a type parameter — write `[T: Trait]` to say the parameter has one. A trait method and a bounded definition are both called rather than passed: the implementation is supplied at the call site, so a reference that is never called has nowhere to receive it. |
B0387 | error | the type does not implement the trait — There is no `impl Trait for Type` in scope for the receiver's type. |
B0389 | error | a block has more statements than the checker will follow — A block is a chain of `let`s however flat it looks in source, so the checker recurses once per statement and a long enough body reaches the end of the host stack. The bound is `beck_diag::depth::MAX_BLOCK` — much larger than the nesting ceiling, because 256 levels of nesting is pathological and 256 sequential bindings is merely a long function. It is a fixed count rather than a reading of the stack, so the same file is accepted or refused identically in a debug and a release build; without it, a long enough body aborted the process with no span at all. |
B0390 | error | the expression nests too deep to check — The checker walks an expression and a type as deeply as they nest, and stops at `beck_diag::depth::MAX_NESTING` levels — the same count the reader stops at, because the checker can be handed a tree a macro produced rather than one anybody typed. Everything downstream walks the `Core` this pass built, so it is bounded by the same number. |
B0391 | error | a raised value must have a declared type — `raise` performs `raises(T)`, and the atom names `T` so that a handler can say what it catches. A builtin will not do: `raises(Int)` would make every integer failure in a program the same failure, and a handler could not tell them apart. |
B0392 | error | nothing here can fail, and nothing says what this would catch — A `try:` reifies one failure into a `Result`, and it takes the error type from the enclosing signature's `Result[T, E]` where there is one and from the block's own row where there is not. Neither said anything here. Either the call you meant to make is not there, or the `try:` is left over from a signature that has stopped failing — which is the good case, and the diagnostic is how you find out. |
B0393 | error | the block can fail in more than one way, and nothing says which to catch — A `Result[T, E]` has one error type, and a `try:` catches one — the rest keep travelling, which is what makes a handler composable. Here nothing named which: give the enclosing definition a `Result[T, E]` return type, and the handler catches that `E`. |
B0394 | error | the row is declared twice — Two `row Name = …` declarations with the same name. A row alias is a name for a bundle of effect atoms, and a second one would make every `uses` clause mentioning it ambiguous. |
B0395 | error | the host of an outbound call has to be written at the call site — `http_fetch` performs `net.out(host)`, and §6.5 derives the cluster's egress policy from that atom and nothing else. A host computed at run time is an outbound call the deployment cannot be told about, so the argument is read where it is written. Compute the path, the port, the headers and the body; or take a closure, so the caller names its own host and the row carries the atom out. |
B0396 | error | that is not a host an outbound call can name — The host becomes a NetworkPolicy peer and a `uses net.out(…)` clause, both of which are written as bare DNS labels — so a scheme, a port or a path in it is a name neither could carry. `origin` is refused for a different reason: it is the one outbound atom a client tier discharges, and a client reaches its own server over the command channel. |
B0397 | error | a parallel scope has fewer than two children — A `parallel:` scope runs its bindings as children. With one there is nothing to run it alongside, and with none there is nothing to run — either way the form is claiming a concurrency it does not have, and an ordinary block says the same thing without the claim. The tail is everything after the last binding, so a scope written with its work in the tail has no children either. |
B0398 | error | a child of a parallel scope names another child — The children of a `parallel:` scope run together, so none of them can see another's result — a child that could would have to run second, and then it is not a child but a next line. Move the reader into the scope's tail, which runs after the join with every child's result in scope, or out into a second scope below this one. |
B0399 | error | a child of a parallel scope performs an effect another child could observe — The claim a `parallel:` scope makes is that its answer does not depend on the order its children ran in, and an effect on state the program holds — the log, the document, the merge point, a file, an external store — breaks it: two children appending to the log in the other order is a different log. `net.out(host)` is not on that list and is the case the form exists for. Do the shared-state part in the tail, which runs once, after the join. |
| Code | | Meaning |
|---|
B0500 | error | this program has no merge point — A Beck application is a fold over an event stream, and the stream starts at `merge_clients()`. Not an error for a library: this code, with B0501 and B0505, is what says a module is a domain module rather than an application. |
B0501 | error | this program has no durable state — `durable(fold(f, init, s))` is what makes the log a database. |
B0502 | error | `durable` must wrap a `fold` — Only a fold has an accumulator to persist. |
B0504 | error | events must come from `decide` — The fold has no chokepoint upstream of it. `decide` is the sole consumer of ingress and the one place a command becomes an event — §3.5's "authority is one chokepoint". |
B0505 | error | no signal is placed on the client — `page` is the tier crossing: a `Signal[Html]` the browser subscribes to. |
B0506 | error | not a signal — A signal's inputs are other signals. A function is applied *through* a construct — `signal_map(s, f)` — rather than named as an input. |
B0507 | error | not a signal construct — §3.7's signal vocabulary is `merge_clients`, `filter_map`, `fold`, `durable`, `signal_map`, `map2`, `per_session` and `decide`. |
B0508 | error | unsupported signal expression — A signal is a node in the dataflow, not a computation. The computation goes in a `def` and the signal names it: `summary: Signal[Summary] = signal_map(counts, summarise)`. |
B0509 | error | a signal defined in terms of itself — The cycle is printed. A cycle through a `fold` is sound — an accumulator is a value, so the recursion has a bottom, which is why `events → todos → events` is legal. One with no fold in it has no first value to compute from. |
B0510 | error | two signals are the page, and there is no router yet — The slicer will slice both; the runtime serves one document per connection, and choosing between them is routing — a Phase 3 client bullet that is not built. |
B0511 | error | a program has one authority chokepoint — A second `decide`. §3.5 rests on validation being one place: two of them are two answers to "may this actor do this", and the log would record whichever ran. |
B0512 | error | the chokepoint does not read a durable fold — `decide` threads the accumulator through validation, so what it reads has to be one — that is what makes first-writer-wins and ownership decidable (§3.7). |
B0513 | error | a fold that is not durable — Its accumulator has nowhere to live across a restart. The log is what survives, and `durable` is what says an accumulator is folded from it. |
B0514 | error | renders differently for each session, so it cannot render on the client — The page reads the session as well as the state, so it filters, scopes or hides by identity. `@render(client)` sends the browser the state rather than the page, which would hand every actor what the filter was removing (docs/94 §94.2). |