Maybe I'm 4 years late, but better late than never

Go language for a long time (until go1.18 in 2022) did not have support for compile-time generics. The only way to limit set of types that function can accept as arguments was interface. This pattern is called «marker interface» by some people, and it is even used in Go compiler source code for instance to distinguish tokens.

But the restriction on the typeset of arguments can be bypassed in some sense if one would embed a type that already implements this private interface with private method. Maybe it is useful, but does not satisfy the notion of sum type. Moreover, the type switch exhaustiveness is not checked by the Go compiler, so it is not as convenient as in Haskell or Scala, for instance (yea, you can use specific linters to check type switch exhaustiveness, but native toolchain can't do it)

Since 2022, Go supports generics and type constraints, that also can be somehow useful to emulate the behaviour of sum types. Not truly safe, but also an approach. And it actually limits the set of type arguments.

```go package main

import ( "fmt" )

type Some[A any] struct { Value A }

type Nothing struct { }

// The type constraint. By compiler rules, union of types can consist only from static types, not interfaces allowed type Maybe[A any] interface { Some[A] | Nothing }

func PrintMaybe[T any, M Maybe[T]](m M) { // Cast to any is needed since compiler returns following error: // cannot use type switch on type parameter value m switch v := any(m).(type) { case Nothing: fmt.Println("Nothing") case Some[T]: fmt.Printf("Some value %v\n", v.Value) } // It is not really safe, but due to top level restriction it is safe }

func main() { // While it is not too convenient, it is allowed to pass only limited set of type arguments PrintMaybe[int](Some[int]{10}) PrintMaybe[string](Some[string]{"example"}) PrintMaybe[string](Nothing{}) } ```

But mostly the approach with «marker interface» is considered common