// used to implement (set v 10)
19805
func (scope *Scope) UpdateSymbolInScope(sym *SexpSymbol, expr Sexp) error {

	_, found := scope.Map[sym.number]
	if !found {
		return fmt.Errorf("symbol `%s` not found", sym.name)
	}
	scope.Map[sym.number] = expr
	return nil
}
353498
func (i *Uint) Set(value uint) {
	i.lock.Lock()
	defer i.lock.Unlock()
	i.increment = value
}
287380
func NewVersionSet(apiVersions ...string) VersionSet {
	vs := VersionSet{}
	for _, v := range apiVersions {
		vs[v] = struct{}{}
	}
	return vs
}
673034
func (fds *FDSet) Set(fd uintptr) {
	fds.X__fds_bits[fd/NFDBITS] |= (1 << (fd % NFDBITS))
}
1232814
func (m *symbol) set(x int, y int, v bool) {
	m.module[y+m.quietZoneSize][x+m.quietZoneSize] = v
	m.isUsed[y+m.quietZoneSize][x+m.quietZoneSize] = true
}
325050
func (i *injector) Set(typ reflect.Type, val reflect.Value) TypeMapper {
	i.values[typ] = val
	return i
}
1301299
func (kv *KeyValSlice) Set(v string) error {
	if len(*kv) == 0 {
		*kv = make([]map[string]string, 0)
	}
	var i KeyVal
	if err := i.Set(v); err != nil {
		return trace.Wrap(err)
	}
	*kv = append(*kv, i)
	return nil
}
823154
func Set(value reflect.Value, v interface{}, seps ...rune) error {
	if !value.CanSet() {
		return errCannotSet
	}

	if s, ok := v.(string); ok {
		return UnmarshalValue(value, s, seps...)
	}

	val := reflect.ValueOf(v)
	if value.Kind() != val.Kind() {
		// The value was converted.
		v, err := convert(val, value)
		if err != nil {
			return err
		}
		val = v
	}
	value.Set(val)
	return nil
}
1371907
func (l *ShardedNoTS) Set(tenantID, key string, val interface{}) error {
	_, ok := l.cache[tenantID]
	if !ok {
		l.cache[tenantID] = l.constructor()
		l.itemCount[tenantID] = 0
	}

	l.itemCount[tenantID]++
	return l.cache[tenantID].Set(key, val)
}
1316713
func (vn *VecN) Set(i int, val float64) {
	vn.vec[i] = val
}
4999
func (sv *SyncVal) Set(val interface{}) {
	sv.lock.Lock()
	sv.val = val
	sv.lock.Unlock()
}
1101496
func (state *Runtime) Set(name string, val interface{}) {
	state.setValue(name, reflect.ValueOf(val))
}
812740
func Set(v interface{}, err error) (map[interface{}]bool, error) {
	if err != nil {
		return nil, err
	}

	vd, ok := v.(map[interface{}]bool)
	if ok {
		return vd, nil
	}

	return nil, newWrongTypeError(v, vd)
}
67754
func set(dst, src reflect.Value) error {
	dstType, srcType := dst.Type(), src.Type()
	switch {
	case dstType.Kind() == reflect.Interface && dst.Elem().IsValid():
		return set(dst.Elem(), src)
	case dstType.Kind() == reflect.Ptr && dstType.Elem() != derefbigT:
		return set(dst.Elem(), src)
	case srcType.AssignableTo(dstType) && dst.CanSet():
		dst.Set(src)
	case dstType.Kind() == reflect.Slice && srcType.Kind() == reflect.Slice:
		return setSlice(dst, src)
	default:
		return fmt.Errorf("abi: cannot unmarshal %v in to %v", src.Type(), dst.Type())
	}
	return nil
}
574089
func (me *TxsdPlatformTypeChoiceIlluminaSequenceInstrumentModel) Set(s string) {
	(*xsdt.String)(me).Set(s)
}
332785
func (r *Ring) set(p int, v interface{}) {
	r.buff[r.mod(p)] = v
}
331826
func NewVarSet(vs ...Var) VarSet {
	s := VarSet{}
	for _, v := range vs {
		s.Add(v)
	}
	return s
}