package enum

Import Path
	github.com/orsinium-labs/enum (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 2 packages

Involved Source Files

	    enum.go
Code Examples

	Enum_Contains
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			contains := Colors.Contains(Red)
			fmt.Println(contains)
		}

	Enum_Empty
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			empty := Colors.Empty()
			fmt.Println(empty)
		}

	Enum_GoString
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			fmt.Printf("%#v\n", Colors)
		}

	Enum_Index
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			index := Colors.Index(Green)
			fmt.Println(index)
		}

	Enum_Len
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			length := Colors.Len()
			fmt.Println(length)
		}

	Enum_Members
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			members := Colors.Members()
			fmt.Println(members)
		}

	Enum_Parse
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			parsed := Colors.Parse("red")
			fmt.Printf("%#v\n", parsed)
		}

	Enum_String
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			fmt.Println(Colors)
		}

	Enum_TypeName
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			tname := Colors.TypeName()
			fmt.Println(tname)
		}

	Enum_Value
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			value := Colors.Value(Green)
			fmt.Println(value)
		}

	Enum_Values
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			values := Colors.Values()
			fmt.Println(values)
		}

	New
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			fmt.Printf("%#v\n", Colors)
		}

	NewBuilder
		package main
		
		import (
			"fmt"
		
			"github.com/orsinium-labs/enum"
		)
		
		func main() {
			type Color enum.Member[string]
			var (
				b      = enum.NewBuilder[string, Color]()
				Red    = b.Add(Color{"red"})
				Green  = b.Add(Color{"green"})
				Blue   = b.Add(Color{"blue"})
				Colors = b.Enum()
			)
		
			fmt.Println(
				Colors.Contains(Red),
				Colors.Contains(Green),
				Colors.Contains(Blue),
			)
		}

	Parse
		package main
		
		import (
			"fmt"
			"strings"
		
			"github.com/orsinium-labs/enum"
		)
		
		type FoldedString string
		
		// Equal implements [enum.Equaler].
		//
		// Compare strings ignoring the case.
		func (s FoldedString) Equal(other FoldedString) bool {
			return strings.EqualFold(string(s), string(other))
		}
		
		func main() {
			type Color enum.Member[FoldedString]
		
			var (
				Red    = Color{"red"}
				Green  = Color{"green"}
				Blue   = Color{"blue"}
				Colors = enum.New(Red, Green, Blue)
			)
		
			parsed := enum.Parse(Colors, "RED")
			fmt.Printf("%#v\n", parsed)
		}


Package-Level Type Names (total 4)

	/* sort by: alphabet | popularity */
	 type Builder[M, V] (struct)

		Type Parameters:
			M: iMember[V]
			V: comparable

		Builder is a constructor for an [Enum].
		
		Use [Builder.Add] to add new members to the future enum
		and then call [Builder.Enum] to create a new [Enum] with all added members.
		
		Builder is useful for when you have lots of enum members, and new ones
		are added over time, as the project grows. In such scenario, it's easy to forget
		to add in the [Enum] a newly created [Member].
		The builder is designed to prevent that.

		Methods (total 2)
			(*Builder[M, V]) Add(m M) M
				Add registers a new [Member] in the builder.

			(*Builder[M, V]) Enum() Enum[M, V]
				Enum creates a new [Enum] with all members registered using [Builder.Add].

		As Outputs Of (at least one exported)
			func NewBuilder[V, M]() Builder[M, V]

	 type Enum[M, V] (struct)

		Type Parameters:
			M: iMember[V]
			V: comparable

		Enum is a collection of enum members.
		
		Use [New] to construct a new Enum from a list of members.

		Methods (total 12)
			( Enum[M, V]) Choice(seed int64) *M
				Choice returns a randomly selected member of the enum.
				
				A random seed can be given (or be 0 to use time.Now().UnixNano() as the seed).
				nil is returned only if the Enum contains no members.

			( Enum[M, V]) Contains(member M) bool
				Contains returns true if the enum has the given member.

			( Enum[M, V]) Empty() bool
				Empty returns true if the enum doesn't have any members.

			( Enum[M, V]) GoString() string
				GoString implements [fmt.GoStringer] interface.
				
				When you print a member using "%#v" format,
				it will show the enum representation as a valid Go syntax.

			( Enum[M, V]) Index(member M) int
				Index returns the index of the given member in the enum.
				
				If the given member is not in the enum, it panics.
				Use [Enum.Contains] first if you don't know for sure
				if the member belongs to the enum.

			( Enum[M, V]) Len() int
				Len returns how many members the enum has.

			( Enum[M, V]) Members() []M
				Members returns a slice of the members in the enum.

			( Enum[M, V]) Parse(value V) *M
				Parse converts a raw value into a member of the enum.
				
				If none of the enum members has the given value, nil is returned.

			( Enum[M, V]) String() string
				String implements [fmt.Stringer] interface.
				
				It returns a comma-separated list of values of the enum members.

			( Enum[M, V]) TypeName() string
				TypeName is a string representation of the wrapped type.

			( Enum[M, V]) Value(member M) V
				Value returns the wrapped value of the given enum member.

			( Enum[M, V]) Values() []V
				Values returns a slice of values of all members of the enum.

		Implements (at least 4)
			 Enum : github.com/apache/arrow-go/v18/arrow/compute.FunctionOptions
			 Enum : expvar.Var
			 Enum : fmt.GoStringer
			 Enum : fmt.Stringer
		As Outputs Of (at least 2)
			func New[V, M](members ...M) Enum[M, V]
			func (*Builder)[M, V].Enum() Enum[M, V]
		As Inputs Of (at least one exported)
			func Parse[M, V](e Enum[M, V], value V) *M
		As Types Of (total 3)
			  var github.com/pancsta/asyncmachine-go/pkg/integrations.KindEnum enum.Enum[...]
			  var github.com/pancsta/asyncmachine-go/pkg/rpc.ClientMethods enum.Enum[...]
			  var github.com/pancsta/asyncmachine-go/pkg/rpc.ServerMethods enum.Enum[...]

	 type Equaler[V] (interface)

		Type Parameters:
			V: comparable

		Equaler check if the two values of the same type are equal.

		Methods (only one)
			( Equaler[V]) Equal(other V) bool

	 type Member[T] (struct)

		Type Parameters:
			T: comparable

		Member is an enum member, a specific value bound to a variable.

		Fields (only one)
			Value T


Package-Level Functions (total 3)

	 func New[V, M](members ...M) Enum[M, V]

		Type Parameters:
			V: comparable
			M: iMember[V]

		New constructs a new [Enum] wrapping the given enum members.

	 func NewBuilder[V, M]() Builder[M, V]

		Type Parameters:
			V: comparable
			M: iMember[V]

		NewBuilder creates a new [Builder], a constructor for an [Enum].

	 func Parse[M, V](e Enum[M, V], value V) *M

		Type Parameters:
			M: iMember[V]
			V: Equaler[V]

		Parse is like [Enum.Parse] but finds the member for the value using [Equaler] comparator.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.