Go AST Visualizer

// -- go-visual-ast -------------------------------------------------
// However the nodes to see tooltips.
// Click the nodes to see the details.
// Ctrl+ScrollUp/Down on the tree node to change zoom.
//
// You can also drag & resize the sidebar and the
// pinned panel for a custom layout.
// -----------------------------------------------------------------

package main

import (
    "errors"
    "fmt"
    "math"
    "sync"
)

// -- types: basic -------------------------------------------------

var (
    i   int     = 42
    f   float64 = 3.14
    b   bool    = true
    s   string  = "hello"
    by  byte    = 'A'
    rn  rune    = '世'
    ui  uint    = 7
    c64 complex64 = 1 + 2i
)

// -- types: composite ---------------------------------------------

type Color int

const (
    Red Color = iota
    Green
    Blue
)

type Person struct {
    Name string
    Age  int
    Tags []string
}

type Animal interface {
    Speak() string
}

type Dog struct {
    Name string
}

func (d Dog) Speak() string { return "Woof!" }

var (
    arr  [3]int          = [3]int{1, 2, 3}
    slc  []string        = []string{"a", "b", "c"}
    mp   map[string]int  = map[string]int{"x": 1}
    ch   chan int        = make(chan int, 1)
    ptr  *int            = &i
    fn   func(int) int   = func(x int) int { return x * 2 }
    ifce Animal          = Dog{"Buddy"}
    e    error           = errors.New("oops")
)

// -- control flow -------------------------------------------------

func ifElseFor(a int) string {
    var result string
    for j := 0; j < a; j++ {
        if j%2 == 0 {
            result += "even "
        } else {
            result += "odd "
        }
    }
    return result
}

func switchCase(v interface{}) string {
    switch x := v.(type) {
    case int:
        return fmt.Sprintf("int: %d", x)
    case string:
        return fmt.Sprintf("string: %s", x)
    case bool:
        return fmt.Sprintf("bool: %v", x)
    case nil:
        return "nil"
    default:
        return "unknown"
    }
}

// -- generics -----------------------------------------------------

func Max[T int | float64](a, b T) T {
    if a > b {
        return a
    }
    return b
}

type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(v T) {
    s.items = append(s.items, v)
}

// -- embedding ----------------------------------------------------

type Base struct{ ID int }

func (b Base) Identify() string {
    return fmt.Sprintf("#%d", b.ID)
}

type Extended struct {
    Base
    Extra string
}

// -- channels & goroutines -----------------------------------

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}

// -- type constraints ---------------------------------------------

type Number interface {
    int | int64 | float64
}

// -- function literals / closures ---------------------------------

func newCounter() func() int {
    x := 0
    return func() int {
        x++
        return x
    }
}

// -- defer / panic / recover --------------------------------------

func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic: %v", r)
        }
    }()
    if b == 0 {
        panic("division by zero")
    }
    return a / b, nil
}

// -- labeled statements -------------------------------------------

func labelDemo() {
outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i*j > 2 {
                break outer
            }
        }
    }
}

// -- complex example ----------------------------------------------

type Cache[K comparable, V any] struct {
    mu    sync.Mutex
    store map[K]V
}

func NewCache[K comparable, V any]() *Cache[K, V] {
    return &Cache[K, V]{store: make(map[K]V)}
}

func (c *Cache[K, V]) Get(key K) (V, bool) {
    c.mu.Lock()
    defer c.mu.Unlock()
    v, ok := c.store[key]
    return v, ok
}

func (c *Cache[K, V]) Set(key K, val V) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.store[key] = val
}

type Result[T any] struct {
    Value T
    Err   error
}

func process[T fmt.Stringer](items []T) []Result[string] {
    results := make([]Result[string], 0, len(items))
    for _, item := range items {
        results = append(results, Result[string]{
            Value: item.String(),
        })
    }
    return results
}

// -- main ---------------------------------------------------------

func main() {
    fmt.Println(ifElseFor(5))
    fmt.Println(switchCase(42))
    fmt.Println(switchCase("hi"))
    fmt.Println(Max(3.0, 4.0))
    fmt.Println(Dog{"Rex"}.Speak())
    fmt.Println(safeDivide(10, 0))

s := &Stack[int]{}
    s.Push(1)
    s.Push(2)

e := Extended{Base: Base{ID: 99}, Extra: "data"}
    fmt.Println(e.Identify())

counter := newCounter()
    fmt.Println(counter())
    fmt.Println(counter())

fmt.Println(math.Sqrt(16))

jobs := make(chan int, 5)
    res := make(chan int, 5)
    go worker(1, jobs, res)
    for j := 1; j <= 3; j++ {
        jobs <- j
    }
    close(jobs)
    for j := 1; j <= 3; j++ {
        fmt.Println(<-res)
    }

cache := NewCache[string, int]()
    cache.Set("hello", 42)
    if v, ok := cache.Get("hello"); ok {
        fmt.Println(v)
    }
}

Paste Go code on the left and click "Visualize AST".