GALA

Sum Types and Pattern Matching for Go — Without Leaving the Ecosystem

GALA (Go Alternative LAnguage) is a modern programming language that transpiles to Go. The 2024 Go Developer Survey confirmed that sum types and enums are the #1 most-requested missing feature in Go. As of Go 1.25, they still don’t exist. GALA delivers them today — along with exhaustive pattern matching, Option[T]/Either[A,B]/Try[T] monads, and immutable collections — all compiling to a single native binary through the standard Go toolchain.

Unlike libraries like samber/lo or IBM/fp-go that bolt functional patterns onto Go’s syntax, GALA adds these features at the language level with clean, concise syntax. Every Go library works out of the box. Your existing Go modules, third-party packages, and tooling remain fully compatible. GALA extends Go with the type-safety features it deliberately omits, while preserving Go’s performance, deployment simplicity, and ecosystem.

GALA’s transpiler performs type inference, exhaustive match checking, and immutability enforcement at compile time. The generated Go code is clean and readable — you can always inspect what GALA produces. There is no runtime overhead beyond what the equivalent hand-written Go would have.

Features

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

val msg = shape match {
    case Circle(r)       => f"r=$r%.1f"
    case Rectangle(w, h) => f"${w * h}%.2f"
}

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

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

val nums = ArrayOf(1, 2, 3, 4, 5)
val evens = nums.Filter((x) => x % 2 == 0)
val sum = nums.FoldLeft(0, (acc, x) => acc + x)

import "strings"

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

GALA vs Go — A Quick Look

Pattern matching is one of the most visible differences between GALA and Go. Where Go requires a manual type switch with field accessors, GALA destructures values directly and ensures every case is handled at compile time.

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 shape._variant {
case Shape_Circle:
    msg = fmt.Sprintf("r=%.1f",
        shape.Radius.Get())
case Shape_Rectangle:
    msg = fmt.Sprintf("%fx%f",
        shape.Width.Get(),
        shape.Height.Get())
case Shape_Point:
    msg = "point"
}

GALA’s version is shorter, handles destructuring automatically, and produces a compile-time error if you forget a case. See the full GALA vs Go comparison for more examples including Option handling, immutable structs, and error handling.

Get Started in 3 Steps

1. Install

Download a pre-built binary from Releases for Linux, macOS, or Windows. Or build from source:

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

2. Write

Create 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"
}

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

3. Run

gala run main.gala

Or with Bazel for larger projects:

bazel run //myapp:myapp

See the full Getting Started guide for project setup, Bazel integration, and dependency management.

Standard Library

GALA ships with a standard library of type-safe data structures and monads, all built on sealed types and functional programming patterns.

Types

Collections

All collections support Map, Filter, FoldLeft, ForEach, Exists, Find, Collect, MkString, Sorted, and more. Mutable variants are available in collection_mutable for performance-sensitive code. See the collections documentation for details.

Documentation

Showcase Projects