package reflectlite

Import Path
	internal/reflectlite (on golang.org and go.dev)

Dependency Relation
	imports 3 packages, and imported by 3 packages

Involved Source Files
	    swapper.go
	d-> type.go
	    value.go
	    asm.s

Exported Type Names

	 type Kind uint
		A Kind represents the specific kind of type that a Type represents.
		The zero Kind is not a valid kind.

		As Outputs Of (2+)
			func Type.Kind() Kind
			func Value.Kind() Kind
		As Types Of (27+)
			const Array
			const Bool
			const Chan
			const Complex128
			const Complex64
			const Float32
			const Float64
			const Func
			const Int
			const Int16
			const Int32
			const Int64
			const Int8
			const Interface
			const Invalid
			const Map
			const Ptr
			const Slice
			const String
			const Struct
			const Uint
			const Uint16
			const Uint32
			const Uint64
			const Uint8
			const Uintptr
			const UnsafePointer
	 type Type (interface)
		Type is the representation of a Go type.

		Not all methods apply to all kinds of types. Restrictions,
		if any, are noted in the documentation for each method.
		Use the Kind method to find out the kind of type before
		calling kind-specific methods. Calling a method
		inappropriate to the kind of type causes a run-time panic.

		Type values are comparable, such as with the == operator,
		so they can be used as map keys.
		Two Type values are equal if they represent identical types.

		Exported Methods (9)
			 (T) AssignableTo(u Type) bool
			 (T) Comparable() bool
			 (T) Elem() Type
			 (T) Implements(u Type) bool
			 (T) Kind() Kind
			 (T) Name() string
			 (T) PkgPath() string
			 (T) Size() uintptr
			 (T) String() string
		Implements (1+)
			 T : fmt.Stringer
		As Outputs Of (3+)
			func TypeOf(i interface{}) Type
			func Type.Elem() Type
			func Value.Type() Type
		As Inputs Of (2+)
			func Type.AssignableTo(u Type) bool
			func Type.Implements(u Type) bool
	 type Value (struct)
		Value is the reflection interface to a Go value.

		Not all methods apply to all kinds of values. Restrictions,
		if any, are noted in the documentation for each method.
		Use the Kind method to find out the kind of value before
		calling kind-specific methods. Calling a method
		inappropriate to the kind of type causes a run time panic.

		The zero Value represents no value.
		Its IsValid method returns false, its Kind method returns Invalid,
		its String method returns "<invalid Value>", and all other methods panic.
		Most functions and methods never return an invalid value.
		If one does, its documentation states the conditions explicitly.

		A Value can be used concurrently by multiple goroutines provided that
		the underlying Go value can be used concurrently for the equivalent
		direct operations.

		To compare two Values, compare the results of the Interface method.
		Using == on two Values does not compare the underlying values
		they represent.

		Exported Methods (8)
			 (T) CanSet() bool
			 (T) Elem() Value
			 (T) IsNil() bool
			 (T) IsValid() bool
			 (T) Kind() Kind
			 (T) Len() int
			 (T) Set(x Value)
			 (T) Type() Type
		Implements (1+)
			 T : database/sql/driver.Validator
		As Outputs Of (2+)
			func ValueOf(i interface{}) Value
			func Value.Elem() Value
		As Inputs Of (1+)
			func Value.Set(x Value)
	 type ValueError (struct)
		A ValueError occurs when a Value method is invoked on
		a Value that does not support it. Such cases are documented
		in the description of each method.

		Exported Fields (2)
			Kind Kind
			Method string
		One Exported Method
			(*T) Error() string
		Implements (1+)
			*T : error
Exported Values

	const Array Kind = 17
	const Bool Kind = 1
	const Chan Kind = 18
	const Complex128 Kind = 16
	const Complex64 Kind = 15
	const Float32 Kind = 13
	const Float64 Kind = 14
	const Func Kind = 19
	const Int Kind = 2
	const Int16 Kind = 4
	const Int32 Kind = 5
	const Int64 Kind = 6
	const Int8 Kind = 3
	const Interface Kind = 20
	const Invalid Kind = 0
	const Map Kind = 21
	const Ptr Kind = 22
	const Slice Kind = 23
	const String Kind = 24
	const Struct Kind = 25
	 func Swapper(slice interface{}) func(i, j int)
		Swapper returns a function that swaps the elements in the provided
		slice.

		Swapper panics if the provided interface is not a slice.
	 func TypeOf(i interface{}) Type
		TypeOf returns the reflection Type that represents the dynamic type of i.
		If i is a nil interface value, TypeOf returns nil.
	const Uint Kind = 7
	const Uint16 Kind = 9
	const Uint32 Kind = 10
	const Uint64 Kind = 11
	const Uint8 Kind = 8
	const Uintptr Kind = 12
	const UnsafePointer Kind = 26
	 func ValueOf(i interface{}) Value
		ValueOf returns a new Value initialized to the concrete value
		stored in the interface i. ValueOf(nil) returns the zero Value.

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