s.insert(i, x) same as s[i:i] = [x]
        Raises TypeError if x isn't a string.
512653
def insert(self, i, x):
        """"""
        if not isinstance(x, str):
            raise TypeError(
                'Members of this object must be strings. '
                'You supplied \"%s\"' % type(x))
        list.insert(self, i, x)
349186
function insertAt(items, item, index) {
  var copy = items.slice();
  copy.splice(index, 0, item);
  return copy;
}
846222
def insert(self, var, value, index=None):
        
        current = self.__get(var)
        if not isinstance(current, list):
            raise KeyError("%s: is not a list" % var)
        if index is None:
            current.append(value)
        else:
            current.insert(index, value)
        if self.auto_save:
            self.save()
999831
function insert(seq, index) { var values, result
        values = slice(arguments, 2)
        result = copy(seq)
        result.splice.apply(result, [index, 0].concat(values))

        return result
    }
408830
public StrBuilder insert(int index, CharSequence csq) {
		if (null == csq) {
			csq = "null";
		}
		int len = csq.length();
		moveDataAfterIndex(index, csq.length());
		if (csq instanceof String) {
			((String) csq).getChars(0, len, this.value, index);
		} else if (csq instanceof StringBuilder) {
			((StringBuilder) csq).getChars(0, len, this.value, index);
		} else if (csq instanceof StringBuffer) {
			((StringBuffer) csq).getChars(0, len, this.value, index);
		} else if (csq instanceof StrBuilder) {
			((StrBuilder) csq).getChars(0, len, this.value, index);
		} else {
			for (int i = 0, j = this.position; i < len; i++, j++) {
				this.value[j] = csq.charAt(i);
			}
		}
		this.position = Math.max(this.position, index) + len;
		return this;
	}
637953
def _insertDateIndex(date, l):
    '''
    
    '''
    return next((i for i, n in enumerate(l) if n[0] < date), len(l))
168269
def p_substr_assignment_no_let(p):
    
    # This can be only a substr assignment like a$(i + 3) = ".", since arrays
    # have ARRAY_ID already
    entry = SYMBOL_TABLE.access_call(p[1], p.lineno(1))
    if entry is None:
        return

    if entry.class_ == CLASS.unknown:
        entry.class_ = CLASS.var

    if p[6].type_ != TYPE.string:
        api.errmsg.syntax_error_expected_string(p.lineno(5), p[6].type_)

    lineno = p.lineno(2)
    base = make_number(OPTIONS.string_base.value, lineno, _TYPE(gl.STR_INDEX_TYPE))
    substr = make_typecast(_TYPE(gl.STR_INDEX_TYPE), p[3], lineno)
    p[0] = make_sentence('LETSUBSTR', entry,
                         make_binary(lineno, 'MINUS', substr, base, func=lambda x, y: x - y),
                         make_binary(lineno, 'MINUS', substr, base, func=lambda x, y: x - y),
                         p[6])
448559
def insert(self, index, item):
        
        if not is_any(item):
            raise MemberTypeError(self, item, member=len(self))
        self._data.insert(index, item)
21759
def equals(self, data):
        

        if isinstance(data, six.string_types):
            return self._add_condition('=', data, types=[int, str])
        elif isinstance(data, list):
            return self._add_condition('IN', ",".join(map(str, data)), types=[str])

        raise QueryTypeError('Expected value of type `str` or `list`, not %s' % type(data))
1095111
function SQL(strs) {
  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    args[_key - 1] = arguments[_key];
  }

  var values = [];
  var text = strs.reduce(function (prev, curr, i) {
    var arg = args[i - 1];
    if (arg instanceof InsertValue) {
      return prev + arg.value + curr;
    } else {
      values.push(arg);
      return prev + '$' + values.length + curr;
    }
  });

  return {
    text: text,
    values: values
  };
}
1221893
@SuppressWarnings("unchecked")
	public static <T> Object insert(Object array, int index, T... newElements) {
		if (isEmpty(newElements)) {
			return array;
		}
		if(isEmpty(array)) {
			return newElements;
		}
		
		final int len = length(array);
		if (index < 0) {
			index = (index % len) + len;
		}
		
		final T[] result = newArray(array.getClass().getComponentType(), Math.max(len, index) + newElements.length);
		System.arraycopy(array, 0, result, 0, Math.min(len, index));
		System.arraycopy(newElements, 0, result, index, newElements.length);
		if (index < len) {
			System.arraycopy(array, index, result, index + newElements.length, len - index);
		}
		return result;
	}
1017539
def InsertArg(self, string='', **unused_kwargs):
    """"""
    logging.debug('Storing Argument {0:s}'.format(string))

    # This expression is complete
    if self.current_expression.AddArg(string):
      self.stack.append(self.current_expression)
      self.current_expression = self.expression_cls()
      return self.PopState()
    return None
183248
def _type_insert(self, handle, key, value):
    '''
    
    '''
    if value!=0:
      if isinstance(value,float):
        handle.incrbyfloat(key, value)
      else:
        handle.incr(key,value)
217065
function insert (getValue, item, list) {
    var index = binaryIndexBy(getValue, getValue(item), list);

    list.splice(index, 0, item);
    return item;
  }
797987
def perform_import(val):
    
    if val is None:
        return None
    elif isinstance(val, str):
        return import_from_string(val)
    elif isinstance(val, (list, tuple)):
        return [import_from_string(item) for item in val]
    return val
1081622
function insert (table, columns, values) {
    if (this.typecheck) t.typecheck('insert', [table, columns, values]);
    if ('string'===typeof columns) columns = [columns];
    if ('string'===typeof values) values = [values];

    var get = function get (values) {
        var result = [];
        for (var i=0; i < values.length; i++) {
            var value = values[i];
            if ('string'===typeof value
                // X\'blob\' \'\\xblob\'
                && value.indexOf("X\'") != 0 && value.indexOf("\'\\x") != 0)
                value = this.string(value);
            if (value===null) value = 'null';
            result.push(value);
        }
        return result;
    }.bind(this);

    var result = [];
    if (values[0] instanceof Array) {
        for (var i=0; i < values.length; i++) {
            var val = get(values[i]);
            result.push('('+val.join()+')');
        }
    }
    else {
        var val = get(values);
        result.push('('+val.join()+')');
    }

    return ['insert','into',table,'('+columns.join()+')','values',result.join()].join(' ');
}
110877
function strSplice(str, index, count, add) {
  return str.slice(0, index) + add + str.slice(index + count);
}