#
6.3 Sequence Protocol

int `PySequence_Check`(PyObject *o)
  Return `1` if the object provides sequence protocol, and `0` otherwise. This function always succeeds.

int `PySequence_Size`(PyObject *o)
  Returns the number of objects in sequence o on success, and `-1` on failure. For objects that do not provide sequence protocol, this is equivalent to the Python expression "`len(o)`".

int `PySequence_Length`(PyObject *o)
  Alternate name for `PySequence_Size()`.

PyObject* `PySequence_Concat`(PyObject *o1, PyObject *o2)
  Return value: New reference.
  Return the concatenation of o1 and o2 on success, and `NULL` on failure. This is the equivalent of the Python expression "`o1 + o2`".

PyObject* `PySequence_Repeat`(PyObject *o, int count)
  Return value: New reference.
  Return the result of repeating sequence object o count times, or `NULL` on failure. This is the equivalent of the Python expression "`o * count`".

PyObject* `PySequence_InPlaceConcat`(PyObject *o1, PyObject *o2)
  Return value: New reference.
  Return the concatenation of o1 and o2 on success, and `NULL` on failure. The operation is done in-place when o1 supports it. This is the equivalent of the Python expression "`o1 += o2`".

PyObject* `PySequence_InPlaceRepeat`(PyObject *o, int count)
  Return value: New reference.
  Return the result of repeating sequence object o count times, or `NULL` on failure. The operation is done in-place when o supports it. This is the equivalent of the Python expression "`o *= count`".

PyObject* `PySequence_GetItem`(PyObject *o, int i)
  Return value: New reference.
  Return the ith element of o, or `NULL` on failure. This is the equivalent of the Python expression "`o[i]`".

PyObject* `PySequence_GetSlice`(PyObject *o, int i1, int i2)
  Return value: New reference.
  Return the slice of sequence object o between i1 and i2, or `NULL` on failure. This is the equivalent of the Python expression "`o[i1:i2]`".

int `PySequence_SetItem`(PyObject *o, int i, PyObject *v)
  Assign object v to the ith element of o. Returns `-1` on failure. This is the equivalent of the Python statement "`o[i] = v`".

int `PySequence_DelItem`(PyObject *o, int i)
  Delete the ith element of object o. Returns `-1` on failure. This is the equivalent of the Python statement "`del o[i]`".

int `PySequence_SetSlice`(PyObject *o, int i1, int i2, PyObject *v)
  Assign the sequence object v to the slice in sequence object o from i1 to i2. This is the equivalent of the Python statement "`o[i1:i2] = v`".

int `PySequence_DelSlice`(PyObject *o, int i1, int i2)
  Delete the slice in sequence object o from i1 to i2. Returns `-1` on failure. This is the equivalent of the Python statement "`del o[i1:i2]`".

PyObject* `PySequence_Tuple`(PyObject *o)
  Return value: New reference.
  Returns the o as a tuple on success, and `NULL` on failure. This is equivalent to the Python expression "`tuple(o)`".

int `PySequence_Count`(PyObject *o, PyObject *value)
  Return the number of occurrences of value in o, that is, return the number of keys for which `o[key] == value`. On failure, return `-1`. This is equivalent to the Python expression "`o.count(value)`".

int `PySequence_Contains`(PyObject *o, PyObject *value)
  Determine if o contains value. If an item in o is equal to value, return `1`, otherwise return `0`. On error, return `-1`. This is equivalent to the Python expression "`value in o`".

int `PySequence_Index`(PyObject *o, PyObject *value)
  Return the first index i for which `o[i] == value`. On error, return `-1`. This is equivalent to the Python expression "`o.index(value)`".

PyObject* `PySequence_List`(PyObject *o)
  Return value: New reference.
  Return a list object with the same contents as the arbitrary sequence o. The returned list is guaranteed to be new.

PyObject* `PySequence_Tuple`(PyObject *o)
  Return value: New reference.
  Return a tuple object with the same contents as the arbitrary sequence o. If o is a tuple, a new reference will be returned, otherwise a tuple will be constructed with the appropriate contents.

PyObject* `PySequence_Fast`(PyObject *o, const char *m)
  Return value: New reference.
  Returns the sequence o as a tuple, unless it is already a tuple or list, in which case o is returned. Use `PySequence_Fast_GET_ITEM()` to access the members of the result. Returns `NULL` on failure. If the object is not a sequence, raises `TypeError` with m as the message text.

PyObject* `PySequence_Fast_GET_ITEM`(PyObject *o, int i)
  Return value: Borrowed reference.
  Return the ith element of o, assuming that o was returned by `PySequence_Fast()`, o is not `NULL`, and that i is within bounds.

int `PySequence_Fast_GET_SIZE`(PyObject *o)
  Returns the length of o, assuming that o was returned by `PySequence_Fast()` and that o is not `NULL`. The size can also be gotten by calling `PySequence_Size()` on o, but `PySequence_Fast_GET_SIZE()` is faster because it can assume o is a list or tuple.