enter

Documentation

Index

• Variables
• func Get()
• type Inner
• type MultiParamAligned
• type MultiParamUnaligned
• type MyTest
• type MyTest2
• type MyTest3
• type MyTest4
• type MyTest5
• type Number
• type OuterAligned
• type OuterUnaligned
• type Problem1
• type Problem2
• type Problem3
• type S1
• type S2
• type STR
• type STRs
• type SimpleGenericAligned
• type SimpleGenericUnaligned
• type SliceContainerAligned
• type SliceContainerUnaligned
• type StructWithGenerics
• type StructWithMoreGenerics
• type TreeNodeAligned
• type TreeNodeUnaligned

Variables

var Name = "dsds"

Functions

func Get

func Get()

Types

type Inner

type Inner[T comparable] struct {
	Key   T
	Value string
}

type MultiParamAligned

type MultiParamAligned[T any, U Number] struct {
	First   T
	Second  U
	IsValid bool
}

type MultiParamUnaligned

type MultiParamUnaligned[T string, U Number] struct {
	First   T
	Second  U
	IsValid bool
}

type MyTest

type MyTest struct {
	Problem1 struct {
		I interface{}
		S struct{}
	}

	App struct {
		// LogLevel
		LogLevel                  string        `yaml:"log_level" env-default:"info"` // 2 text
		Name                      string        `yaml:"name" env-default:"ms-sso"`
		IsProduction              bool          `yaml:"is_production" env:"IS_PRODUCTION" yaml-default:"true"`
		TimeToConfirmRegistration time.Duration `yaml:"tim_to_confirm_registration" env-required:"24h"`
	} `yaml:"app"`
	// contains filtered or unexported fields
} /* some text
dsdsd
dsds
*/

Test comment

type MyTest2

type MyTest2 struct{}

type MyTest3

type MyTest3 struct {
}

type MyTest4

type MyTest4 struct{} // test

type MyTest5

type MyTest5 struct{} // test

type Number

type Number interface {
	int | int32 | int64 | float32 | float64
}

Common types used in the structures above

type OuterAligned

type OuterAligned[T any, U comparable] struct {
	Data     T
	Nested   Inner[U]
	Priority int
}

type OuterUnaligned

type OuterUnaligned[T any, U comparable] struct {
	Data     T
	Nested   Inner[U]
	Priority int
}

type Problem1

type Problem1 struct{}

type Problem2

type Problem2 struct {
}

type Problem3

type Problem3 struct {
	time.Time
	time.Duration
	time.Location
	// contains filtered or unexported fields
}

type S1

type S1 struct {
	F1 bool
	F2 string
}

type S2

type S2 struct {
	F1, F2 bool
	F3     string
	F4     StructWithGenerics[int]
	F5     StructWithMoreGenerics[int, float64, string]
}

type STR

type STR string

type STRs

type STRs []string

type SimpleGenericAligned

type SimpleGenericAligned[T any] struct {
	Value T
	ID    int
	Name  string
}

Aligned Structures

type SimpleGenericUnaligned

type SimpleGenericUnaligned[T any] struct {
	Value T
	ID    int
	Name  string
}

Unaligned Structures

type SliceContainerAligned

type SliceContainerAligned[T any] struct {
	Items      []T
	TotalCount int
	MaxSize    int64
	IsReadOnly bool
}

type SliceContainerUnaligned

type SliceContainerUnaligned[T any] struct {
	Items      []T
	TotalCount int
	MaxSize    int64
	IsReadOnly bool
}

type StructWithGenerics

type StructWithGenerics[T any] struct {
	F T
}

type StructWithMoreGenerics

type StructWithMoreGenerics[T1, T2 any, T3 comparable] struct {
	F1 T1
	F2 T2
	F3 T3
}

type TreeNodeAligned

type TreeNodeAligned[T any] struct {
	Value  T
	Left   *TreeNodeAligned[T]
	Right  *TreeNodeAligned[T]
	Depth  int
	IsLeaf bool
}

type TreeNodeUnaligned

type TreeNodeUnaligned[T any] struct {
	Value  T
	Left   *TreeNodeUnaligned[T]
	Right  *TreeNodeUnaligned[T]
	Depth  int
	IsLeaf bool
}