home / skills / madappgang / claude-code / dingo
This skill helps you work with the Dingo meta-language for Go by transpiling to idiomatic Go, enabling Option/Result types and concise error handling.
npx playbooks add skill madappgang/claude-code --skill dingoReview the files below or copy the command above to add this skill to your agents.
---
name: dingo
version: 1.0.0
description: Use when working with Dingo meta-language for Go, implementing optionals/results, using generics shortcuts, or transpiling .dingo files to .go while maintaining Go compatibility.
keywords:
- Dingo
- Go
- meta-language
- transpiler
- optionals
- results
- generics
- Go tooling
plugin: dev
updated: 2026-01-20
---
# Dingo Language Patterns
## Overview
Dingo is a meta-language for Go that transpiles `.dingo` files to `.go` files, providing modern language features while maintaining 100% Go ecosystem compatibility.
**Repository:** https://github.com/MadAppGang/dingo
**When to use Dingo:**
- You want concise error handling with the `?` operator
- You need sum types (enums) and pattern matching
- You prefer functional patterns with lambdas
- You want `Option[T]` and `Result[T,E]` types
- You need safe navigation (`?.`) and null coalescing (`??`)
**Key Philosophy:**
Dingo makes common Go patterns more concise and safer without departing from Go idioms. The transpiled Go code is clean and idiomatic.
## Project Structure
```
project/
├── cmd/
│ └── api/
│ └── main.dingo # Entry point
├── internal/
│ ├── handlers/ # HTTP handlers (.dingo files)
│ ├── services/ # Business logic
│ ├── repositories/ # Data access
│ └── models/ # Domain models
├── pkg/ # Public packages
├── configs/ # Configuration
├── go.mod # Go module file
├── go.sum # Go dependencies
└── .dingo/ # Generated .go files (gitignored)
```
## Build & Development Workflow
### Commands
```bash
dingo build # Transpile to Go and build binary
dingo run main.dingo # Transpile and run directly
dingo go # Generate .go files only (for CI/CD)
dingo fmt # Format Dingo files
```
### Development Cycle
1. **Write**: Edit `.dingo` files
2. **Transpile**: Run `dingo go` to generate `.go` files in `.dingo/`
3. **Type Check**: gopls works on generated `.go` files for IDE support
4. **Build**: `dingo build` or `go build` on generated files
### IDE Integration
gopls (Go language server) works on the generated `.go` files:
```bash
# After dingo go, gopls sees:
.dingo/
├── cmd/api/main.go
├── internal/handlers/user.go
└── internal/services/user.go
```
Configure your editor to watch `.dingo/` for Go analysis.
### CI/CD Pipeline
```yaml
# GitHub Actions example
steps:
- name: Install Dingo
run: go install github.com/MadAppGang/dingo/cmd/dingo@latest
- name: Generate Go files
run: dingo go
- name: Build
run: go build -o app ./.dingo/cmd/api
- name: Test
run: go test ./.dingo/...
```
### Transpilation Errors
Dingo reports errors with source locations in `.dingo` files:
```
error: mismatched types in match expression
--> internal/handlers/user.dingo:42:5
|
42 | match status {
| ^^^^^ expected Status, found string
```
Fix errors in `.dingo` source, then re-run `dingo go`.
## Built-in Types
**Important:** `Option[T]`, `Result[T,E]`, `Some()`, `None()`, `Ok()`, `Err()` are **built-in Dingo syntax**, not Go imports. The transpiler generates all necessary type definitions.
```dingo
// These are built-in - no import needed
func findUser(id string) Option[User] {
// ...
return Some(user) // Built-in function
return None() // Built-in function
}
func divide(a, b int) Result[int, string] {
if b == 0 {
return Err("division by zero") // Built-in
}
return Ok(a / b) // Built-in
}
```
Only import `dgo` if writing **pure Go code** that interoperates with Dingo-generated types.
## Error Propagation (? Operator)
The `?` operator provides concise error handling, similar to Rust.
### Basic Propagation
```dingo
// Before: verbose Go pattern
func loadUser(id string) (*User, error) {
user, err := db.FindByID(id)
if err != nil {
return nil, err
}
return user, nil
}
// After: concise Dingo
func loadUser(id string) (*User, error) {
user := db.FindByID(id)?
return user, nil
}
```
### Error Context
Add context to propagated errors:
```dingo
func processOrder(id string) (*Order, error) {
// Wrap error with message
order := db.FindOrder(id) ? "failed to find order"
// Validates and wraps
validated := validateOrder(order) ? "order validation failed"
// Process with full context
result := processPayment(validated) ? "payment processing failed"
return result, nil
}
```
### Error Transform
Transform errors with closures:
```dingo
func createUser(input CreateUserInput) (*User, error) {
// Rust-style closure
user := db.Create(input) ? |e| fmt.Errorf("db error: %w", e)
// TypeScript-style arrow
profile := createProfile(user.ID) ? e => AppError.Wrap(e, "profile creation")
return user, nil
}
```
### Error Propagation in Lambdas
When using `?` inside lambda bodies, the error propagates to the enclosing function:
```dingo
func processAllUsers(ids []string) (*Summary, error) {
// Error in lambda propagates to processAllUsers
results := map(ids, |id| {
user := db.FindUser(id)? // Propagates to processAllUsers, not the lambda
return transform(user)
})
return summarize(results), nil
}
// For lambdas that should handle errors internally:
func processAllUsersSafe(ids []string) []Result[User, error] {
return map(ids, |id| {
user, err := db.FindUser(id)
if err != nil {
return Err(err)
}
return Ok(user)
})
}
```
**Important:** The `?` operator inside lambdas propagating to the enclosing function is **intentional Dingo design**. When the transpiler sees `?` inside a lambda body, it generates special code that propagates errors to the enclosing function rather than the lambda itself. This is the most common use case for error handling in functional chains. If you need the lambda to handle errors internally (e.g., to return `Result` types), use explicit Go-style error checking as shown in `processAllUsersSafe` above.
## Option[T] Type
Use `Option[T]` for optional values instead of nullable pointers.
### Basic Usage
```dingo
func findUser(id string) Option[User] {
user, err := db.FindByID(id)
if err != nil {
return None()
}
return Some(user)
}
// Usage
user := findUser("123")
if user.IsSome() {
fmt.Println(user.Unwrap().Name)
}
// With default
name := findUser("123").Map(|u| u.Name).UnwrapOr("Anonymous")
```
### Option Methods
```dingo
opt := Some("hello")
opt.IsSome() // true
opt.IsNone() // false
opt.Unwrap() // "hello" (panics if None)
opt.UnwrapOr("default") // "hello"
opt.UnwrapOrElse(|| "computed") // "hello"
opt.Map(|s| len(s)) // Some(5)
opt.FlatMap(|s| Some(s + "!")) // Some("hello!")
```
## Result[T, E] Type
Use `Result[T, E]` for explicit error modeling.
**Type Parameter Inference:** Type parameters can be inferred when the context makes them clear (e.g., function return type), but explicit parameters are needed in standalone expressions like `Ok[int, string](42)`.
### Basic Usage
```dingo
func divide(a, b int) Result[int, string] {
if b == 0 {
return Err("division by zero")
}
return Ok(a / b)
}
// Usage
result := divide(10, 2)
if result.IsOk() {
fmt.Println(result.Unwrap()) // 5
}
// With default
value := divide(10, 0).UnwrapOr(0) // 0
```
### Result Methods
```dingo
ok := Ok[int, string](42)
err := Err[int, string]("failed")
ok.IsOk() // true
ok.IsErr() // false
ok.Unwrap() // 42
ok.UnwrapErr() // panics
ok.UnwrapOr(0) // 42
ok.Map(|n| n * 2) // Ok(84)
err.UnwrapOr(0) // 0
err.UnwrapErr() // "failed"
```
## Sum Types (Enums)
Define algebraic data types with named variants.
### Basic Enum
```dingo
enum Status {
Pending
Active
Suspended { reason: string }
Deleted { deletedAt: time.Time, deletedBy: string }
}
func (s Status) String() string {
match s {
Pending => "pending",
Active => "active",
Suspended(reason) => fmt.Sprintf("suspended: %s", reason),
Deleted(at, by) => fmt.Sprintf("deleted at %v by %s", at, by),
}
}
```
### Enum Instantiation
Use constructor syntax to create enum variants:
```dingo
// Simple variants (no fields)
status := Status.Pending
active := Status.Active
// Variants with fields - constructor syntax
suspended := Status.Suspended("policy violation")
deleted := Status.Deleted(time.Now(), "[email protected]")
```
### Event Sourcing Example
```dingo
enum UserEvent {
Created { userID: int, email: string, createdAt: time.Time }
EmailChanged { userID: int, oldEmail: string, newEmail: string }
Deactivated { userID: int, reason: string }
Reactivated { userID: int }
}
// Creating events - use constructor syntax
func recordUserCreation(id int, email string) UserEvent {
return UserEvent.Created(id, email, time.Now())
}
func recordEmailChange(id int, old, new string) UserEvent {
return UserEvent.EmailChanged(id, old, new)
}
func processEvent(event UserEvent) {
match event {
Created(id, email, _) => {
fmt.Printf("User %d created with email %s\n", id, email)
},
EmailChanged(id, old, new) => {
fmt.Printf("User %d changed email from %s to %s\n", id, old, new)
},
Deactivated(id, reason) => {
fmt.Printf("User %d deactivated: %s\n", id, reason)
},
Reactivated(id) => {
fmt.Printf("User %d reactivated\n", id)
},
}
}
```
## Pattern Matching (match)
Exhaustive pattern matching with guards.
### Basic Matching
```dingo
func describe(n int) string {
match n {
0 => "zero",
1 => "one",
_ if n < 0 => "negative",
_ if n > 100 => "large",
_ => "other",
}
}
```
### With Enum Destructuring
```dingo
enum Shape {
Circle { radius: float64 }
Rectangle { width: float64, height: float64 }
Triangle { base: float64, height: float64 }
}
func area(shape Shape) float64 {
match shape {
Circle(r) => 3.14159 * r * r,
Rectangle(w, h) => w * h,
Triangle(b, h) => 0.5 * b * h,
}
}
```
### Nested Match with Guards
Complex matching scenarios with nested patterns:
```dingo
enum Response {
Success { data: Option[User], cached: bool }
Error { code: int, message: string }
}
func handleResponse(resp Response) string {
match resp {
// Nested pattern: match on enum variant AND option state
Success(Some(user), true) => {
fmt.Sprintf("Cached user: %s", user.Name)
},
Success(Some(user), false) => {
fmt.Sprintf("Fresh user: %s", user.Name)
},
Success(None(), _) => "No user data",
// Guard on nested field
Error(code, msg) if code >= 500 => {
fmt.Sprintf("Server error %d: %s", code, msg)
},
Error(code, msg) if code >= 400 => {
fmt.Sprintf("Client error %d: %s", code, msg)
},
Error(code, msg) => {
fmt.Sprintf("Unknown error %d: %s", code, msg)
},
}
}
```
### Wildcard Ignoring
```dingo
func getOrderSummary(event OrderEvent) string {
match event {
OrderPlaced(id, _, amount) => fmt.Sprintf("Order %s: $%.2f", id, amount),
OrderShipped(id, _, _) => fmt.Sprintf("Order %s shipped", id),
_ => "Unknown event",
}
}
```
## Lambda Expressions
Concise function literals with two syntax styles.
### Rust-Style (Pipe Syntax)
```dingo
users := []User{...}
// Single argument
activeUsers := filter(users, |u| u.Active)
// Multiple arguments
sorted := sort(users, |a, b| a.Name < b.Name)
// With block body
processed := map(users, |u| {
name := strings.ToUpper(u.Name)
return fmt.Sprintf("%s (%d)", name, u.Age)
})
```
### TypeScript-Style (Arrow Syntax)
```dingo
// Single argument
activeUsers := filter(users, u => u.Active)
// Multiple arguments (parentheses required)
sorted := sort(users, (a, b) => a.CreatedAt.Before(b.CreatedAt))
// With block
processed := map(users, u => {
return u.Name + " - " + u.Email
})
```
### Practical Examples
```dingo
// Filtering
adults := filter(people, |p| p.Age >= 18)
// Mapping
names := map(users, |u| u.Name)
// Reducing
total := reduce(orders, 0, |sum, o| sum + o.Amount)
// Chaining with Option
result := findUser(id)
.Map(|u| u.Profile)
.FlatMap(|p| p.Avatar)
.UnwrapOr(defaultAvatar)
```
## Safe Navigation (?.) and Null Coalescing (??)
Handle nullable chains safely.
### Safe Navigation
```dingo
type Config struct {
Database *DatabaseConfig
}
type DatabaseConfig struct {
Primary *ConnectionInfo
}
type ConnectionInfo struct {
Host string
Port int
}
// Safe navigation through nullable chain
host := config?.Database?.Primary?.Host ?? "localhost"
port := config?.Database?.Primary?.Port ?? 5432
```
### Chained Safe Navigation with Null Coalescing
```dingo
// Deep chain with fallback
dbHost := appConfig?.Database?.Primary?.Host
?? appConfig?.Database?.Fallback?.Host
?? envConfig?.DbHost
?? "localhost"
// Method chains
userName := response?.Data?.User?.Profile?.DisplayName
?? response?.Data?.User?.Name
?? "Anonymous"
// With function calls in fallback
timeout := config?.Timeout ?? getDefaultTimeout()
```
### Null Coalescing
```dingo
// Simple default
name := user.Nickname ?? user.Name ?? "Anonymous"
// With function call
timeout := config.Timeout ?? getDefaultTimeout()
// Combined with safe navigation
dbHost := appConfig?.Database?.Host ?? envConfig?.DbHost ?? "localhost"
```
## Ternary Operator
Simple conditional expressions.
```dingo
// Basic ternary
status := user.Active ? "Active" : "Inactive"
// Nested (use sparingly)
role := user.IsAdmin ? "Admin" : user.IsModerator ? "Moderator" : "User"
// In function calls
greet(user.Preferred ? user.Nickname : user.FullName)
// With expressions
discount := order.Total > 100 ? order.Total * 0.1 : 0
```
## Tuples
Lightweight compound values.
### Tuple Types
```dingo
type Point2D = (float64, float64)
type Range = (int, int)
type NamedResult = (string, int, error)
```
### Tuple Destructuring
```dingo
func getCoordinates() (float64, float64) {
return (42.5, 73.2)
}
// Destructure in assignment
(x, y) := getCoordinates()
// Ignore values with _
(lat, _) := getCoordinates()
// Multiple return handling
(user, err) := fetchUser(id)
if err != nil {
return err
}
```
### Tuple in Functions
```dingo
func minMax(numbers []int) (int, int) {
min := numbers[0]
max := numbers[0]
for _, n := range numbers {
if n < min { min = n }
if n > max { max = n }
}
return (min, max)
}
(lo, hi) := minMax([]int{3, 1, 4, 1, 5, 9})
```
## Guard Statement
Early returns with clear error handling.
**Error Binding Rules:**
- Use `guard x := f() else |err| { ... }` when `f()` returns `(T, error)` or `Result[T, E]` - the error value is bound to `err` for custom handling
- Use `guard x := f() else { ... }` when `f()` returns `Option[T]` - `None` has no error value to bind
### Basic Guard
```dingo
func processUser(id string) Result[User, error] {
// Guard with error handling
guard user := findUser(id) else |err| {
return Err(fmt.Errorf("user not found: %w", err))
}
guard profile := user.Profile else {
return Err(errors.New("user has no profile"))
}
// Both user and profile are now available
return Ok(user)
}
```
### Guard with Option
```dingo
func getDisplayName(userId string) string {
guard user := findUser(userId) else {
return "Unknown User"
}
guard nickname := user.Nickname else {
return user.FullName
}
return nickname
}
```
### Multiple Guards
```dingo
func createOrder(req CreateOrderRequest) (*Order, error) {
guard user := findUser(req.UserID) else |err| {
return nil, fmt.Errorf("invalid user: %w", err)
}
guard cart := getCart(user.ID) else |err| {
return nil, fmt.Errorf("cart not found: %w", err)
}
guard len(cart.Items) > 0 else {
return nil, errors.New("cart is empty")
}
guard total := calculateTotal(cart) else |err| {
return nil, fmt.Errorf("calculation failed: %w", err)
}
return createOrderFromCart(user, cart, total)
}
```
## HTTP Handler Patterns
### Handler with Error Propagation
```dingo
// Standard Go imports apply - import net/http, encoding/json, etc.
import "github.com/go-chi/chi/v5"
func (h *Handler) GetUser(w http.ResponseWriter, r *http.Request) {
id := chi.URLParam(r, "id")
user := h.userService.FindByID(r.Context(), id) ? |e| {
h.handleError(w, e)
return
}
h.respond(w, http.StatusOK, user)
}
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
var req CreateUserRequest
json.NewDecoder(r.Body).Decode(&req) ? |e| {
h.respondError(w, http.StatusBadRequest, "invalid request body")
return
}
user := h.userService.Create(r.Context(), req) ? |e| {
h.handleError(w, e)
return
}
h.respond(w, http.StatusCreated, user)
}
```
### Service Layer with Result Types
```dingo
type UserService struct {
repo UserRepository
}
func (s *UserService) FindByID(ctx context.Context, id string) Result[User, error] {
guard user := s.repo.FindByID(ctx, id) else |err| {
if errors.Is(err, sql.ErrNoRows) {
return Err(NotFoundError("user"))
}
return Err(InternalError(err))
}
return Ok(user)
}
func (s *UserService) Create(ctx context.Context, req CreateUserRequest) Result[User, error] {
// Check if email exists
existing := s.repo.FindByEmail(ctx, req.Email)
if existing.IsSome() {
return Err(ConflictError("email already exists"))
}
hashedPassword := hashPassword(req.Password)?
user := s.repo.Create(ctx, User{
Email: req.Email,
PasswordHash: hashedPassword,
Name: req.Name,
})?
return Ok(user)
}
```
## Repository Pattern
```dingo
type UserRepository interface {
FindByID(ctx context.Context, id string) Result[User, error]
FindByEmail(ctx context.Context, email string) Option[User]
Create(ctx context.Context, user User) Result[User, error]
Update(ctx context.Context, user User) Result[User, error]
Delete(ctx context.Context, id string) Result[bool, error]
}
type postgresUserRepo struct {
db *sql.DB
}
func (r *postgresUserRepo) FindByID(ctx context.Context, id string) Result[User, error] {
var user User
err := r.db.QueryRowContext(ctx,
"SELECT id, email, name, created_at FROM users WHERE id = $1",
id,
).Scan(&user.ID, &user.Email, &user.Name, &user.CreatedAt)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return Err(NotFoundError("user"))
}
return Err(err)
}
return Ok(user)
}
func (r *postgresUserRepo) FindByEmail(ctx context.Context, email string) Option[User] {
var user User
err := r.db.QueryRowContext(ctx,
"SELECT id, email, name FROM users WHERE email = $1",
email,
).Scan(&user.ID, &user.Email, &user.Name)
if err != nil {
return None()
}
return Some(user)
}
```
## Testing
### Unit Tests with Option/Result
```dingo
func TestUserService_FindByID(t *testing.T) {
repo := mocks.NewMockUserRepository(t)
service := NewUserService(repo)
t.Run("returns user when found", func(t *testing.T) {
expected := User{ID: "123", Name: "John"}
repo.EXPECT().FindByID(mock.Anything, "123").Return(Ok(expected))
result := service.FindByID(context.Background(), "123")
assert.True(t, result.IsOk())
assert.Equal(t, expected, result.Unwrap())
})
t.Run("returns error when not found", func(t *testing.T) {
repo.EXPECT().FindByID(mock.Anything, "456").Return(
Err[User, error](NotFoundError("user")),
)
result := service.FindByID(context.Background(), "456")
assert.True(t, result.IsErr())
assert.Contains(t, result.UnwrapErr().Error(), "not found")
})
}
```
### Testing Pattern Matching
```dingo
func TestEventProcessing(t *testing.T) {
tests := []struct {
name string
event UserEvent
expected string
}{
{
name: "created event",
event: UserEvent.Created(1, "[email protected]", time.Now()),
expected: "User 1 created",
},
{
name: "deactivated event",
event: UserEvent.Deactivated(1, "violation"),
expected: "User 1 deactivated",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := processEvent(tt.event)
assert.Contains(t, result, tt.expected)
})
}
}
```
## Best Practices
### Prefer Dingo Idioms Over Go Patterns
| Go Pattern | Dingo Idiom |
|------------|-------------|
| `if err != nil { return err }` | `x := f()?` |
| `*T` for optional values | `Option[T]` |
| `(T, error)` returns | `Result[T, E]` for typed errors |
| `interface{}` + type switch | `enum` + `match` |
| `func(x int) int { return x * 2 }` | `\|x\| x * 2` |
| nil checks chain | `?.` safe navigation |
| `if x != nil { x } else { default }` | `x ?? default` |
| Multi-line if-else | `condition ? a : b` |
### Error Handling Guidelines
1. Use `?` for simple propagation
2. Add context with `? "message"` or `? \|e\| wrap(e)`
3. Use `Result[T, E]` when callers need error type information
4. Use `guard` for early returns that simplify the happy path
### Type Safety Guidelines
1. Prefer `Option[T]` over `*T` for optional values
2. Use `Result[T, E]` for operations that can fail
3. Use `enum` for closed sets of variants
4. Always handle all `match` cases (exhaustive matching)
### Lambda Guidelines
1. Use `|x| expr` for simple transforms
2. Use `(a, b) => expr` for multi-arg comparators
3. Add block `{ ... }` for multi-line bodies
4. Prefer named functions for complex logic
### Project Organization
1. Keep `.dingo` files in the same structure as a Go project
2. The `.dingo/` directory contains generated Go files
3. Add `.dingo/` to `.gitignore`
4. Run `dingo go` before `go build` in CI
---
*Dingo language patterns for Go meta-programming*
This skill helps you work with the Dingo meta-language for Go: write .dingo files, use built-in Option/Result types, leverage the ? error operator and generics shortcuts, and transpile .dingo sources into idiomatic .go code. It focuses on preserving 100% compatibility with the Go ecosystem while making common patterns more concise and safer. Use it to author, transpile, and integrate Dingo code into CI/CD and editor workflows.
The skill inspects .dingo source files and maps Dingo constructs (Option[T], Result[T,E], enums, pattern matching, safe navigation, lambdas, and the ? operator) to generated Go code in a .dingo/ output folder. It validates transpilation steps, surfaces source-level error locations, and ensures generated Go files are gopls-friendly so IDEs and tooling can type-check and build. It also documents common transformations and shows how lambdas and error propagation are translated so behavior remains predictable.
Does the transpiler change runtime semantics compared to hand-written Go?
No — the transpiler produces idiomatic Go that preserves Dingo semantics while remaining compatible with the Go toolchain; runtime behavior matches Dingo language rules.
How does the ? operator behave inside lambdas?
By design, ? inside a lambda propagates the error to the enclosing function. If you need the lambda to return a Result and handle errors locally, use explicit Go-style error checks or return Result values directly.