func reflect.TypeOf

85 uses

	reflect (current package)
		type.go#L1368: func TypeOf(i interface{}) Type {
		type.go#L2606: 			{Name: "S", Type: TypeOf(structType{})},
		type.go#L2607: 			{Name: "U", Type: TypeOf(uncommonType{})},
		type.go#L2608: 			{Name: "M", Type: ArrayOf(len(methods), TypeOf(methods[0]))},
		value.go#L934: var uint8Type = TypeOf(uint8(0)).(*rtype)

	encoding/asn1
		asn1.go#L656: 	bitStringType        = reflect.TypeOf(BitString{})
		asn1.go#L657: 	objectIdentifierType = reflect.TypeOf(ObjectIdentifier{})
		asn1.go#L658: 	enumeratedType       = reflect.TypeOf(Enumerated(0))
		asn1.go#L659: 	flagType             = reflect.TypeOf(Flag(false))
		asn1.go#L660: 	timeType             = reflect.TypeOf(time.Time{})
		asn1.go#L661: 	rawValueType         = reflect.TypeOf(RawValue{})
		asn1.go#L662: 	rawContentsType      = reflect.TypeOf(RawContent(nil))
		asn1.go#L663: 	bigIntType           = reflect.TypeOf(new(big.Int))
		asn1.go#L1115: 		return nil, &invalidUnmarshalError{reflect.TypeOf(val)}

	encoding/binary
		binary.go#L253: 		return errors.New("binary.Read: invalid type " + reflect.TypeOf(data).String())
		binary.go#L383: 		return errors.New("binary.Write: invalid type " + reflect.TypeOf(data).String())

	encoding/gob
		decode.go#L1158: var emptyStructType = reflect.TypeOf(emptyStruct{})
		decode.go#L1228: 	switch reflect.TypeOf(int(0)).Bits() {
		decode.go#L1242: 	switch reflect.TypeOf(uintptr(0)).Bits() {
		type.go#L106: 	gobEncoderInterfaceType        = reflect.TypeOf((*GobEncoder)(nil)).Elem()
		type.go#L107: 	gobDecoderInterfaceType        = reflect.TypeOf((*GobDecoder)(nil)).Elem()
		type.go#L108: 	binaryMarshalerInterfaceType   = reflect.TypeOf((*encoding.BinaryMarshaler)(nil)).Elem()
		type.go#L109: 	binaryUnmarshalerInterfaceType = reflect.TypeOf((*encoding.BinaryUnmarshaler)(nil)).Elem()
		type.go#L110: 	textMarshalerInterfaceType     = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
		type.go#L111: 	textUnmarshalerInterfaceType   = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		type.go#L259: var tWireType = mustGetTypeInfo(reflect.TypeOf(wireType{})).id
		type.go#L265: 	checkId(17, mustGetTypeInfo(reflect.TypeOf(arrayType{})).id)
		type.go#L266: 	checkId(18, mustGetTypeInfo(reflect.TypeOf(CommonType{})).id)
		type.go#L267: 	checkId(19, mustGetTypeInfo(reflect.TypeOf(sliceType{})).id)
		type.go#L268: 	checkId(20, mustGetTypeInfo(reflect.TypeOf(structType{})).id)
		type.go#L269: 	checkId(21, mustGetTypeInfo(reflect.TypeOf(fieldType{})).id)
		type.go#L270: 	checkId(23, mustGetTypeInfo(reflect.TypeOf(mapType{})).id)
		type.go#L284: 	wireTypeUserInfo = userType(reflect.TypeOf((*wireType)(nil)))
		type.go#L615: 	rt := reflect.TypeOf(e).Elem()
		type.go#L813: 	ut := userType(reflect.TypeOf(value))
		type.go#L819: 	if t, dup := nameToConcreteType.LoadOrStore(name, reflect.TypeOf(value)); dup && t != ut.user {
		type.go#L838: 	rt := reflect.TypeOf(value)

	encoding/json
		decode.go#L173: 		return &InvalidUnmarshalError{reflect.TypeOf(v)}
		decode.go#L599: var textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
		decode.go#L838: 		return nil, &UnmarshalTypeError{Value: "number " + s, Type: reflect.TypeOf(0.0), Offset: int64(d.off)}
		decode.go#L843: var numberType = reflect.TypeOf(Number(""))
		encode.go#L411: 	marshalerType     = reflect.TypeOf((*Marshaler)(nil)).Elem()
		encode.go#L412: 	textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()

	flag
		flag.go#L457: 	typ := reflect.TypeOf(flag.Value)

	fmt
		print.go#L337: 		p.buf.writeString(reflect.TypeOf(p.arg).String())
		print.go#L652: 		p.fmt.fmtS(reflect.TypeOf(arg).String())
		print.go#L1140: 				p.buf.writeString(reflect.TypeOf(arg).String())
		print.go#L1152: 		isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String

	net/http
		client.go#L328: 	if reflect.TypeOf(rt).String() == "*http2.Transport" {
		transfer.go#L422: 	if reflect.TypeOf(t.Body) == nopCloserType {
		transfer.go#L1077: var nopCloserType = reflect.TypeOf(io.NopCloser(nil))
		transfer.go#L1087: 	if reflect.TypeOf(r) == nopCloserType {

	src.elv.sh/pkg/edit/complete
		node_utils.go#L12: 	return reflect.TypeOf(a) == reflect.TypeOf(b)

	src.elv.sh/pkg/eval
		go_fn.go#L57: 	frameType      = reflect.TypeOf((*Frame)(nil))
		go_fn.go#L58: 	rawOptionsType = reflect.TypeOf(RawOptions(nil))
		go_fn.go#L59: 	optionsPtrType = reflect.TypeOf((*optionsPtr)(nil)).Elem()
		go_fn.go#L60: 	inputsType     = reflect.TypeOf(Inputs(nil))
		go_fn.go#L96: 	implType := reflect.TypeOf(impl)
		go_fn.go#L153: var errorType = reflect.TypeOf((*error)(nil)).Elem()

	src.elv.sh/pkg/eval/evaltest
		matchers.go#L99: 	return reflect.TypeOf(e.v) == reflect.TypeOf(e2)

	src.elv.sh/pkg/eval/vals
		equal.go#L86: 	t := reflect.TypeOf(x)
		equal.go#L87: 	if t != reflect.TypeOf(y) {
		has_key.go#L57: 	for _, fieldName := range getStructMapInfo(reflect.TypeOf(m)).fieldNames {
		hash.go#L51: 		it := iterateStructMap(reflect.TypeOf(v))
		index.go#L83: 	it := iterateStructMap(reflect.TypeOf(a))
		iterate_keys.go#L47: 	for _, k := range getStructMapInfo(reflect.TypeOf(v)).fieldNames {
		len.go#L28: 		return getStructMapInfo(reflect.TypeOf(v)).filledFields
		reflect_wrappers.go#L8: 	emptyInterfaceType = reflect.TypeOf(&dummy).Elem()
		reflect_wrappers.go#L27: 	return reflect.TypeOf(i)

	src.elv.sh/pkg/parse
		parser.go#L36: var nodeType = reflect.TypeOf((*Node)(nil)).Elem()
		pprint.go#L30: 	nodeType := reflect.TypeOf((*Node)(nil)).Elem()
		pprint.go#L34: 	nt := reflect.TypeOf(n).Elem()
		pprint.go#L117: 		leading += reflect.TypeOf(n).Elem().Name() + "/"
		pprint.go#L127: 	return fmt.Sprintf("%s %s %d-%d", reflect.TypeOf(n).Elem().Name(),

	src.elv.sh/pkg/rpc
		server.go#L147: var typeOfError = reflect.TypeOf((*error)(nil)).Elem()
		server.go#L232: 	s.typ = reflect.TypeOf(rcvr)

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L254: var bigIntType = reflect.TypeOf((*big.Int)(nil)).Elem()
		asn1.go#L260: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L279: 		if reflect.TypeOf(out).Elem() == bigIntType {
		asn1.go#L606: 	if reflect.TypeOf(out).Kind() != reflect.Ptr {
		asn1.go#L620: 			if reflect.TypeOf(out).Elem() != bigIntType {
		asn1.go#L623: 			if reflect.TypeOf(defaultValue).Kind() != reflect.Ptr ||
		asn1.go#L624: 				reflect.TypeOf(defaultValue).Elem() != bigIntType {