Home / Docs / Error Codes

GALA Compiler Error Codes

Every semantic error the GALA transpiler emits carries a stable error code of the form GALA-Exxxx. Codes are opaque identifiers — they never change meaning across releases, so tools, tests, CI checks, and documentation can link against them.

If the compiler handed you a code, find it in the table below and jump straight to the page for it.

Anatomy of a GALA error

gala build, gala run, and gala transpile print a framed diagnostic:

error[GALA-E0002]: non-exhaustive match: missing cases: Blue
  --> main.gala:10:5
   |
10 |     case Red()   => "red"
   |     ^^^^ add the missing variant cases, or add a `case _ => ...` defa…
   |
   = hint: add the missing variant cases, or add a `case _ => ...` default to cover them

Diagnostics raised before a source position is known — package resolution and the type-inference engine — print the header and hint with no frame.

Batch analysis and your editor show the same diagnostic in a terse single-line form, because the language server consumes that shape:

Error transpiling main.gala: [SemanticError GALA-E0002] main.gala:10:4 non-exhaustive match: missing cases: Blue (hint: add the missing variant cases, or add a `case _ => ...` default to cover them)

Same code, same message; the column is zero-based in the terse form. See Compiler DX for more on the diagnostic renderer.

All error codes

Every code the compiler can emit now has a page. Codes are never renumbered and never change meaning, so a code you find in an old build log still means the same thing here.

Five codes are retired, and their numbers are not reused. GALA-E0016 rejected a generic struct field named like another generic type of its package, such as struct Box[T any](Mode Mode[T]); such fields are accepted now. GALA-E0070 rejected the read-only ConstPtr that &x of a val used to produce where an interface was expected; taking that address is now GALA-E0076. GALA-E0021, GALA-E0022 and GALA-E0024 belonged to a Hindley-Milner fallback engine that was removed; none of them ever reached a user.

Codes you will not see in practice

Three codes exist in the compiler but no valid source reaches them. Each still has a page, because a stable code is worth documenting even when it is a backstop:

Everyday type mismatches transpile cleanly and surface from the Go compiler afterwards, pointing back at your .gala line. GALA’s inference deliberately leaves type checking to Go.

By category

Pattern matching and sealed types — E0002, E0003, E0004, E0005, E0006, E0015, E0018, E0031, E0039 bare variant name, E0061 a variant used as a type, E0071 an alternative pattern that binds a name, E0072 a variant with more than 10 fields, E0073 a malformed named sub-pattern, E0074 an invalid default case, E0079 a case that does not apply to a sealed view, E0083 a sealed type’s private is<Variant> predicate called from another package. Start with Pattern Matching and Sealed Types.

Collections and Go interop — E0007, E0008, E0043 type name called as a constructor, E0049 a Go call’s Try or Tuple used as its plain value, E0067 a type argument nothing determines, often a Go package whose types were not loaded, E0080 a pointer that may be nil where a non-null Ptr is needed. See Collections and Go Interop.

Declarations — E0011, E0012, E0013, E0014, E0034, E0045 missing required struct field, E0048 method on an alias to a non-local type, E0052 named function inside a body, E0056 malformed tuple destructuring, E0060 val _ = that binds nothing, E0066 a declaration named like a dot-imported name, E0077 a type that holds itself by value, E0078 an invalid interface literal, E0081 a struct field and method of one name, E0082 a call with the wrong number of arguments.

Redeclaration — one name declared twice: E0011 types · E0012 methods · E0027 functions · E0028 type aliases · E0029 interface method specs · E0030 struct fields · E0031 sealed cases. GALA has no overloading, so a second declaration is always a mistake.

Type inference — E0018, E0023, E0033, E0044 unknown method on a known type, E0054 a value that is not a function called as one, E0068 a match or if-expression whose value is used but has no type, E0084 == on values Go cannot compare. See Type Inference.

Opaque types — E0062 an underlying type that is not a scalar · E0063 a direct conversion between two opaque types · E0064 an implicit conversion to or from an opaque type · E0065 an opaque-type pattern with other than one sub-pattern. Start with Opaque Types.

Packages and imports — E0010, E0020, E0025, E0026, E0032, E0041 internal-package visibility, E0046 duplicate import. See Dependency Management.

Go constructs with no GALA surface — E0007 slice literals · E0008 map literals · E0035 builtins like len and panic · E0036 statement keywords like defer and go · E0040 slice/map types in an expression · E0047 the if initializer statement · E0055 a Go keyword used as a name · E0085 a struct tag on a field. Each names its GALA replacement or the fix.

Literals — E0038 invalid string escape · E0051 illegal source character · E0019 empty () used as a value.

Syntax — E0042 unparenthesized lambda parameter (x => e); GALA always writes (x) => e.

Control flow — E0015 bare return in a match whose value is used · E0059 break or continue that cannot reach its loop (outside a loop, in a lambda, or in a match or if-expression whose value is used) · E0069 a return that would leave only a match or if-expression whose value is used.

Immutability and concurrency safety — E0001, E0037, E0053 pointer method on a copy of a lock or builder · E0076 the address of a val, a parameter or a receiver. See Immutability and Concurrency Safety.

Transpiler bugs — E0009, E0017. These mean the transpiler hit a case it does not handle; please file an issue with the source snippet.

Further Reading

• Documentation Hub — language reference, standard library, and guides
• Compiler DX — framed diagnostics, carets, and GALA source positions in stack traces
• Pattern Matching — exhaustive matching, destructuring, and guards
• Sealed Types — closed hierarchies with compile-time exhaustiveness
• Concurrency Safety — the shareability model behind GALA-E0037
• Error Handling — Option, Either, and Try for runtime failures (compile-time codes are on this page)