either

Documentation

Overview

Package either provides a simple implementation of a sum type, Either, that can be either a Left or a Right.

Usage:

left := LeftOf[string](42)
fmt.Println(left.Get()) // 42

right := RightOf[int]("foo")
fmt.Println(right.Get()) // foo

var either Either[int, string] = left
either = right

Index

• type Either
• type Left
  • func LeftOf[R, L any](value L) Left[L, R]
  • func (e Left[L, R]) Get() L
  • func (e Left[L, R]) GoString() string
  • func (e Left[L, R]) String() string
• type Right
  • func RightOf[L, R any](value R) Right[L, R]
  • func (e Right[L, R]) Get() R
  • func (e Right[L, R]) GoString() string
  • func (e Right[L, R]) String() string

Types

type Either

type Either[L, R any] interface {
	String() string
	GoString() string
	// contains filtered or unexported methods
}

Either is a "sum type" that can be either Left or Right.

type Left

type Left[L, R any] struct {
	// contains filtered or unexported fields
}

func LeftOf

func LeftOf[R, L any](value L) Left[L, R]

LeftOf creates an Either[L, R] with a left value.

Note that the L and R type parameters are flipped so that we can use type inference to avoid having to specify the L type.

func (Left[L, R]) Get

func (e Left[L, R]) Get() L

func (Left[L, R]) GoString

func (e Left[L, R]) GoString() string

func (Left[L, R]) String

func (e Left[L, R]) String() string

type Right

type Right[L, R any] struct {
	// contains filtered or unexported fields
}

func RightOf

func RightOf[L, R any](value R) Right[L, R]

RightOf creates an Either[L, R] with a right value.

func (Right[L, R]) Get

func (e Right[L, R]) Get() R

func (Right[L, R]) GoString

func (e Right[L, R]) GoString() string

func (Right[L, R]) String

func (e Right[L, R]) String() string