Set fills the fields of the struct ptr points to from their `default` tags, and descends into structs, pointers, slices and maps to do the same below.

CanUpdate returns true when the given value is an initial value of its type

add adds an entry for k below the deepest x holds, and reports true, or reports false and adds nothing if x already holds k.

MustSet function is a wrapper of Set function It will call Set and panic if err not equals nil.

hash mixes k into an int whose low bits pick a bucket.

key is w as the path's index holds it. A reflect.Type points to the one descriptor of its type, so the descriptor's address names the type, as == on T

This test is in package defaults rather than defaults_test: it takes walking and pathIndex on their own, which Set reaches only through a walk deeper

pathKeys returns n keys, no two alike, and keeps the values they name alive for the test.

pathSmallIndex returns an index with room for size entries, which grow doubles. The walk makes a larger one; a small one reaches grow in a handful of

pop takes the deepest entry out of x.

repeatsFar is repeatsNear for a w more than scanDepth down.

unmarshalTag offers value to target's own unmarshalers, UnmarshalText first and UnmarshalJSON second, and reports whether one took it. An empty value

pathBelow returns an entry naming a value of its own, below outer.

repeatsNear reports whether the value w names is already being walked above it, on w.outer's path, if w is no more than scanDepth down. For a deeper w

leave takes w out of the path's index, if the index holds it, as w's walk returns. It is called on every return, a failed walk's too: a failure ends t

benchFillValue is benchFill for a type built at run time.

benchStruct builds a struct of n fields of typ, F0 to Fn-1, each tagged tag: a field count or a tag chosen at run time, where a literal struct would t

isPromotedMethod reports whether the method called name is promoted from an embedded field rather than declared by t itself. reflect lists the two al

pathKeyInBucket returns a key other than k that an index of that many buckets puts in k's bucket, to test a chain of them.

set is Set, for a struct that may be reached by recursion and so carries the tags still being applied above it and the values being walked on the path

setField fills field from its tag and descends into it. It reports whether an UnmarshalText or UnmarshalJSON took the tag, the field's own or, behind

addTo adds w to x, after every entry above it that x does not hold yet. Each entry below scanDepth adds itself as it is checked, so the entries x lack

benchFill measures filling a zero T. The value is allocated once and reset in place before each Set, so allocs/op counts Set's allocations and not the

benchNestedValues builds depth structs nested by value, each holding the next as its first field. Only the innermost has a default. A []string at ever

benchRepeat measures Set on a value it leaves as it is. The first Set fills ptr, and ready checks that the value is in the state the case measures.

benchTaggedChain builds depth structs linked by pointers tagged `default:"{}"`, ending in a struct whose int has a default. Every level is a type of i

canHoldDefaults reports whether a slice element or map value of type t is of a kind the walk descends into. Such a value has no tag of its own, so des

fillField is setField for a field it does not leave alone: it applies the tag if isInitial, which reports whether the field is zero, and descends into

grow doubles x's room for entries and its buckets, as many of each and a power of two, and chains every entry again from the top down, so that each ch

hasPromotedSetter reports whether the SetDefaults of t, a struct type whose pointer implements Setter, is promoted from an embedded field rather than

repeatsInIndex is repeatsFar's check. It makes the path's index if the walk has none yet, adds to it every entry above w that it does not hold, and th

shouldInitializeField reports whether the field's own state warrants visiting it, regardless of any tag: a struct is always descended into, as is a po

BenchmarkCanUpdate measures the zero check on its own, which is what Set spends per field.

BenchmarkFail measures a Set that fails. The first error is checked, so each case measures the failure it names.

BenchmarkParse applies one tag to one zero field. unparsed_kind is the cost every other row includes: a tagged zero field with nothing parsed and noth

Every case calls b.ReportAllocs. A case that calls Set does its setup and checks the value it measures once before b.ResetTimer, and then does the sam

BenchmarkWalk measures going through a value with little or nothing left to fill. Unless a case says otherwise, it runs Set again on a value the first

This example fills a tree of structs, pointers, slices and maps in one call. Every Endpoint the call reaches gets the same treatment wherever it sits:

SetDefaults derives a default that a tag cannot express, and CanUpdate keeps it from overriding what the caller already provided.

SetDefaults derives Addr from Host and Port, which the tags have filled by the time it is called.

TestCanUpdate covers what "can update" means: the value still holds the zero value of its own type. Note that an allocated-but-empty slice or map is t

TestCanUpdate_FloatEdges pins the two floats where a per-kind zero check and a comparison against the zero value could plausibly disagree: a negative

TestCanUpdate_Nil covers a nil, which carries no type to compare against: there is nothing there to preserve, so it is updatable. It used to panic ins

TestIsPromotedMethod covers where the code behind a method comes from, which reflect reports alike for a method a type declares and one it takes from

TestMustSet_PanicsForNil pins that a nil panics with Set's error. It used to panic too, but from inside Set, before there was an error to panic with.

TestPathIndex_AddHoldsEachKeyOnce covers add's answer, which is the repeat: a key the index holds is not added again.

TestPathIndex_GrowingKeepsEachBucketDeepestFirst covers the chains grow builds again. The deepest key of a bucket heads its chain, so taking it out mo

TestPathIndex_GrowsAndKeepsEveryKey covers growing past the room the index was made with, which a walk does a few hundred values down: every key is st

TestPathIndex_HoldsKeysThatShareABucket covers the chain a bucket holds: keys that hash together are told apart, and taking one out leaves the others

TestPathIndex_PopTakesTheDeepestKeyOut covers pop, which leave calls: the keys join and leave the index as their values do the path, so the one taken

TestSet_ArraysAreLeftAlone pins that reflect.Array has no case in setField, which makes an array behave unlike the slice of the same element type: its

TestSet_ByteSlice covers []byte, where encoding/json accepts two spellings and rejects bare text.

TestSet_CallerPointerToContainerIsSkipped covers a pointer the caller allocated to a slice, a map or a pointer, as a field, a slice element and a map

TestSet_CannotPreserveFalseBool pins the one type whose caller-provided value is indistinguishable from "unset": a bool. An explicit false is overwrit

TestSet_CyclesEnd covers data the caller built with a way back to itself. Where the walk comes back to a value it is still walking, Set goes no furthe

TestSet_CyclesEndAtAnyDepth covers cycles that close far down a long path. Set scans the path for a value near its top, but looks up a value further d

TestSet_DurationAndIntegerShareOneParser pins the outcomes of int64-kinded fields being handed to both time.ParseDuration and strconv.ParseInt: a bare

TestSet_DurationEmptyTagReportsNothing covers `default:""` on an int64-kinded field. Both parsers reject an empty tag, as they reject "1d", but it ask

TestSet_DurationErrorNamesBothParsers covers an int64-kinded tag that neither parser takes. The error carries both rejections, the duration parser's f

TestSet_DurationStringOnANarrowerIntegerIsRejected pins that the duration fallback is int64-only. A narrower width rejects a duration string outright,

TestSet_DurationTagIsTrimmed covers a duration tag carrying surrounding whitespace, which used to leave the field at zero. The trim happens where Pars