View Source array (stdlib v6.0)

Functional, extendible arrays.

Arrays can have fixed size, or can grow automatically as needed. A default value is used for entries that have not been explicitly set.

Arrays uses zero-based indexing. This is a deliberate design choice and differs from other Erlang data structures, for example, tuples.

Unless specified by the user when the array is created, the default value is the atom undefined. There is no difference between an unset entry and an entry that has been explicitly set to the same value as the default one (compare reset/2). If you need to differentiate between unset and set entries, ensure that the default value cannot be confused with the values of set entries.

The array never shrinks automatically. If an index I has been used to set an entry successfully, all indices in the range [0,I] stay accessible unless the array size is explicitly changed by calling resize/2.

Examples:

Create a fixed-size array with entries 0-9 set to undefined:

A0 = array:new(10).
10 = array:size(A0).

Create an extendible array and set entry 17 to true, causing the array to grow automatically:

A1 = array:set(17, true, array:new()).
18 = array:size(A1).

Read back a stored value:

true = array:get(17, A1).

Accessing an unset entry returns default value:

undefined = array:get(3, A1)

Accessing an entry beyond the last set entry also returns the default value, if the array does not have fixed size:

undefined = array:get(18, A1).

"Sparse" functions ignore default-valued entries:

A2 = array:set(4, false, A1).
[{4, false}, {17, true}] = array:sparse_to_orddict(A2).

An extendible array can be made fixed-size later:

A3 = array:fix(A2).

A fixed-size array does not grow automatically and does not allow accesses beyond the last set entry:

{'EXIT',{badarg,_}} = (catch array:set(18, true, A3)).
{'EXIT',{badarg,_}} = (catch array:get(18, A3)).

Summary

Types

array()

array(Type)

A functional, extendible array. The representation is not documented and is subject to change without notice. Notice that arrays cannot be directly compared for equality.

array_indx()

array_opt()

array_opts()

indx_pair(Type)

indx_pairs(Type)

Functions

default(Array)

Gets the value used for uninitialized entries.

fix(Array)

Fixes the array size. This prevents it from growing automatically upon insertion.

foldl(Function, InitialAcc, Array)

Folds the array elements using the specified function and initial accumulator value. The elements are visited in order from the lowest index to the highest.

foldr(Function, InitialAcc, Array)

Folds the array elements right-to-left using the specified function and initial accumulator value. The elements are visited in order from the highest index to the lowest.

from_list(List)

Equivalent to from_list(List, undefined).

from_list(List, Default)

Converts a list to an extendible array. Default is used as the value for uninitialized entries of the array.

from_orddict(Orddict)

Equivalent to from_orddict(Orddict, undefined).

from_orddict(Orddict, Default)

Converts an ordered list of pairs {Index, Value} to a corresponding extendible array. Default is used as the value for uninitialized entries of the array.

get(I, Array)

Gets the value of entry I.

is_array(X)

Returns true if X is an array, otherwise false.

is_fix(Array)

Checks if the array has fixed size. Returns true if the array is fixed, otherwise false.

map(Function, Array)

Maps the specified function onto each array element. The elements are visited in order from the lowest index to the highest.

new()

Creates a new, extendible array with initial size zero.

new(Options)

Creates a new array according to the specified options. By default, the array is extendible and has initial size zero. Array indices start at 0.

new(Size, Options)

Creates a new array according to the specified size and options.

relax(Array)

Makes the array resizable. (Reverses the effects of fix/1.)

reset(I, Array)

Resets entry I to the default value for the array. If the value of entry I is the default value, the array is returned unchanged.

resize(Array)

Changes the array size to that reported by sparse_size/1. If the specified array has fixed size, also the resulting array has fixed size.

resize(Size, Array)

Change the array size.

set(I, Value, Array)

Sets entry I of the array to Value.

size(Array)

Gets the number of entries in the array. Entries are numbered from 0 to size(Array)-1. Hence, this is also the index of the first entry that is guaranteed to not have been previously set.

sparse_foldl(Function, InitialAcc, Array)

Folds the array elements using the specified function and initial accumulator value, skipping default-valued entries. The elements are visited in order from the lowest index to the highest.

sparse_foldr(Function, InitialAcc, Array)

Folds the array elements right-to-left using the specified function and initial accumulator value, skipping default-valued entries. The elements are visited in order from the highest index to the lowest.

sparse_map(Function, Array)

Maps the specified function onto each array element, skipping default-valued entries. The elements are visited in order from the lowest index to the highest.

sparse_size(Array)

Gets the number of entries in the array up until the last non-default-valued entry. That is, returns I+1 if I is the last non-default-valued entry in the array, or zero if no such entry exists.

sparse_to_list(Array)

Converts the array to a list, skipping default-valued entries.

sparse_to_orddict(Array)

Converts the array to an ordered list of pairs {Index, Value}, skipping default-valued entries.

to_list(Array)

Converts the array to a list.

to_orddict(Array)

Converts the array to an ordered list of pairs {Index, Value}.

Types

array()

-type array() :: array(term()).

array(Type)

-opaque array(Type)

A functional, extendible array. The representation is not documented and is subject to change without notice. Notice that arrays cannot be directly compared for equality.

array_indx()

(not exported)

-type array_indx() :: non_neg_integer().

array_opt()

(not exported)

-type array_opt() ::
    {fixed, boolean()} |
    fixed |
    {default, Type :: term()} |
    {size, N :: non_neg_integer()} |
    (N :: non_neg_integer()).

array_opts()

(not exported)

-type array_opts() :: array_opt() | [array_opt()].

indx_pair(Type)

(not exported)

-type indx_pair(Type) :: {Index :: array_indx(), Type}.

indx_pairs(Type)

(not exported)

-type indx_pairs(Type) :: [indx_pair(Type)].

Functions

default(Array)

-spec default(Array :: array(Type)) -> Value :: Type.

Gets the value used for uninitialized entries.

fix(Array)

-spec fix(Array :: array(Type)) -> array(Type).

Fixes the array size. This prevents it from growing automatically upon insertion.

foldl(Function, InitialAcc, Array)

-spec foldl(Function, InitialAcc :: A, Array :: array(Type)) -> B
         when Function :: fun((Index :: array_indx(), Value :: Type, Acc :: A) -> B).

Folds the array elements using the specified function and initial accumulator value. The elements are visited in order from the lowest index to the highest.

If Function is not a function, the call fails with reason badarg.

See also foldr/3, map/2, sparse_foldl/3.

foldr(Function, InitialAcc, Array)

-spec foldr(Function, InitialAcc :: A, Array :: array(Type)) -> B
         when Function :: fun((Index :: array_indx(), Value :: Type, Acc :: A) -> B).

Folds the array elements right-to-left using the specified function and initial accumulator value. The elements are visited in order from the highest index to the lowest.

If Function is not a function, the call fails with reason badarg.

from_list(List)

-spec from_list(List :: [Value :: Type]) -> array(Type).

Equivalent to from_list(List, undefined).

from_list(List, Default)

-spec from_list(List :: [Value :: Type], Default :: term()) -> array(Type).

Converts a list to an extendible array. Default is used as the value for uninitialized entries of the array.

If List is not a proper list, the call fails with reason badarg.

from_orddict(Orddict)

-spec from_orddict(Orddict :: indx_pairs(Value :: Type)) -> array(Type).

Equivalent to from_orddict(Orddict, undefined).

from_orddict(Orddict, Default)

-spec from_orddict(Orddict :: indx_pairs(Value :: Type), Default :: Type) -> array(Type).

Converts an ordered list of pairs {Index, Value} to a corresponding extendible array. Default is used as the value for uninitialized entries of the array.

If Orddict is not a proper, ordered list of pairs whose first elements are non-negative integers, the call fails with reason badarg.

get(I, Array)

-spec get(I :: array_indx(), Array :: array(Type)) -> Value :: Type.

Gets the value of entry I.

If I is not a non-negative integer, or if the array has fixed size and I is larger than the maximum index, the call fails with reason badarg.

If the array does not have fixed size, the default value for any index I greater than size(Array)-1 is returned.

is_array(X)

-spec is_array(X :: term()) -> boolean().

Returns true if X is an array, otherwise false.

Notice that the check is only shallow, as there is no guarantee that X is a well-formed array representation even if this function returns true.

is_fix(Array)

-spec is_fix(Array :: array()) -> boolean().

Checks if the array has fixed size. Returns true if the array is fixed, otherwise false.

map(Function, Array)

-spec map(Function, Array :: array(Type1)) -> array(Type2)
       when Function :: fun((Index :: array_indx(), Type1) -> Type2).

Maps the specified function onto each array element. The elements are visited in order from the lowest index to the highest.

If Function is not a function, the call fails with reason badarg.

See also foldl/3, foldr/3, sparse_map/2.

new()

-spec new() -> array().

Creates a new, extendible array with initial size zero.

new(Options)

-spec new(Options :: array_opts()) -> array().

Creates a new array according to the specified options. By default, the array is extendible and has initial size zero. Array indices start at 0.

Options is a single term or a list of terms, selected from the following:

N::integer() >= 0 or {size, N::integer() >= 0} - Specifies the initial array size; this also implies {fixed, true}. If N is not a non-negative integer, the call fails with reason badarg.
fixed or {fixed, true} - Creates a fixed-size array. See also fix/1.
{fixed, false} - Creates an extendible (non-fixed-size) array.
{default, Value} - Sets the default value for the array to Value.

Options are processed in the order they occur in the list, that is, later options have higher precedence.

The default value is used as the value of uninitialized entries, and cannot be changed once the array has been created.

Examples:

array:new(100)

creates a fixed-size array of size 100.

array:new({default,0})

creates an empty, extendible array whose default value is 0.

array:new([{size,10},{fixed,false},{default,-1}])

creates an extendible array with initial size 10 whose default value is -1.

new(Size, Options)

-spec new(Size :: non_neg_integer(), Options :: array_opts()) -> array().

Creates a new array according to the specified size and options.

If Size is not a non-negative integer, the call fails with reason badarg. By default, the array has fixed size. Notice that any size specifications in Options override parameter Size.

If Options is a list, this is equivalent to new([{size, Size} | Options]), otherwise it is equivalent to new([{size, Size} | [Options]]). However, using this function directly is more efficient.

Example:

array:new(100, {default,0})

creates a fixed-size array of size 100, whose default value is 0.

relax(Array)

-spec relax(Array :: array(Type)) -> array(Type).

Makes the array resizable. (Reverses the effects of fix/1.)

reset(I, Array)

-spec reset(I :: array_indx(), Array :: array(Type)) -> array(Type).

Resets entry I to the default value for the array. If the value of entry I is the default value, the array is returned unchanged.

Reset never changes the array size. Shrinking can be done explicitly by calling resize/2.

If I is not a non-negative integer, or if the array has fixed size and I is larger than the maximum index, the call fails with reason badarg; compare set/3

resize(Array)

-spec resize(Array :: array(Type)) -> array(Type).

Changes the array size to that reported by sparse_size/1. If the specified array has fixed size, also the resulting array has fixed size.

resize(Size, Array)

-spec resize(Size :: non_neg_integer(), Array :: array(Type)) -> array(Type).

Change the array size.

If Size is not a non-negative integer, the call fails with reason badarg. If the specified array has fixed size, also the resulting array has fixed size.

set(I, Value, Array)

-spec set(I :: array_indx(), Value :: Type, Array :: array(Type)) -> array(Type).

Sets entry I of the array to Value.

If I is not a non-negative integer, or if the array has fixed size and I is larger than the maximum index, the call fails with reason badarg.

If the array does not have fixed size, and I is greater than size(Array)-1, the array grows to size I+1.

size(Array)

-spec size(Array :: array()) -> non_neg_integer().

Gets the number of entries in the array. Entries are numbered from 0 to size(Array)-1. Hence, this is also the index of the first entry that is guaranteed to not have been previously set.

sparse_foldl(Function, InitialAcc, Array)

-spec sparse_foldl(Function, InitialAcc :: A, Array :: array(Type)) -> B
                when Function :: fun((Index :: array_indx(), Value :: Type, Acc :: A) -> B).

Folds the array elements using the specified function and initial accumulator value, skipping default-valued entries. The elements are visited in order from the lowest index to the highest.

If Function is not a function, the call fails with reason badarg.

sparse_foldr(Function, InitialAcc, Array)

-spec sparse_foldr(Function, InitialAcc :: A, Array :: array(Type)) -> B
                when Function :: fun((Index :: array_indx(), Value :: Type, Acc :: A) -> B).

If Function is not a function, the call fails with reason badarg.

sparse_map(Function, Array)

-spec sparse_map(Function, Array :: array(Type1)) -> array(Type2)
              when Function :: fun((Index :: array_indx(), Type1) -> Type2).

Maps the specified function onto each array element, skipping default-valued entries. The elements are visited in order from the lowest index to the highest.

If Function is not a function, the call fails with reason badarg.

sparse_size(Array)

-spec sparse_size(Array :: array()) -> non_neg_integer().

Gets the number of entries in the array up until the last non-default-valued entry. That is, returns I+1 if I is the last non-default-valued entry in the array, or zero if no such entry exists.

sparse_to_list(Array)

-spec sparse_to_list(Array :: array(Type)) -> [Value :: Type].

Converts the array to a list, skipping default-valued entries.

sparse_to_orddict(Array)

-spec sparse_to_orddict(Array :: array(Type)) -> indx_pairs(Value :: Type).

Converts the array to an ordered list of pairs {Index, Value}, skipping default-valued entries.

to_list(Array)

-spec to_list(Array :: array(Type)) -> [Value :: Type].

Converts the array to a list.

to_orddict(Array)

-spec to_orddict(Array :: array(Type)) -> indx_pairs(Value :: Type).

Converts the array to an ordered list of pairs {Index, Value}.