A collection that supports subscript assignment.


protocol MutableCollection where Self.SubSequence : MutableCollection


Collections that conform to MutableCollection gain the ability to change the value of their elements. This example shows how you can modify one of the names in an array of students.

var students = ["Ben", "Ivy", "Jordell", "Maxime"]
if let i = students.firstIndex(of: "Maxime") {
    students[i] = "Max"
// Prints "["Ben", "Ivy", "Jordell", "Max"]"

In addition to changing the value of an individual element, you can also change the values of a slice of elements in a mutable collection. For example, you can sort part of a mutable collection by calling the mutable sort() method on a subscripted subsequence. Here’s an example that sorts the first half of an array of integers:

var numbers = [15, 40, 10, 30, 60, 25, 5, 100]
// Prints "[10, 15, 30, 40, 60, 25, 5, 100]"

The MutableCollection protocol allows changing the values of a collection’s elements but not the length of the collection itself. For operations that require adding or removing elements, see the RangeReplaceableCollection protocol instead.

Conforming to the MutableCollection Protocol

To add conformance to the MutableCollection protocol to your own custom collection, upgrade your type’s subscript to support both read and write access.

A value stored into a subscript of a MutableCollection instance must subsequently be accessible at that same position. That is, for a mutable collection instance a, index i, and value x, the two sets of assignments in the following code sample must be equivalent:

a[i] = x
let y = a[i]

// Must be equivalent to:
a[i] = x
let y = x


Instance Methods

func partition(by: (Self.Element) -> Bool) -> Self.Index

Reorders the elements of the collection such that all the elements that match the given predicate are after all the elements that don’t match.

Required. Default implementations provided.

func reverse()

Reverses the elements of the collection in place.

func shuffle()

Shuffles the collection in place.

func shuffle<T>(using: inout T)

Shuffles the collection in place, using the given generator as a source for randomness.

func sort()

Sorts the collection in place.

func sort(by: (Self.Element, Self.Element) -> Bool)

Sorts the collection in place, using the given predicate as the comparison between elements.

func swapAt(Self.Index, Self.Index)

Exchanges the values at the specified indices of the collection.

Required. Default implementation provided.

func withContiguousMutableStorageIfAvailable<R>((inout UnsafeMutableBufferPointer<Self.Element>) -> R) -> R?

Call body(p), where p is a pointer to the collection’s mutable contiguous storage. If no such storage exists, it is first created. If the collection does not support an internal representation in a form of mutable contiguous storage, body is not called and nil is returned.

Required. Default implementation provided.


subscript(Self.Index) -> Self.Element

Accesses the element at the specified position.

Required. Default implementations provided.

subscript(Range<Self.Index>) -> Self.SubSequence

Accesses a contiguous subrange of the collection’s elements.


See Also

Collection Mutability

protocol RangeReplaceableCollection

A collection that supports replacement of an arbitrary subrange of elements with the elements of another collection.