Go中实现Rust式类型匹配的惯用方式是什么？

I understand that Go does not support enums of the kind shown in the Rust example below. What would be the idiomatic way of achieving the same effect, i.e., perform matching on types, in Go? For example, would I use an empty struct or an interface?

enum WebEvent {
    PageLoad,
    KeyPress(char),
}

fn inspect(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("page loaded"),
        WebEvent::KeyPress(c) => println!("pressed '{}'.", c),
    }
}

Example taken from Rust By Example.

If your WebEvents share a common functionality, define an explicit interface.

type WebEvent interface {
    Foo()
    Bar()
}

type PageLoad struct{}

func (*pl PageLoad) Foo() {
    // do something
}

func (*pl PageLoad) Bar() {
    // do something else
}

func Inspect(event WebEvent) {
    switch event.(type) {
    case PageLoad:
        // inside this block you're operating on event.(PageLoad), not just event.(WebEvent)!
    }
}

Otherwise you can use an empty interface

type PageLoad struct{}  // optionally with methods as above

func Inspect(event interface{}) {
    switch event.(type) {
    case PageLoad:
        // similarly, in here event is a PageLoad, not an interface{}
    }
}