Scala on Go

Sum types, exhaustive pattern matching, and Option/Try — the type system Go is missing, as a language, not a library.

Scala on Go.

sealed type Shape {
    case Circle(Radius float64)
    case Rectangle(Width float64, Height float64)
}

func area(s Shape) string = s match {
    case Circle(r)       => f"circle area: ${3.14159 * r * r}%.2f"
    case Rectangle(w, h) => f"rect area: ${w * h}%.2f"
}

Try it in your browser — no install.

What is GALA?

GALA is a statically typed, functional-first language that transpiles to Go. You get sealed types, exhaustive pattern matching, immutable collections, and a real monad stack (Option, Either, Try, Future, IO) — and you keep the entire Go ecosystem, including third-party modules, working out of the box.

It's aimed at Go developers who have used Scala, Kotlin, F#, or OCaml and miss the type system.

(GALA stands for Go Alternative LAnguage.)

Why GALA? — Safe, Ergonomic, Compatible

Safe — Go's runtime bugs, caught by the compiler.

• Sealed types with exhaustive matching. The compiler rejects incomplete matches at build time — including nested patterns, guards, and generic extractors. An incomplete match is a build error, not a production panic.
• No nil. Option / Either / Try replace nil checks and naked error returns.
• Immutable by default. val bindings, immutable struct fields, read-only ConstPtr[T]; always concrete types, never a silent any.
• Zero-reflection JSON. Codec[T] is backed by a compiler-generated StructMeta[T] intrinsic — no reflect, no struct tags, and it doubles as a pattern-match extractor.

Ergonomic — the functional code you want to write, minus the ceremony.

• bind / also do-notation. Flat monadic binding over any monad — sequential bind, plus also for independent steps that accumulate errors (Validated) or run concurrently (Future). No nested FlatMap staircases.
• Functional standard library. Option, Either, Try, Future, IO with Map / FlatMap / Recover, plus immutable List, Array, HashMap, HashSet, TreeSet, TreeMap.
• Less syntax. String interpolation (s"…" / f"…"), named arguments and default parameters, type inference everywhere, expression functions, and regex extractors that destructure capture groups directly inside match.

Compatible — every Go library, no bindings, native binaries.

• Full Go third-party module interop. Any Go package works — not just stdlib. Return types are inferred directly from the Go SDK (no declaration files), and (T, error) returns are wrapped into Try[T] automatically.
• Shipped IDE tooling. GoLand/IntelliJ plugin and an LSP server (gala lsp) for VS Code and Neovim — diagnostics, hover, go-to-definition, inlay hints, completion. Batched transpilation and analysis caching keep multi-file rebuilds fast.

Quick Start

1. Install

Download a pre-built binary from Releases, rename it to gala (or gala.exe on Windows), and put it on your PATH.

GALA transpiles to Go, so it needs Go 1.25+ on your PATH to compile programs.

Or build from source:

git clone https://github.com/martianoff/gala.git && cd gala
bazel build //cmd/gala:gala

2. Write main.gala

package main

struct Person(Name string, Age int)

func greet(p Person) string = p match {
    case Person(name, age) if age < 18 => s"Hey, $name!"
    case Person(name, _)               => s"Hello, $name"
    case _                             => "Unknown"
}

func main() {
    Println(greet(Person("Alice", 25)))
}

3. Run

gala mod init example.com/hello
gala run main.gala     # Transpile + compile + run
gala build             # Build project to a binary
gala test              # Run tests

Need help? Ask in GitHub Discussions.

GALA vs Go

Pattern Matching vs Switch

val msg = shape match {
    case Circle(r)      => f"r=$r%.1f"
    case Rectangle(w,h) => f"$w%.0fx$h%.0f"
    case Point()        => "point"
}

var msg string
switch s := shape.(type) {
case Circle:
    msg = fmt.Sprintf("r=%.1f", s.Radius)
case Rectangle:
    msg = fmt.Sprintf("%.0fx%.0f", s.Width, s.Height)
case Point:
    msg = "point"
}

Option Handling vs nil Checks

val name = user.Name
    .Map((n) => strings.ToUpper(n))
    .GetOrElse("ANONYMOUS")

name := "ANONYMOUS"
if user.Name != nil {
    name = strings.ToUpper(*user.Name)
}

Immutable Structs vs Manual Copying

struct Config(Host string, Port int)
val updated = config.Copy(Port = 8080)

type Config struct {
    Host string
    Port int
}
updated := config     // value copy; both stay mutable
updated.Port = 8080

Default Parameters vs Option Structs

func connect(
    host string,
    port int = 8080,
    tls bool = true,
) Connection

connect("localhost", tls = false)

type ConnectOptions struct {
    Host string
    Port int
    TLS  *bool
}

func Connect(opts ConnectOptions) Connection {
    if opts.Port == 0 { opts.Port = 8080 }
    if opts.TLS == nil {
        t := true; opts.TLS = &t
    }
    // ...
}
Connect(ConnectOptions{Host: "localhost", TLS: ptrBool(false)})

Error Handling: Try vs if-err

val result = divide(10, 2)
    .Map((x) => x * 2)
    .FlatMap((x) => divide(x, 3))
    .Recover((e) => 0)

result, err := divide(10, 2)
if err == nil {
    result, err = divide(result*2, 3)
}
if err != nil {
    result = 0
}

Monadic Binding: bind / also

Map/FlatMap chains nest badly the moment a later step needs an earlier value. bind flattens them — every binding is a normal immutable local that stays in scope, and the block short-circuits on the first failure:

func processOrder(id int) Try[Receipt] {
    bind o       = fetchOrder(id)
    bind valid   = validateOrder(o)
    bind payment = chargePayment(valid)
    Success(Receipt(o.Id, payment))   // `o` still in scope; no nested FlatMap
}

also marks a bind as independent of its group, and the block's type decides what that unlocks. Over Validated it accumulates every error instead of stopping at the first:

import . "martianoff/gala/validation"

func makePerson(name string, email string, age int) Validated[string, Person] {
    bind n = vName(name)
    also e = vEmail(email)
    also a = vAge(age)
    Valid(Person(n, e, a))
}
// makePerson("", "", -1).GetErrors().Size() == 3  — all failures at once

Over Future, an also group runs its clauses concurrently. And it's not special-cased to the standard library: any type with a FlatMap method is bindable, resolved structurally at transpile time — no higher-kinded types. See Monadic binding.

More Language Features

Expression functions — single-expression bodies skip braces and return.

func square(x int) int = x * x
func max(a int, b int) int = if (a > b) a else b

Named arguments — any order; compiler reorders to match the signature.

func connect(host string, port int = 8080, tls bool = true) Connection

connect("localhost")                  // port=8080, tls=true
connect("localhost", tls = false)     // port=8080, tls=false
connect(host = "db", port = 5432)     // tls=true

Lambda type inference — parameter types and method type parameters are inferred from context.

val list = ListOf(1, 2, 3)
val doubled = list.Map((x) => x * 2)
val sum = list.FoldLeft(0, (acc, x) => acc + x)

Tuples with destructuring — up to Tuple5, with pattern matching.

val pair = (1, "hello")
val (x, y) = pair

Read-only pointers — ConstPtr[T] prevents accidental mutation through pointers.

val data = 42
val ptr = &data       // ConstPtr[int], not *int
val value = *ptr      // OK: read
// *ptr = 100         // compile error: cannot write through ConstPtr

String interpolation — s"..." with auto-inferred format verbs and f"..." with explicit format specs. No imports needed.

val name = "Alice"
val age = 30
Println(s"$name is $age years old")       // Alice is 30 years old
Println(f"Pi = ${3.14159}%.2f")           // Pi = 3.14
Println(s"${nums.MkString(", ")}")        // 1, 2, 3

Zero-reflection JSON codec — Codec[T] uses the compiler-generated StructMeta[T] intrinsic for fully typed serialization with no reflection, no struct tags, and pattern matching support.

struct Person(FirstName string, LastName string, Age int)

val codec = Codec[Person](SnakeCase())
val jsonStr = codec.Encode(Person("Alice", "Smith", 30)).Get()
// {"first_name":"Alice","last_name":"Smith","age":30}

val decoded = codec.Decode(jsonStr)       // Try[Person]
val name = jsonStr match {
    case codec(p) => p.FirstName          // pattern matching!
    case _        => "unknown"
}

Regex with pattern matching — compile-safe regex with extractors that destructure capture groups directly in match.

val dateRegex = regex.MustCompile("(\\d{4})-(\\d{2})-(\\d{2})")

"2024-01-15" match {
    case dateRegex(Array(year, month, day)) => s"$year/$month/$day"
    case _ => "not a date"
}

Pattern matching with guards.

val status = p match {
    case Person(name, age) if age < 18 => name + " is a minor"
    case Person(name, age) if age > 65 => name + " is a senior"
    case Person(name, _)               => name + " is an adult"
    case _                             => "Unknown"
}

Type-based pattern matching.

val res = x match {
    case s: string => s"string: $s"
    case i: int    => s"int: $i"
    case _         => "unknown"
}

Collect — filter and transform in one pass.

val nums = ArrayOf(1, 2, 3, 4, 5, 6)
val evenDoubled = nums.Collect({ case n if n % 2 == 0 => n * 2 })
// Array(4, 8, 12)

val options = ArrayOf(Some(1), None[int](), Some(2), None[int](), Some(3))
val values = options.Collect({ case Some(v) => v * 10 })
// Array(10, 20, 30)

Standard Library

Functional Types

Serialization, Regex, IO

Collections

All collections support Map, Filter, FoldLeft, ForEach, Exists, Find, Collect, MkString, Sorted, SortWith, SortBy, and more.

TreeMap[K,V] is a Red-Black tree that maintains entries in sorted key order. It provides MinKey, MaxKey, Range(from, to), RangeFrom, RangeTo, and conversion to HashMap, Go maps, or sorted arrays.

Mutable variants of all collection types are available in collection_mutable for performance-sensitive code.

Built with GALA

GALA is dogfooded, not just demoed — its own tooling and these projects are written in the language, which is how the ergonomics get stress-tested. Real applications written in GALA:

All of the above are written in GALA, not just "use GALA somewhere."

Dependency Management

gala mod init github.com/user/project
gala mod add github.com/example/[email protected]
gala mod add github.com/google/[email protected] --go
gala mod tidy

Third-party Go modules are first-class. GALA reads the Go SDK to infer return types, and multi-return (T, error) patterns are auto-wrapped into Try[T] at the call site.

IDE Support

GALA ships with a GoLand/IntelliJ plugin and an LSP server (gala lsp) for editor-agnostic support.

GoLand / IntelliJ IDEA

1. Install GALA CLI: download from releases and add to PATH.
2. Install plugin: GoLand > Settings > Plugins > Install from Disk > select gala-intellij-plugin.zip from releases.
3. Restart GoLand — the LSP server starts automatically when a .gala file is opened.

The plugin works locally (ANTLR parser, semantic highlighting, structure view, 12 live templates). The LSP server (gala lsp) adds real-time diagnostics including match-exhaustiveness, hover types, cross-file go-to-definition, type-aware completion, and inlay hints — for VS Code and Neovim too. Full feature list: IDE Support.

VS Code

Add to .vscode/settings.json:

{
  "lsp.servers": {
    "gala": {
      "command": "gala",
      "args": ["lsp"],
      "filetypes": ["gala"]
    }
  }
}

Neovim

require('lspconfig.configs').gala = {
  default_config = {
    cmd = { 'gala', 'lsp' },
    filetypes = { 'gala' },
    root_dir = require('lspconfig.util').root_pattern('gala.mod', '.git'),
  },
}
require('lspconfig').gala.setup({})

Installation

Pre-built Binaries

Download from Releases:

After downloading, rename the binary to gala (or gala.exe on Windows) and add it to your PATH.

Prerequisite: GALA needs Go 1.25+ on your PATH to compile programs. Install Go before running gala build or gala run.

Build from Source

git clone https://github.com/martianoff/gala.git
cd gala
bazel build //cmd/gala:gala

Using Bazel

load("@rules_gala//gala:defs.bzl", "gala_binary", "gala_library")

gala_binary(
    name = "myapp",
    src = "main.gala",
)

Documentation

• Language Specification — complete language reference
• Why GALA? — feature deep-dive and honest trade-offs
• Examples — code examples for all features
• Type Inference — how type inference works
• JSON Codec — zero-reflection JSON serialization
• Regex — pattern matching with regex extractors
• IO Effect — lazy, composable side effects
• Go Interop — seamless Go library integration
• Concurrent — Future, Promise, and ExecutionContext
• Stream — lazy, potentially infinite sequences
• Immutable Collections — List, Array, HashMap, HashSet, TreeSet, TreeMap
• Mutable Collections — mutable variants for performance
• Strings — free functions over string, Str wrapper, and StringBuilder
• Time Utils — Duration and Instant types
• Dependency Management — module system

Contributing

Contributions are welcome. Please ensure:

1. bazel build //... passes
2. bazel test //... passes
3. New features include examples in examples/
4. Documentation is updated for grammar/feature changes

See CONTRIBUTING.MD for details.

License

Apache License 2.0. See LICENSE for details.