Namespace: go.std.reflect
v1.0Contents
Summary
Provides a lowlevel interface to the reflect package.
Package reflect implements runtime reflection, allowing a program to
manipulate objects with arbitrary types. The typical use is to take a value
with static type interface{} and extract its dynamic type information by
calling TypeOf, which returns a Type.
A call to ValueOf returns a Value representing the runtime data.
Zero takes a Type and returns a Value representing a zero value
for that type.
See "The Laws of Reflection" for an introduction to reflection in Go:
https://golang.org/doc/articles/laws_of_reflection.html
Index
 *ChanDir
 *Kind
 *MapIter
 *Method
 *SelectCase
 *SelectDir
 *SliceHeader
 *StringHeader
 *StructField
 *StructTag
 *Value
 *ValueError
 AppendSlice
 Array
 ArrayOf
 Bool
 BothDir
 Chan
 ChanDir
 ChanOf
 Complex128
 Complex64
 Copy
 Float32
 Float64
 Func
 Indirect
 Intrenamed
 Int16
 Int32
 Int64
 Int8
 Interface
 Invalid
 Kind
 MakeChan
 MakeMap
 MakeMapWithSize
 MakeSlice
 Map
 MapIter
 MapOf
 Method
 New
 NewAt
 Ptr
 PtrTo
 RecvDir
 SelectCase
 SelectDefault
 SelectDir
 SelectRecv
 SelectSend
 SendDir
 Slice
 SliceHeader
 SliceOf
 Stringrenamed
 StringHeader
 Struct
 StructField
 StructTag
 Type
 Uint
 Uint16
 Uint32
 Uint64
 Uint8
 Uintptr
 UnsafePointer
 Value
 ValueError
 Zero
Legend

Constant
Variable
Function
Macro
Special form
GoType
GoVar
Receiver/Method
Constants
Constants are variables with :const true in their metadata. Joker currently does not recognize them as special; as such, it allows redefining them or their values.
Array
Number v1.0 
Bool
Number v1.0 
BothDir
Int v1.0chan

Chan
Number v1.0 
Complex128
Number v1.0 
Complex64
Number v1.0 
Float32
Number v1.0 
Float64
Number v1.0 
Func
Number v1.0 
Intrenamed
Number v1.0 
Int16
Number v1.0 
Int32
Number v1.0 
Int64
Number v1.0 
Int8
Number v1.0 
Interface
Number v1.0 
Invalid
Number v1.0 
Map
Number v1.0 
Ptr
Number v1.0 
RecvDir
Int v1.0<chan

SelectDefault
Int v1.0default

SelectRecv
Int v1.0case <Chan:

SelectSend
Int v1.0case Chan < Send

SendDir
Int v1.0chan<

Slice
Number v1.0 
Stringrenamed
Number v1.0 
Struct
Number v1.0 
Uint
Number v1.0 
Uint16
Number v1.0 
Uint32
Number v1.0 
Uint64
Number v1.0 
Uint8
Number v1.0 
Uintptr
Number v1.0 
UnsafePointer
Number v1.0
Variables

(None.)
Functions, Macros, and Special Forms

AppendSlice
Function v1.0(AppendSlice s t)
AppendSlice appends a slice t to a slice s and returns the resulting slice.
The slices s and t must have the same element type.
Go input arguments: (s Value, t Value)
Go return type: Value
Joker input arguments: [^go.std.reflect/Value s, ^go.std.reflect/Value t]
Joker return type: go.std.reflect/Value 
ArrayOf
Function v1.0(ArrayOf count elem)
ArrayOf returns the array type with the given count and element type.
For example, if t represents int, ArrayOf(5, t) represents [5]int.
If the resulting type would be larger than the available address space,
ArrayOf panics.
Go input arguments: (count int, elem Type)
Go return type: Type
Joker input arguments: [^Int count, ^go.std.reflect/Type elem]
Joker return type: go.std.reflect/Type 
ChanOf
Function v1.0(ChanOf dir t)
ChanOf returns the channel type with the given direction and element type.
For example, if t represents int, ChanOf(RecvDir, t) represents <chan int.
The gc runtime imposes a limit of 64 kB on channel element types.
If t's size is equal to or exceeds this limit, ChanOf panics.
Go input arguments: (dir ChanDir, t Type)
Go return type: Type
Joker input arguments: [^go.std.reflect/ChanDir dir, ^go.std.reflect/Type t]
Joker return type: go.std.reflect/Type 
Copy
Function v1.0(Copy dst src)
Copy copies the contents of src into dst until either
dst has been filled or src has been exhausted.
It returns the number of elements copied.
Dst and src each must have kind Slice or Array, and
dst and src must have the same element type.
As a special case, src can have kind String if the element type of dst is kind Uint8.
Go input arguments: (dst Value, src Value)
Go return type: int
Joker input arguments: [^go.std.reflect/Value dst, ^go.std.reflect/Value src]
Joker return type: Int 
Indirect
Function v1.0(Indirect v)
Indirect returns the value that v points to.
If v is a nil pointer, Indirect returns a zero Value.
If v is not a pointer, Indirect returns v.
Go input arguments: (v Value)
Go return type: Value
Joker input arguments: [^go.std.reflect/Value v]
Joker return type: go.std.reflect/Value 
MakeChan
Function v1.0(MakeChan typ buffer)
MakeChan creates a new channel with the specified type and buffer size.
Go input arguments: (typ Type, buffer int)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ, ^Int buffer]
Joker return type: go.std.reflect/Value 
MakeMap
Function v1.0(MakeMap typ)
MakeMap creates a new map with the specified type.
Go input arguments: (typ Type)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ]
Joker return type: go.std.reflect/Value 
MakeMapWithSize
Function v1.0(MakeMapWithSize typ n)
MakeMapWithSize creates a new map with the specified type
and initial space for approximately n elements.
Go input arguments: (typ Type, n int)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ, ^Int n]
Joker return type: go.std.reflect/Value 
MakeSlice
Function v1.0(MakeSlice typ len cap)
MakeSlice creates a new zeroinitialized slice value
for the specified slice type, length, and capacity.
Go input arguments: (typ Type, len int, cap int)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ, ^Int len, ^Int cap]
Joker return type: go.std.reflect/Value 
MapOf
Function v1.0(MapOf key elem)
MapOf returns the map type with the given key and element types.
For example, if k represents int and e represents string,
MapOf(k, e) represents map[int]string.
If the key type is not a valid map key type (that is, if it does
not implement Go's == operator), MapOf panics.
Go input arguments: (key Type, elem Type)
Go return type: Type
Joker input arguments: [^go.std.reflect/Type key, ^go.std.reflect/Type elem]
Joker return type: go.std.reflect/Type 
New
Function v1.0(New typ)
New returns a Value representing a pointer to a new zero value
for the specified type. That is, the returned Value's Type is PtrTo(typ).
Go input arguments: (typ Type)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ]
Joker return type: go.std.reflect/Value 
NewAt
Function v1.0(NewAt typ p)
NewAt returns a Value representing a pointer to a value of the
specified type, using p as that pointer.
Go input arguments: (typ Type, p unsafe.Pointer)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ, ^go.std.unsafe/Pointer p]
Joker return type: go.std.reflect/Value 
PtrTo
Function v1.0(PtrTo t)
PtrTo returns the pointer type with element t.
For example, if t represents type Foo, PtrTo(t) represents *Foo.
Go input arguments: (t Type)
Go return type: Type
Joker input arguments: [^go.std.reflect/Type t]
Joker return type: go.std.reflect/Type 
SliceOf
Function v1.0(SliceOf t)
SliceOf returns the slice type with element type t.
For example, if t represents int, SliceOf(t) represents []int.
Go input arguments: (t Type)
Go return type: Type
Joker input arguments: [^go.std.reflect/Type t]
Joker return type: go.std.reflect/Type 
Zero
Function v1.0(Zero typ)
Zero returns a Value representing the zero value for the specified type.
The result is different from the zero value of the Value struct,
which represents no value at all.
For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0.
The returned value is neither addressable nor settable.
Go input arguments: (typ Type)
Go return type: Value
Joker input arguments: [^go.std.reflect/Type typ]
Joker return type: go.std.reflect/Value
Types

*ChanDir
Concrete GoType v1.0 
*Kind
Concrete GoType v1.0 
*MapIter
Concrete GoType v1.0 
Key
Receiver for *MapIter v1.0([])
Key returns the key of the iterator's current map entry.

Next
Receiver for *MapIter v1.0([])
Next advances the map iterator and reports whether there is another
entry. It returns false when the iterator is exhausted; subsequent
calls to Key, Value, or Next will panic.

Value
Receiver for *MapIter v1.0([])
Value returns the value of the iterator's current map entry.

*Method
Concrete GoType v1.0 
*SelectCase
Concrete GoType v1.0 
*SelectDir
Concrete GoType v1.0 
*SliceHeader
Concrete GoType v1.0 
*StringHeader
Concrete GoType v1.0 
*StructField
Concrete GoType v1.0 
*StructTag
Concrete GoType v1.0 
*Value
Concrete GoType v1.0 
*ValueError
Concrete GoType v1.0 
Error
Receiver for *ValueError v1.0([])

ChanDir
Concrete GoType v1.0ChanDir represents a channel type's direction.

String
Receiver for ChanDir v1.0([])

Kind
Concrete GoType v1.0A Kind represents the specific kind of type that a Type represents.
The zero Kind is not a valid kind.

String
Receiver for Kind v1.0([])
String returns the name of k.

MapIter
Concrete GoType v1.0A MapIter is an iterator for ranging over a map.
See Value.MapRange.

Method
Concrete GoType v1.0Method represents a single method.

SelectCase
Concrete GoType v1.0A SelectCase describes a single case in a select operation.
The kind of case depends on Dir, the communication direction.
If Dir is SelectDefault, the case represents a default case.
Chan and Send must be zero Values.
If Dir is SelectSend, the case represents a send operation.
Normally Chan's underlying value must be a channel, and Send's underlying value must be
assignable to the channel's element type. As a special case, if Chan is a zero Value,
then the case is ignored, and the field Send will also be ignored and may be either zero
or nonzero.
If Dir is SelectRecv, the case represents a receive operation.
Normally Chan's underlying value must be a channel and Send must be a zero Value.
If Chan is a zero Value, then the case is ignored, but Send must still be a zero Value.
When a receive operation is selected, the received Value is returned by Select.

SelectDir
Concrete GoType v1.0A SelectDir describes the communication direction of a select case.

SliceHeader
Concrete GoType v1.0SliceHeader is the runtime representation of a slice.
It cannot be used safely or portably and its representation may
change in a later release.
Moreover, the Data field is not sufficient to guarantee the data
it references will not be garbage collected, so programs must keep
a separate, correctly typed pointer to the underlying data.

StringHeader
Concrete GoType v1.0StringHeader is the runtime representation of a string.
It cannot be used safely or portably and its representation may
change in a later release.
Moreover, the Data field is not sufficient to guarantee the data
it references will not be garbage collected, so programs must keep
a separate, correctly typed pointer to the underlying data.

StructField
Concrete GoType v1.0A StructField describes a single field in a struct.

StructTag
Concrete GoType v1.0A StructTag is the tag string in a struct field.
By convention, tag strings are a concatenation of
optionally spaceseparated key:"value" pairs.
Each key is a nonempty string consisting of noncontrol
characters other than space (U+0020 ' '), quote (U+0022 '"'),
and colon (U+003A ':'). Each value is quoted using U+0022 '"'
characters and Go string literal syntax.

Get
Receiver for StructTag v1.0([key])
Get returns the value associated with key in the tag string.
If there is no such key in the tag, Get returns the empty string.
If the tag does not have the conventional format, the value
returned by Get is unspecified. To determine whether a tag is
explicitly set to the empty string, use Lookup.

Lookup
Receiver for StructTag v1.0([key])
Lookup returns the value associated with key in the tag string.
If the key is present in the tag the value (which may be empty)
is returned. Otherwise the returned value will be the empty string.
The ok return value reports whether the value was explicitly set in
the tag string. If the tag does not have the conventional format,
the value returned by Lookup is unspecified.

Type
Abstract GoType v1.0Type 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 kindspecific methods. Calling a method
inappropriate to the kind of type causes a runtime 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.

Align
Method for Type v1.0([])
Align returns the alignment in bytes of a value of
this type when allocated in memory.

AssignableTo
Method for Type v1.0([u])
AssignableTo reports whether a value of the type is assignable to type u.

Bits
Method for Type v1.0([])
Bits returns the size of the type in bits.
It panics if the type's Kind is not one of the
sized or unsized Int, Uint, Float, or Complex kinds.

ChanDir
Method for Type v1.0([])
ChanDir returns a channel type's direction.
It panics if the type's Kind is not Chan.

Comparable
Method for Type v1.0([])
Comparable reports whether values of this type are comparable.

ConvertibleTo
Method for Type v1.0([u])
ConvertibleTo reports whether a value of the type is convertible to type u.

Elem
Method for Type v1.0([])
Elem returns a type's element type.
It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.

Field
Method for Type v1.0([i])
Field returns a struct type's i'th field.
It panics if the type's Kind is not Struct.
It panics if i is not in the range [0, NumField()).

FieldAlign
Method for Type v1.0([])
FieldAlign returns the alignment in bytes of a value of
this type when used as a field in a struct.

FieldByName
Method for Type v1.0([name])
FieldByName returns the struct field with the given name
and a boolean indicating if the field was found.

Implements
Method for Type v1.0([u])
Implements reports whether the type implements the interface type u.

In
Method for Type v1.0([i])
In returns the type of a function type's i'th input parameter.
It panics if the type's Kind is not Func.
It panics if i is not in the range [0, NumIn()).

IsVariadic
Method for Type v1.0([])
IsVariadic reports whether a function type's final input parameter
is a "..." parameter. If so, t.In(t.NumIn()  1) returns the parameter's
implicit actual type []T.
For concreteness, if t represents func(x int, y ... float64), then
t.NumIn() == 2
t.In(0) is the reflect.Type for "int"
t.In(1) is the reflect.Type for "[]float64"
t.IsVariadic() == true
IsVariadic panics if the type's Kind is not Func.

Key
Method for Type v1.0([])
Key returns a map type's key type.
It panics if the type's Kind is not Map.

Kind
Method for Type v1.0([])
Kind returns the specific kind of this type.

Len
Method for Type v1.0([])
Len returns an array type's length.
It panics if the type's Kind is not Array.

Method
Method for Type v1.0([arg1])
Method returns the i'th method in the type's method set.
It panics if i is not in the range [0, NumMethod()).
For a noninterface type T or *T, the returned Method's Type and Func
fields describe a function whose first argument is the receiver.
For an interface type, the returned Method's Type field gives the
method signature, without a receiver, and the Func field is nil.
Only exported methods are accessible and they are sorted in
lexicographic order.

MethodByName
Method for Type v1.0([arg1])
MethodByName returns the method with that name in the type's
method set and a boolean indicating if the method was found.
For a noninterface type T or *T, the returned Method's Type and Func
fields describe a function whose first argument is the receiver.
For an interface type, the returned Method's Type field gives the
method signature, without a receiver, and the Func field is nil.

Name
Method for Type v1.0([])
Name returns the type's name within its package for a defined type.
For other (nondefined) types it returns the empty string.

NumField
Method for Type v1.0([])
NumField returns a struct type's field count.
It panics if the type's Kind is not Struct.

NumIn
Method for Type v1.0([])
NumIn returns a function type's input parameter count.
It panics if the type's Kind is not Func.

NumMethod
Method for Type v1.0([])
NumMethod returns the number of exported methods in the type's method set.

NumOut
Method for Type v1.0([])
NumOut returns a function type's output parameter count.
It panics if the type's Kind is not Func.

Out
Method for Type v1.0([i])
Out returns the type of a function type's i'th output parameter.
It panics if the type's Kind is not Func.
It panics if i is not in the range [0, NumOut()).

PkgPath
Method for Type v1.0([])
PkgPath returns a defined type's package path, that is, the import path
that uniquely identifies the package, such as "encoding/base64".
If the type was predeclared (string, error) or not defined (*T, struct{},
[]int, or A where A is an alias for a nondefined type), the package path
will be the empty string.

Value
Concrete GoType v1.0Value 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 kindspecific 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.

Addr
Receiver for Value v1.0([])
Addr returns a pointer value representing the address of v.
It panics if CanAddr() returns false.
Addr is typically used to obtain a pointer to a struct field
or slice element in order to call a method that requires a
pointer receiver.

Bool
Receiver for Value v1.0([])
Bool returns v's underlying value.
It panics if v's kind is not Bool.

Bytes
Receiver for Value v1.0([])
Bytes returns v's underlying value.
It panics if v's underlying value is not a slice of bytes.

CanAddr
Receiver for Value v1.0([])
CanAddr reports whether the value's address can be obtained with Addr.
Such values are called addressable. A value is addressable if it is
an element of a slice, an element of an addressable array,
a field of an addressable struct, or the result of dereferencing a pointer.
If CanAddr returns false, calling Addr will panic.

CanInterface
Receiver for Value v1.0([])
CanInterface reports whether Interface can be used without panicking.

CanSet
Receiver for Value v1.0([])
CanSet reports whether the value of v can be changed.
A Value can be changed only if it is addressable and was not
obtained by the use of unexported struct fields.
If CanSet returns false, calling Set or any typespecific
setter (e.g., SetBool, SetInt) will panic.

Cap
Receiver for Value v1.0([])
Cap returns v's capacity.
It panics if v's Kind is not Array, Chan, or Slice.

Convert
Receiver for Value v1.0([t])
Convert returns the value v converted to type t.
If the usual Go conversion rules do not allow conversion
of the value v to type t, Convert panics.

Elem
Receiver for Value v1.0([])
Elem returns the value that the interface v contains
or that the pointer v points to.
It panics if v's Kind is not Interface or Ptr.
It returns the zero Value if v is nil.

Field
Receiver for Value v1.0([i])
Field returns the i'th field of the struct v.
It panics if v's Kind is not Struct or i is out of range.

FieldByName
Receiver for Value v1.0([name])
FieldByName returns the struct field with the given name.
It returns the zero Value if no field was found.
It panics if v's Kind is not struct.

Index
Receiver for Value v1.0([i])
Index returns v's i'th element.
It panics if v's Kind is not Array, Slice, or String or i is out of range.

Int
Receiver for Value v1.0([])
Int returns v's underlying value, as an int64.
It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.

Interface
Receiver for Value v1.0([])
Interface returns v's current value as an interface{}.
It is equivalent to:
var i interface{} = (v's underlying value)
It panics if the Value was obtained by accessing
unexported struct fields.

InterfaceData
Receiver for Value v1.0([])
InterfaceData returns the interface v's value as a uintptr pair.
It panics if v's Kind is not Interface.

IsNil
Receiver for Value v1.0([])
IsNil reports whether its argument v is nil. The argument must be
a chan, func, interface, map, pointer, or slice value; if it is
not, IsNil panics. Note that IsNil is not always equivalent to a
regular comparison with nil in Go. For example, if v was created
by calling ValueOf with an uninitialized interface variable i,
i==nil will be true but v.IsNil will panic as v will be the zero
Value.

IsValid
Receiver for Value v1.0([])
IsValid reports whether v represents a value.
It returns false if v is the zero Value.
If IsValid returns false, all other methods except String panic.
Most functions and methods never return an invalid Value.
If one does, its documentation states the conditions explicitly.

IsZero
Receiver for Value v1.0([])
IsZero reports whether v is the zero value for its type.
It panics if the argument is invalid.

Kind
Receiver for Value v1.0([])
Kind returns v's Kind.
If v is the zero Value (IsValid returns false), Kind returns Invalid.

Len
Receiver for Value v1.0([])
Len returns v's length.
It panics if v's Kind is not Array, Chan, Map, Slice, or String.

MapIndex
Receiver for Value v1.0([key])
MapIndex returns the value associated with key in the map v.
It panics if v's Kind is not Map.
It returns the zero Value if key is not found in the map or if v represents a nil map.
As in Go, the key's value must be assignable to the map's key type.

MapKeys
Receiver for Value v1.0([])
MapKeys returns a slice containing all the keys present in the map,
in unspecified order.
It panics if v's Kind is not Map.
It returns an empty slice if v represents a nil map.

MapRange
Receiver for Value v1.0([])
MapRange returns a range iterator for a map.
It panics if v's Kind is not Map.
Call Next to advance the iterator, and Key/Value to access each entry.
Next returns false when the iterator is exhausted.
MapRange follows the same iteration semantics as a range statement.
Example:
iter := reflect.ValueOf(m).MapRange()
for iter.Next() {
k := iter.Key()
v := iter.Value()
...
}

Method
Receiver for Value v1.0([i])
Method returns a function value corresponding to v's i'th method.
The arguments to a Call on the returned function should not include
a receiver; the returned function will always use v as the receiver.
Method panics if i is out of range or if v is a nil interface value.

MethodByName
Receiver for Value v1.0([name])
MethodByName returns a function value corresponding to the method
of v with the given name.
The arguments to a Call on the returned function should not include
a receiver; the returned function will always use v as the receiver.
It returns the zero Value if no method was found.

NumField
Receiver for Value v1.0([])
NumField returns the number of fields in the struct v.
It panics if v's Kind is not Struct.

NumMethod
Receiver for Value v1.0([])
NumMethod returns the number of exported methods in the value's method set.

OverflowInt
Receiver for Value v1.0([x])
OverflowInt reports whether the int64 x cannot be represented by v's type.
It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.

OverflowUint
Receiver for Value v1.0([x])
OverflowUint reports whether the uint64 x cannot be represented by v's type.
It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.

Recv
Receiver for Value v1.0([])
Recv receives and returns a value from the channel v.
It panics if v's Kind is not Chan.
The receive blocks until a value is ready.
The boolean value ok is true if the value x corresponds to a send
on the channel, false if it is a zero value received because the channel is closed.

Slice
Receiver for Value v1.0([i j])
Slice returns v[i:j].
It panics if v's Kind is not Array, Slice or String, or if v is an unaddressable array,
or if the indexes are out of bounds.

Slice3
Receiver for Value v1.0([i j k])
Slice3 is the 3index form of the slice operation: it returns v[i:j:k].
It panics if v's Kind is not Array or Slice, or if v is an unaddressable array,
or if the indexes are out of bounds.

String
Receiver for Value v1.0([])
String returns the string v's underlying value, as a string.
String is a special case because of Go's String method convention.
Unlike the other getters, it does not panic if v's Kind is not String.
Instead, it returns a string of the form "<T value>" where T is v's type.
The fmt package treats Values specially. It does not call their String
method implicitly but instead prints the concrete values they hold.

TryRecv
Receiver for Value v1.0([])
TryRecv attempts to receive a value from the channel v but will not block.
It panics if v's Kind is not Chan.
If the receive delivers a value, x is the transferred value and ok is true.
If the receive cannot finish without blocking, x is the zero Value and ok is false.
If the channel is closed, x is the zero value for the channel's element type and ok is false.

TrySend
Receiver for Value v1.0([x])
TrySend attempts to send x on the channel v but will not block.
It panics if v's Kind is not Chan.
It reports whether the value was sent.
As in Go, x's value must be assignable to the channel's element type.

Type
Receiver for Value v1.0([])
Type returns v's type.

Uint
Receiver for Value v1.0([])
Uint returns v's underlying value, as a uint64.
It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.

ValueError
Concrete GoType v1.0A 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.