Collections: Difference between revisions

=={{header|11l}}==

11l supports arrays, tuples, dictionaries, sets, and double-ended queues as built-in collection types. See http://11l-lang.org/doc/built-in-types for further details.

 

=={{header|ABAP}}==

 

REPORT z_test_rosetta_collection.

 

START-OF-SELECTION.

NEW lcl_collection( )->start( ).

 

=={{header|Ada}}==

Anonymous arrays have no type associated with them that is accessible to the programmer. This means that anonymous arrays cannot be compared in the aggregate to other arrays (even those with the same index structure and contained type) or passed as a parameter to a subprogram. For these reasons, anonymous arrays are best used as singletons and global constants.

 

 

A : array (-3 .. -1) of Integer := (1, 2, 3);

A (-1) := 1;

 

===array types===

Because of the limitations of anonymous arrays noted above, arrays are more typically defined in Ada as array types, as in the example below.

 

 

type Array_Type is array (1 .. 3) of Integer;

A (3) := 1;

 

===unconstrained arrays===

Dynamic arrays can be created through the use of pointers to unconstrained arrays. While an unconstrained array's index type is defined, it does not have a pre-defined range of indices - they are specified at the time of declaration or, as would be the case in a dynamic array, at the time the memory for the array is allocated. The creation of a dynamic array is not shown here, but below is an example declaration of an unconstrained array in Ada.

 

 

type Array_Type is array (positive range <>) of Integer; -- may be indexed with any positive

A (3) := 1;

 

===doubly linked lists===

{{libheader|Ada.Containers.Doubly_Linked_Lists}}

 

use Ada.Containers;

 

DL_List.Append (3);

 

===vectors===

{{libheader|Ada.Containers.Vectors}}

 

use Ada.Containers;

 

V.Append (3);

 

=={{header|Aime}}==

===Lists===

Declaring a list:

Adding values to it:

l_push(l, "a string");

Retrieving values from a list:

l_head(l)

l_q_text(l, 1)

 

===Records===

Declaring a record:

Adding values to it:

r_put(r, "key2", "a string");

Retrieving values from a record:

r_tail(r)

 

=={{header|ALGOL 68}}==

Arrays are the closest thing to collections available as standard in Algol 68. Collections could be implemented using STRUCTs but there are none as standard. Some examples of arrays:

[]INT constant array = ( 1, 2, 3, 4 );

# create an array of integers that can be changed, note the size mst be specified #

# replace it with a new array of 5 elements #

fa := LOC[ -2 : 2 ]INT;

 

=={{header|Apex}}==

A list is an ordered collection of elements that are distinguished by their indices

Creating Lists

// Create an empty list of String

List<String> my_list = new List<String>();

// Create a nested list

List<List<Set<Integer>>> my_list_2 = new List<List<Set<Integer>>>();

Access elements in a list

List<Integer> myList = new List<Integer>(); // Define a new list

myList.add(47); // Adds a second element of value 47 to the end

myList.set(0, 1); // Adds the integer 1 to the list at index 0

myList.clear(); // Removes all elements from the list

Using Array Notation for One-dimensional list

String[] colors = new List<String>();

List<String> colors = new String[1];

colors[0] = 'Green';

 

===Sets===

A set is an unordered collection of elements that do not contain any duplicates.

Defining a set:

Set<String> s1 = new Set<String>{'a', 'b + c'}; // Defines a new set with two elements

Set<String> s2 = new Set<String>(s1); // Defines a new set that contains the

// elements of the set created in the previous step

Access elements in a set:

Set<Integer> s = new Set<Integer>(); // Define a new set

s.add(1); // Add an element to the set

System.assert(s.contains(1)); // Assert that the set contains an element

s.remove(1); // Remove the element from the set

Note the following limitations on sets:

* Unlike Java, Apex developers do not need to reference the algorithm that is used to implement a set in their declarations (for example, HashSet or TreeSet). Apex uses a hash structure for all sets.

A map is a collection of key-value pairs where each unique key maps to a single value

Declaring a map:

Map<String, String> country_currencies = new Map<String, String>();

Map<ID, Set<String>> m = new Map<ID, Set<String>>();

Map<String, String> MyStrings = new Map<String, String>{'a' => 'b', 'c' => 'd'.toUpperCase()};

Accessing a Map:

Map<Integer, String> m = new Map<Integer, String>(); // Define a new map

m.put(1, 'First entry'); // Insert a new key-value pair in the map

System.assertEquals('Second entry', value);

Set<Integer> s = m.keySet(); // Return a set that contains all of the keys in the map

Map Considerations:

* Unlike Java, Apex developers do not need to reference the algorithm that is used to implement a map in their declarations (for example, HashMap or TreeMap). Apex uses a hash structure for all maps.

===Array===

 

arr: ["one" 2 "three" "four"]

 

; print it

 

{{out}}

===Dictionary===

 

dict: #[

name: "john"

; print it

 

{{out}}

{{works with|AutoHotkey_L}}

[http://l.autohotkey.net/docs/Objects.htm Documentation]

mycol.mykey := "my value!"

mycol["mykey"] := "new val!"

 

===Pseudo-arrays===

Documentation: http://www.autohotkey.com/docs/misc/Arrays.htm

array%A_Index% := A_Index * 9

===Structs===

Structs are not natively supported in AutoHotkey, however they are often required in DllCalls to C++ Dlls.

This shows how to retrieve values from a RECT structure in AutoHotkey (from the DllCall documentation at http://www.autohotkey.com/docs/commands/DllCall.htm)

DllCall("GetWindowRect", UInt, WinExist(), UInt, &Rect) ; WinExist() returns an HWND.

MsgBox % "Left " . NumGet(Rect, 0, true) . " Top " . NumGet(Rect, 4, true)

 

=={{header|AWK}}==

In awk, the closest thing to collections would be arrays. They are created when needed at assignment

or by splitting a string

Single elements are accessible with the bracket notation, like in C:

One can iterate over the elements of an array:

 

=={{header|Axe}}==

2→{L₁+1}

3→{L₁+2}

Disp {L₁+1}►Dec,i

Disp {L₁+2}►Dec,i

 

=={{header|BBC BASIC}}==

===Arrays===

In BBC BASIC the only native type of 'collection' is the array; the index starts at zero and the subscript specified in the DIM is the highest value of the index. Hence in this example an array with two elements is defined:

text$(0) = "Hello "

===Arrays of structures===

{{works with|BBC BASIC for Windows}}

When the objects in the collection are not simple scalar types an array of structures may be used:

collection{(0)}.name$ = "Richard"

collection{(0)}.year% = 1952

collection{(1)}.name$ = "Sue"

===Linked lists===

Although not a native language feature, other types of collections such as linked lists may be constructed:

list% = 0

PROCadd(list%, node{}, "Richard", 1952)

l% = c.link%

ENDWHILE

 

=={{header|bc}}==

One thing in C language proper that can be said to be a collection is array type.

An array has a length known at compile time.

int ar[10]; /* Collection<Integer> ar = new ArrayList<Integer>(10); */

ar[0] = 1; /* ar.set(0, 1); */

p++) { /* pValue=p.next() ) { */

printf("%d\n",*p); /* System.out.println(pValue); */

Please note that c built-in pointer-arithmetic support which helps this logic. An integer may be 4 bytes, and a char 1 byte: the plus operator (+) is overloaded to multiply a incement by 4 for integer pointers and by 1 for char pointers (etc).

 

Another construct which can be seen as a collection is a malloced array. The size of a malloced array is not known at compile time.

int* ar; /* Collection<Integer> ar; */

int arSize;

p++) { /* pValue=p.next() ) { */

printf("%d\n",*p); /* System.out.println(pValue); */

 

A string is another C language construct (when looked at with its standard libraries) that behaves like a collection.

 

===Arrays===

// Creates and initializes a new integer Array

int[] intArray = new int[5] { 1, 2, 3, 4, 5 };

string[] stringArr = new string[5];

stringArr[0] = "string";

 

===ArrayList and List===

The size of ArrayList is dynamically increased as required. ArrayLists are zero-based.

//Create and initialize ArrayList

ArrayList myAl = new ArrayList { "Hello", "World", "!" };

myAL.Add("!");

 

 

The List class is the generic equivalent of the ArrayList class.

A List is a strongly typed list of objects that can be accessed by index ( zero-based again).

//Create and initialize List

List<string> myList = new List<string> { "Hello", "World", "!" };

myList2.Add("World");

myList2.Add("!");

 

===Hashtable and Dictionary===

Hashtables represent a collection of key/value pairs that are organized based on the hash code of the key.

Keys must be unique.

//Create an initialize Hashtable

Hashtable myHt = new Hashtable() { { "Hello", "World" }, { "Key", "Value" } };

myHt2.Add("Hello", "World");

myHt2.Add("Key", "Value");

Dictionary is a generic class.It represents a collection of key/value pairs. Keys must be unique.

//Create an initialize Dictionary

Dictionary<string, string> dict = new Dictionary<string, string>() { { "Hello", "World" }, { "Key", "Value" } };

dict2.Add("Hello", "World");

dict2.Add("Key", "Value");

 

=={{header|C++}}==

The simplest collection in C++ is the built-in array. Built-in arrays have a fixed size, and except for POD types (i.e. basically any type you culd also write in C), the members are all initialized at array creation time (if no explicit initialization is done, the default constructr is used).

 

a[0] = 1; // indexes start at 0

 

#include <string>

std::string strings[4]; // std::string is no POD, therefore all array members are default-initialized

 

===vector===

A vector is basically a resizable array. It is optimized for adding/removing elements on the end, and fast access to elements anywhere. Inserting elements at the beginning or in the middle is possible, but in general inefficient.

 

 

std::vector<int> v; // empty vector

v.push_back(5); // insert a 5 at the end

 

===deque===

A deque is optimized for appending and removing elements on both ends ofd the array. Accessing random elements is still efficient, but slightly less than with vector.

 

 

std::deque<int> d; // empty deque

d.push_back(5); // insert a 5 at the end

d.push_front(7); // insert a 7 at the beginning

 

===list===

A list is optimized for insertion at an arbitrary place (provided you already have an iterator pointing to that place). Element access is efficient only in linear order.

 

 

std::list<int> l; // empty list

std::list::iterator i = l.begin();

++l;

 

===set===

A set keeps the inserted elements sorted, and also makes sure that each element occurs only once. Of course, if you want to put something into a set, it must be less-than-comparable, i.e. you must be able to compare which of two objects <tt>a</tt> and <tt>b</tt> is smaller using <tt>a<b</tt> (there's also a way to define sets with an user-defined order, in which case this restriction doesn't apply).

 

 

std::set<int> s; // empty set

s.insert(5); // insert a 5

s.insert(7); // insert a 7 (automatically placed after the 5)

 

===multiset===

A multiset is like a set, except the same element may occur multiple times.

 

 

std::multiset<int> m; // empty multiset

m.insert(5); // insert a 5

m.insert(7); // insert a 7 (automatically placed after the 5)

 

=={{header|Clojure}}==

 

===Hash maps===

(hash-map 1 "a" "Q" 10) ; equivalent to the above

(let [my-map {1 "a"}]

===Lists===

(list 1 4 7)

 

===Vectors===

(vector 'a 4 11)

 

===Sets===

(assoc #{:pig :bear} :dog)

 

=={{header|COBOL}}==

 

{{works with|GnuCOBOL}}

program-id. collections.

 

 

goback.

 

{{out}}

====hashing====

 

(hash-table (make-hash-table)))

(push 1 list)

(3 2 1)

[list]

 

====deque====

In Lisp, a deque can be represented using two list variables which are understood to be opposite to each other. That is to say, the list links (cons cell cdr pointers) go inward into the deque from both ends. For instance the deque (1 2 3 4 5 6) can be represented using (1 2 3) and (6 5 4). Then, it is easy to push items on either end using ordinary list push operations. Popping is also simple, except when the case occurs that either piece runs out of items. A Lisp macro can be provided which takes care of this situation. The implementation below handles the underflow in one deque piece by transferring about one half of the elements from the opposite piece. This keeps the amortized cost for pushes and pops O(1), and prevents the degenerate behavior of bouncing all the elements from one side to the other when pops are requested which alternate between the two ends of the deque.

 

;;; Obtained from Usenet,

;;; Message-ID: <b3b1cc90-2e2b-43c3-b7d9-785ae29870e7@e23g2000prf.googlegroups.com>

,other-piece ,new-other)

,result)))

 

Demo:

 

D has static arrays.

array[0] = 5;

 

D has dynamic arrays.

array ~= 5; // append 5

array.length = 3;

array[3] = 17; // runtime error: out of bounds. check removed in release mode.

array = [2, 17, 3];

 

D has associative arrays.

// array ~= 5; // it doesn't work that way!

array[5] = 17;

writefln(array.keys, " -> ", array.values);

assert(5 in array); // returns a pointer, by the way

=={{header|Delphi}}==

 

===Arrays===

Arrays are collection of values with memory self managed, can be static (size fixed and index not need start in zero) or dynamic (size scaled by user in run time and away start index in zero).

// Creates and initializes a new integer Array

var

var intArray7: TArray<Integer> := [1, 2, 3];

end;

===List===

Lists are objects and need be release from memory after use.

var

// TLists can't be initialized or created in declaration scope

List4.free;

end;

 

===Dictionary===

TDictionary is a generic class.It represents a collection of key/value pairs. Keys must be unique.

It need be release from memory after use.

var

// TDictionary can't be initialized or created in declaration scope

Dic3.free;

end;

===Queue===

TQueue is a generic class.It represents a collection of data, stored in fist-in fist-out mode.

It need be release from memory after use.

var

Queue1, Queue2: TQueue<Integer>;

Queue3.free;

end;

===Stack===

TStack is a generic class.It represents a collection of data, stored in last-in first-out mode.

It need be release from memory after use.

var

Stack1, Stack2: TStack<Integer>;

Stack3.free;

end;

===Strings===

String are array of chars, start index is one (not zero like almost languages).

Can store ansichar (one byte char) or widechar (two bytes char), the default for newer versions is widestring;

var

Str1:String; // default WideString

Writeln(Str1[length(str1)]); // the same above

end;

See [[#Pascal]] for more info.

=={{header|E}}==

 

E has both mutable and immutable builtin collections; the common types are list (array), map (hash table), and set (hash table). This interactive session shows mutable lists and immutable collections of all three types. See also [[Arrays#E]].

 

# value: [1, 2, 3, 4, 5]

 

 

? constSet.contains(3)

 

=={{header|EchoLisp}}==

The collection will be a list, which is not unusual in EchoLisp. We add items - symbols - to the collection, and save it to local storage.

(define my-collection ' ( 🌱 ☀️ ☔️ ))

(set! my-collection (cons '🎥 my-collection))

(local-put 'my-collection)

→ my-collection

 

=={{header|Elena}}==

ELENA 5.0:

===Arrays===

// Weak array

var stringArr := Array.allocate(5);

// initialized array

var intArray := new int[]{1, 2, 3, 4, 5};

 

===ArrayList and List===

//Create and initialize ArrayList

//Create and initialize List

 

===Dictionary===

//Create a dictionary

var dict := system'collections'Dictionary.new();

dict["Hello"] := "World";

dict["Key"] := "Value";

 

=={{header|Elixir}}==

===List===

Elixir uses square brackets to specify a list of values. Values can be of any type:

list = [1,2,3,4,5]

length(list) #=> 5

Enum.at(list,3) #=> 4

list ++ [6,7] #=> [1,2,3,4,5,6,7]

 

===Tuple===

Elixir uses curly brackets to define tuples. Like lists, tuples can hold any value:

Tuples store elements contiguously in memory. This means accessing a tuple element per index or getting the tuple size is a fast operation:

tuple = {0,1,2,3,4} #=> {0, 1, 2, 3, 4}

tuple_size(tuple) #=> 5

elem(tuple, 2) #=> 2

 

===Keyword lists===

In Elixir, when we have a list of tuples and the first item of the tuple (i.e. the key) is an atom, we call it a keyword list:

list == [a: 1, b: 2] #=> true

list[:a] #=> 1

Keyword lists are important because they have two special characteristics:

# They keep the keys ordered, as specified by the developer.

# Maps allow any value as a key.

# Maps' keys do not follow any ordering.

kwlist = [x: 1, y: 2] # Key Word List

Map.new(kwlist) #=> %{x: 1, y: 2}

map = %{:a => 1, :b => 2} #=> %{a: 1, b: 2}

map.a #=> 1

 

===Set===

set1 = MapSet.new(1..4) #=> #MapSet<[1, 2, 3, 4]>

MapSet.size(set1) #=> 4

MapSet.intersection(set1,set2) #=> #MapSet<[2, 4]>

MapSet.difference(set1,set2) #=> #MapSet<[1, 3]>

 

===Struct===

Structs are extensions built on top of maps that provide compile-time checks and default values.

defstruct name: "john", age: 27

end

age #=> 27

meg = %User{name: "meg"} #=> %User{age: 27, name: "meg"}

 

=={{header|Factor}}==

 

! ===fixed-size sequences===

 

! Factor also comes with disjoint sets, interval maps, heaps,

 

=={{header|Fancy}}==

===array===

 

# creating an empty array and adding values

 

# creating an array with the constructor

a = Array new # => []

 

===hash===

 

 

h = <[]> # => <[]>

# creating a hash with the constructor

h = Hash new # => <[]>

 

=={{header|Forth}}==

===Array===

 

 

10 car-create ar \ create a dynamic array with initial size 10

3 1 ar car-set \ ar[1] = 3

1 0 ar car-insert \ ar[0] = 1 ar[1] = 2 ar[2] = 3

 

===Double linked list===

 

 

dcl-create dl \ create a double linked list

1 dl dcl-prepend

2 1 dl dcl-insert \ dl[0] = 1 dl[1] = 2 dl[2] = 3

 

===Hashtable===

 

 

10 hct-create ht \ create a hashtable with initial size 10

2 s" two" ht hct-insert \ ht["two"] = 2

3 s" three" ht hct-insert \ ht["three"] = 3

 

=={{header|Fortran}}==

===Standard===

A(1) = 1 !Assigns a value to the first element.

INTEGER COUNTER !Its content is listed.

REAL WEIGHT,DEPTH

COMPLEX PATH(6) !The mixed collection includes an array.

END TYPE MIXED

would define a collection of variables constituting a "type", then a simple variable TEMP whose parts would be accessed via the likes of <code>TEMP.DEPTH</code> or <code>TEMP%DEPTH</code>, and an array of such aggregates where <code> A(3).PATH(1) = (2.7,3.1)</code> assigns a complex number to the first step of the PATH of the third element of array A. The indexing must be associated with the item having an array aspect, but in pl/i <code>A.PATH(3,1)</code> - or other groupings - would be acceptable.

 

 

This can be fixed size or dynamic, have arbitrary lower and upper bounds, have up to 8 dimensions and any kind of element type (including user defined types). Here are some simple examples:

 

'create fixed size array of integers

Dim c(1 To 2, 1 To 2) As Byte = {{1, 2}, {3, 4}}

Print c(1, 1), c(2,2)

 

{{out}}

3.5 7.1

1 4

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=004236066581dd85f39f34e100bf5c40 Click this link to run this code]'''

Dim siCount As Short

Dim cCollection As Collection = ["0": "zero", "1": "one", "2": "two", "3": "three", "4": "four",

Next

 

Output:

<pre>

* Maps

Built in resizable collections are slices and maps. The value type for these collections can be any Go type, including interface. An empty interface can reference an object of any type, providing a kind of polymorphic collection. Here the variable <tt>a</tt> is a slice of interface{} objects.

 

import "fmt"

a = append(a, "apples", "oranges")

fmt.Println(a)

{{out}}

<pre>

=={{header|Groovy}}==

Lists are just variable-length, integer-indexed arrays.

assert emptyList.isEmpty() : "These are not the items you're looking for"

assert emptyList.size() == 0 : "Empty list has size 0"

["even more stuff", "even more stuff", "more stuff"] \

: "reverse referencing last 3 elements"

 

{{out}}

 

Maps are just variable-length, associative arrays. They are not necessarily order preserving.

assert emptyMap.isEmpty() : "These are not the items you're looking for"

assert emptyMap.size() == 0 : "Empty map has size 0"

assert combinedMap.keySet().containsAll(

["lastName", "count", "eyes", "hair", "weight", "initial", "firstName", "birthdate"])

 

{{out}}

 

Sets are unique, not indexed at all (contents can only be discovered by traversal), and are not necessarily order preserving. There is no particular special language support for denoting a Set, although a Set may be initialized from a List, and Sets share many of the same operations and methods that are available in Lists.

assert emptySet.isEmpty() : "These are not the items you're looking for"

assert emptySet.size() == 0 : "Empty set has size 0"

combinedSet << "even more stuff"

assert combinedSet.size() == 5 : "No duplicate elements allowed!"

 

{{out}}

The list is typically the first collection type to be encountered in textbooks, but other types may tend to be more efficient, or more flexibly accessed; see the <code>Data</code> hierarchy of [http://www.haskell.org/ghc/docs/latest/html/libraries/ GHC's standard library]. New collection types may be defined with <code>data</code>.

 

 

To prepend a single element to a list, use the <code>:</code> operator:

 

 

To concatenate two lists, use <code>++</code>:

 

 

To concatenate a whole list of lists, use <code>concat</code>:

 

 

===Data.Array===

Faster retrieval by index:

 

triples :: Array Int (Char, String, String)

 

main :: IO ()

{{Out}}

<pre>虎 hǔ tiger

===Data.Map===

Flexible key-value indexing and efficient retrieval:

import Data.Maybe (isJust)

 

main :: IO ()

main =

{{Out}}

<pre>Just [2,4,6]</pre>

===Data.Set===

Repertoire of efficient set operations:

 

setA :: S.Set String

 

main :: IO ()

{{Out}}

<pre>["delta","epsilon"]</pre>

 

Several data types could be considered collections:

s := "abccd" # string, an ordered collection of characters, immutable

c := 'abcd' # cset, an unordered collection of characters, immutable

L := [] # list, an ordered collection of values indexed by position 1..n or as stack/queue, mutable, contents may be of any type

record constructorname(field1,field2,fieldetc) # record, a collection of values stored in named fields, mutable, contents may be of any type (declare outside procedures)

 

Adding to these collections can be accomplished as follows:

s ||:= "xyz" # concatenation

c ++:= 'xyz' # union

T["abc"] := "xyz" # insert create/overwrite

put(L,1) # put (extend), also push

 

Additionally, the following operations apply:

S := S ++ S2 # union of two sets or two csets

S ++:= S2 # augmented assignment

L := L ||| L2 # list concatenation

 

=={{header|J}}==

J will, when possible without losing significance of the original value, implicitly convert values to a type which allows them represented in a homogeneous fashion in a collection. Heterogeneous collections are possible via "boxing" (analogous to a "variant" data type).

 

c, 50 NB. Append 50 to the collection

1 1 1 1 1

c -: 10 i.5 NB. Test for identicality

 

=={{header|Java}}==

When creating a List of any kind in Java (Arraylist or LinkedList), the type of the variable is a style choice. It is sometimes considered good practice to make the pointer of type List and the new object of a List subclass. Doing this will ensure two things: if you need to change the type of list you want you only need to change one line and all of your methods will still work, and you will not be able to use any methods that are specific to the List type you chose. So in this example, all instances of "ArrayList" can be changed to "LinkedList" and it will still work, but you will not be able to use a method like "ensureCapactiy()" because the variable is of type List.

 

arrayList.add(new Integer(0));

// alternative with primitive autoboxed to an Integer object automatically

for(int i = 0; i < 10; i++) {

myarrlist.add(i);

 

for ( i = 0; i < myarrlist.size(); i++) {

sum += myarrlist.get(i);

or

sum += i;

 

myarrlist.remove(myarrlist.size()-1)

 

//clear the ArrayList

Here is a reference table for characteristics of commonly used <code>Collections</code> classes:

{|class="wikitable"

|}

=== Using the Scala collection classes===

import scala.collection.concurrent.TrieMap;

import scala.collection.immutable.HashSet;

}

}

 

=={{header|JavaScript}}==

array.push('abc');

array.push(123);

array.push(new MyClass);

 

obj['foo'] = 'xyz'; //equivalent to: obj.foo = 'xyz';

obj['bar'] = new MyClass; //equivalent to: obj.bar = new MyClass;

obj['1x; ~~:-b'] = 'text'; //no equivalent

 

=={{header|jq}}==

One of the programmatic approaches to creating JSON objects allows

the key names to be specified as unquoted strings, e.g.

 

evaluates to true. Variables can also be used, e.g. the object {"a":1} can also be created by the following

pipeline:

 

===Equality===

modifying an element of a composite structure. For example, consider the following pipeline:

 

 

The result (or output) of this sequence is [10,1,2], so it is convenient to

Julia has a wide variety of collections, including vectors, matrices, lists of Any data type, associative arrays, and bitsets.

There is a slicing notation and list comprehensions similar to those in Python, but the base index is by default 1, not 0. In Julia, a collection is a just variable length array:

 

julia> collection = []

4

7

 

=={{header|Kotlin}}==

 

In addition, Kotlin can also access other types of Java collection such as LinkedList, Queue, Deque and Stack by simply importing the appropriate type:

 

fun main(args: Array<String>) {

pq.add("First"); pq.add("Second"); pq.add("Third")

println(pq)

 

{{out}}

=={{header|Lingo}}==

Lingo has 2 collection types: lists (arrays) and property lists (hashes):

l = [1, 2]

l.add(3)

pl["barfoo"] = 4

put pl

 

Lingo is not statically-typed, but if needed, a collection type that only accepts a specific data type can be created by sub-classing one of the 2 available collection types and overwriting its access methods, so that those block any data type other than the one that was passed to the constructor.

=={{header|Lisaac}}==

===vector===

vector := ARRAY[INTEGER].create_with_capacity 32 lower 0;

vector.add_last 1;

===hashed set===

set := HASHED_SET[INTEGER].create;

set.add 1;

===linked list===

list := LINKED_LIST[INTEGER].create;

list.add_last 1;

===hashed dictionary===

dict := HASHED_DICTIONARY[INTEGER, STRING_CONSTANT].create;

dict.put 1 to "one";

 

=={{header|Logo}}==

Lua has only one type of collection, the table. But Lua's table has features of both, traditional arrays and hash maps (dictionaries). You can even mix both within one table. Note, that the numeric indices of Lua's table start at 1, not at 0 as with most other languages.

 

print(collection[1]) -- prints 0

 

print(collection.foo) -- syntactic sugar, also prints 0

 

 

It is idiomatic in Lua to represent a Set data structure with a table of keys to the true value.

=={{header|M2000 Interpreter}}==

===Ordered List (array)===

Module Arr {

\\ array as tuple

}

Arr

===Ordered List (stack)===

A stack may have values inventories,arrays, stacks, groups

Module CheckStack {

\\ ordered collection: Stack

}

CheckStack

===Inventories as Maps===

An Inventory may have values inventories,arrays, stacks, groups

Module Maps {

\\ Inventory as pairs of keys/values

}

Maps

 

===Inventories as Sets===

Module Sets {

\\ Inventory as set of keys

}

Sets

 

===Using a Visual Basic 6 Collection===

 

We can get a list

Module GetC {

declare c collection

Read a

Print type$(a)="Collection" ' if we don't declare

{Out}

<pre>

=={{header|Maple}}==

Defining lists:

L1 := [3, 4, 5, 6];

L1 := [3, 4, 5, 6]

L2 := [7, 8, 9];

L2 := [7, 8, 9]

Concatenating two lists:

[op(L1), op(L2)]

[3, 4, 5, 6, 7, 8, 9]

 

Defining an Array:

A1 := Array([3, 4, 5, 6]);

A1 := [3, 4, 5, 6]

 

Appending to a Vector:

ArrayTools:-Append(A1, 7);

A1 := [3, 4, 5, 6, 7]

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

->{3, 4, 5, 6}

 

 

Insert[ Lst, X, 4]

 

=={{header|MATLAB}} / {{header|Octave}}==

 

Sample Usage:

 

A =

 

make: 'honda'

'''Bold text'''

 

=={{header|MiniScript}}==

MiniScript supports both lists and maps (dictionaries). This task demonstrates lists.

seq.push 42

seq = seq + [1, 2, 3]

 

{{output}}

=={{header|MS SmallBasic}}==

Only with LD extension

ll=LDList.CreateFromValues("")

LDList.Add(ll "Cars")

LDList.Add(ll "Toys")

LDList.Print(ll)

result:

 

=={{header|NetRexx}}==

NetRexx can take advantage of Java's <tt>Collection</tt> classes. This example uses the <tt>Set</tt> interface backed by a <tt>HashSet</tt>:

options replace format comments java crossref symbols nobinary

 

 

return

 

=={{header|Nim}}==

===Array===

Length is known at compile time

var b: array[128, int]

b[9] = 10

b[0..8] = a

var c: array['a'..'d', float] = [1.0, 1.1, 1.2, 1.3]

 

===Seq===

Variable length sequences

d.add(10)

d.add([11,12,13,14])

var f = newSeq[string]()

f.add("foo")

 

===Tuple===

Fixed length, named

g[0] = 12

 

 

# A sequence of key-val tuples:

 

===Set===

Bit vector of ordinals

j.incl('X')

 

var k = {'a'..'z', '0'..'9'}

 

 

===Tables===

Hash tables (there are also ordered hash tables and counting hash tables)

var l = initTable[string, int]()

l["foo"] = 12

 

var m = {"foo": 12, "bar": 13}.toTable

 

===Sets===

Hash sets (also ordered hash sets)

var n = initSet[string]()

n.incl("foo")

 

var o = ["foo", "bar", "baz"].toSet

 

===Double queues===

var p = initDeque[int]()

p.addLast(12)

p.addFirst(13)

echo p.popFirst()

 

=={{header|Objeck}}==

===vector===

values := IntVector->New();

values->AddBack(7);

values->AddBack(3);

values->AddBack(10);

 

===linked list===

values := IntList->New();

values->AddBack(7);

values->AddBack(3);

values->AddBack(10);

 

===hash===

values := StringHash->New();

values->Insert("seven", IntHolder->New(7));

values->Insert("three", IntHolder->New(3));

values->Insert("ten", IntHolder->New(10));

 

===stack===

values := IntStack->New();

values->Push(7);

values->Push(3);

values->Push(10);

 

=={{header|Objective-C}}==

Arrays (indexed by an integer), which are also collections, are not shown here.

 

 

void show_collection(id coll)

}

return EXIT_SUCCESS;

 

{{out}} (stripped the left-sided log info):

 

Lists are written like so:

 

To prepend a single element to a list, use the '''::''' operator:

 

To concatenate two lists, use '''@''':

 

To concatenate a whole list of lists, use [http://caml.inria.fr/pub/docs/manual-ocaml/libref/List.html#VALflatten List.flatten]:

 

 

Being a ''functional'' programming language, the list is one of the most important collection type. And being an ''impure'' functional programming language there are also imperative collection type, as for example, arrays:

 

The [http://code.google.com/p/ocaml-extlib/ extlib] also provides a type [http://ocaml-extlib.googlecode.com/svn/doc/apiref/Enum.html Enum.t].

A List (or a Pair) can be created using the following syntax :

 

 

In order to add values to a collection, you have to use a ListBuffer (a mutable collection) :

 

 

{{out}}

ooRexx arrays are sequential lists of object references. The index values are the numeric position (1-based) within the array.

A given array may be sparse and arrays will be automatically expanded as needed.

a = .array~new(4) -- creates an array of 4 items, with all slots empty

say a~size a~items -- size is 4, but there are 0 items

a[5] = "Mike" -- assigns a value to the fifth slot, expanding the size

say a~size a~items -- size is now 5, with 2 items

 

;Lists

and the positions will be adjusted accordingly. Lists are indexed using index cookies that are assigned when

an entry is added to the list and can be used to access entries or traverse through the list.

l = .list~new -- lists have no inherent size

index = l~insert('123') -- adds an item to this list, returning the index

say item

end

{{out}}

<pre>

Queues are non-sparse sequential lists of object references. The index values are by numeric position (1-based), although access to

items is traditionally done by pushing or popping objects.

q = .queue~of(2,4,6) -- creates a queue containing 3 items

say q[1] q[3] -- displays "2 6"

q[1] = q[1] + 1 -- updates the first item

say q[1] q[3] -- displays "5 2"

 

;Tables

Tables are collections that create a one-to-one relationship between an index object and a referenced object.

Although frequently used with string indexes, the index object can be of any class, with index identity determined by the "==" method.

t = .table~new

t['abc'] = 1

t['def'] = 2

say t['abc'] t['def'] -- displays "1 2"

 

;Relations

Relation collections create one-to-many data relationships. An addition to the collection will always create a new entry.

t = .table~new -- a table example to demonstrate the difference

t['abc'] = 1 -- sets an item at index 'abc'

say item

end

 

;Directories

Directory objects are like tables, but the index values must always be string objects.

d = .directory~new

d['abc'] = 1

d['def'] = 2

say d['abc'] d['def'] -- displays "1 2"

Directory objects also support an UNKNOWN method that map messages to directory index entries. This allows

values to be set as if they were object attributes. The following example is another way of doing the same as

the first example:

d = .directory~new

d~abc = 1

d~def = 2

say d~abc d~def -- displays "1 2"

Note that the index entries created in the example are the uppercase 'ABC' and 'DEF'.

 

Sets are unordered collections where the items added to the collection are unique values. Duplicate additions are collapsed to just a

single item. Sets are useful for collecting unique occurrences of items.

s = .set~new

text = "the quick brown fox jumped over the lazy dog"

 

say "text has" text~words", but only" s~items "unique words"

 

=={{header|Oz}}==

The most important collection types are lists, records, dictionaries and arrays:

%% Lists (immutable, recursive)

Xs = [1 2 3 4]

Arr = {Array.new 1 10 initValue}

Arr.1 := 3

 

There are also [http://www.mozart-oz.org/home/doc/base/tuple.html tuples] (records with consecutive integer keys starting with 1), [http://www.mozart-oz.org/documentation/base/weakdictionary.html weak dictionaries], [http://www.mozart-oz.org/documentation/mozart-stdlib/adt/queue.html queues] and [http://www.mozart-oz.org/documentation/mozart-stdlib/adt/stack.html stacks].

=={{header|PARI/GP}}==

Pari has vectors, column vectors, matrices, sets, lists, small vectors, and maps.

v = [];

cv = vectorv(0);

l = List(v);

vs = vectorsmall(0);

Adding members:

v=concat(v, [1,2,3]);

v=concat(v, 4);

 

=={{header|Pascal}}==

Different implementations of Pascal have various containers.

===Array ===

MyArray: array[1..5] of real;

begin

MyArray[1] := 4.35;

===Dynamic Array ===

MyArray: array of integer;

begin

setlength (MyArray, 10);

MyArray[4] := 99;

===Record ===

MyRecord: record

x, y, z: real;

MyRecord.z := -4.0;

MyRecord.presence := true;

 

===Set ===

days = (Mon, Tue, Wed, Thu, Fri, Sat, Sun);

var

week := workdays + [Sat, Sun];

weekendDays := week - workdays;

 

===String ===

MyString: String;

begin

MyString:= 'Some Text';

===List ===

{{works with|Free_Pascal}}

{{libheader|Classes}}

uses

classes;

writeln (integer(MyList.Items[i]^));

MyList.Destroy;

 

{{out}}

{{works with|Free_Pascal}}

{{libheader|Objects}}

 

{ Program to demonstrate the TCollection.AtInsert method }

C^.Foreach(@PrintField);

Dispose(C, Done);

 

=={{header|Perl}}==

Perl has ''array'' and ''hashes''.

 

my @c = (); # create an empty "array" collection

 

foreach my $i ( keys %h ) {

print $i . " -> " . $h{$i} . "\n";

 

=={{header|Phix}}==

Collections can simply be stored as sequences

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">collection</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>

<span style="color: #000000;">collection</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prepend</span><span style="color: #0000FF;">(</span><span style="color: #000000;">collection</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span> <span style="color: #000000;">collection</span> <span style="color: #000080;font-style:italic;">-- {2,"one"}</span>

If you want uniqueness, you could simply use a dictionary with values of 0:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">setd</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"one"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>

<span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"visitor"</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- shows 2, "one"</span>

 

=={{header|PHP}}==

PHP has ''associative arrays'' as collection

 

$a = array();

# add elements "at the end"

$a['two'] = 2;

print_r($a);

 

{{out}}

[two] => 2

)</pre>

 

=={{header|PicoLisp}}==

[http://software-lab.de/doc/refI.html#idx index] trees or

[http://software-lab.de/doc/ref.html#symbol property] lists).

-> (3 4 5 6)

 

 

: (insert 4 Lst 'X)

 

=={{header|PL/I}}==

declare countries character (20) varying controlled;

allocate countries initial ('Britain');

allocate countries initial ('America');

allocate countries initial ('Argentina');

 

=={{header|PowerShell}}==

===Array===

The array index is zero based.

# Create an Array by separating the elements with commas:

$array = "one", 2, "three", 4

 

$multiArray[2,2] # returns 33

===Hash Table===

Hash tables come in two varieties: normal and ordered, where of course, the order of entry is retained.

# An empty Hash Table:

$hash = @{}

Vikings = "Minnesota"

}

===Other Collection Types===

PowerShell is a .NET language so '''all''' of the collection types in .NET are available to PowerShell. The most commonly used would probably be <code>[System.Collections.ArrayList]</code>.

$list = New-Object -TypeName System.Collections.ArrayList -ArgumentList 1,2,3

 

$list.Add(4) | Out-Null

$list.RemoveAt(2)

 

=={{header|Prolog}}==

Traditionally Prolog supports only lists.

L = [a,b,c,d],

 

% delete from list

Output:

<pre>

SWI-Prolog supports some other collection types as built in libraries, the most notable is the Dict.

Dicts can be accessed using a special notation and can be added and removed from in an immutable way.

D1 = point{},

 

 

% access a value randomly

Output:

<pre>

===Arrays===

Creating an [http://www.purebasic.com/documentation/array/index.html Array] of 10 strings (could be any type). PureBasic starts the index with element 0.

 

Text(3)="Hello"

 

===Linked Lists===

Create a [http://www.purebasic.com/documentation/linkedlist/index.html Linked List] for strings (could be any type), then add two elements.

 

AddElement(Cars()): Cars()="Volvo"

 

===Hash table===

Create a [http://www.purebasic.com/documentation/map/index.html Map], e.g. a hash table that could be any type. The size of the dictionary can be defined as needed, otherwise a default value is used.

 

Capitals("USA") = "Washington"

 

=={{header|Python}}==

{{works with|Python|2.5}}

Python supports lists, tuples, dictionaries and now sets as built-in collection types. See http://docs.python.org/tut/node7.html for further details.

x = collection[0] # accessing an item (which happens to be a numeric 0 (zero)

collection.append(2) # adding something to the end of the list

collection = {0: "zero", 1: "one"} # Dictionaries (Hash)

collection['zero'] = 2 # Dictionary members accessed using same syntax as list/array indexes.

 

In addition Python classes support a number of methods allowing them to implement indexing, slicing, and attribute management features as collections. Thus many modules in the Python standard libraries allow one to treat files contents, databases, and other data using the same syntax as the native collection types. Some Python modules (such as Numeric and NumPy) provide low-level implementations of additional collections (such as efficient n-dimensional arrays).

===Vectors===

Numeric (floating point)

1:10

[1] 0 0 0 0 0

[1] 1 2 3 4 5 6 7 8 9 10

[1] 1 3 6 10 15 21

Integer

[1] 0 0 0 0 0

[1] 1 -2 99

Logical

[1] FALSE FALSE FALSE FALSE FALSE

[1] TRUE FALSE

Character

[1] "" "" "" "" ""

[1] "abc" "defg" ""

===Arrays and Matrices===

These are essentially vectors with a dimension attribute. Matrices are just arrays with two dimensions (and a different class).

 

[,1] [,2] [,3] [,4]

[1,] 1 4 7 10

===Lists===

Lists are collections of other variables (that can include other lists).

[1] 123

$b

[1] 0.6013157 0.5011909 0.7106448 0.3882265 0.1274939

$c$e

===Data Frames===

Data frames are like a cross between a list and a matrix. Each row represents one "record", or a collection of variables.

name age

1 Alice 23

 

As in other lisps, the simple kind of linked lists are the most common collection-of-values type.

#lang racket

 

;; add an element to the front of a list (non-destructively)

(cons 1 (list 2 3 4))

Racket comes with about 7000 additional types that can be considered as a collection of values, but it's not clear whether this entry is supposed to be a laundry list...

 

Raku has both mutable and immutable containers of various sorts. Here are some of the most common ones:

===Mutable===

my @array = 1,2,3;

@array.push: 4,5,6;

# BagHash

my $b = BagHash.new: <b a k l a v a>;

 

===Immutable===

my @list := 1,2,3;

my @newlist := |@list, 4,5,6; # |@list will slip @list into the surrounding list instead of creating a list of lists

# Bag

my $bag = bag <b a k l a v a>;

 

===Pair list (cons list)===

 

===P6opaque object (immutable in structure)===

my $obj = Something.new: foo => 1, bar => 2;

 

=={{header|Raven}}==

Numerically indexed List:

 

a_list print

 

1 => 2

2 => 3

 

String key indexed Hash:

 

a_hash print

 

hash (2 items)

a => 1

 

Set items:

 

42 a_hash 'b' set # set item with key 'b'

 

Get items:

 

a_hash 'b' get # get item with key 'b'

 

Other stuff:

 

a_list pop # remove last item

42 a_list shove # prepend an item

a_list shift # remove first item

42 a_list 1 insert # insert item second, shuffling others down

 

=={{header|REXX}}==

To store (say) a collection of numbers &nbsp; (or anything,

for that matter) &nbsp; into a stemmed array:

 

pr.1 = 2 /*note that this array starts at 1 (one). */

do n=-5 to 5 /*define a stemmed array from -5 to 5 */

sawtooth.n = n /*the sawtooth array is, well, a sawtooth curve*/

Most often, programmers will assign the &nbsp; zero &nbsp; entry to the

number of elements in the stemmed array.

This means that any index of the stemmed array must be positive to be useful for

storing numbers.

Programmatically, a simple test could be performed to detect the

end of the array &nbsp; (if there aren't any &nbsp; ''null'' &nbsp; values):

say 'prime' j "is" pr.j

end /*j*/

/*at this point, J=16 (because of the DO */

/*loop incrementing the index. */

 

===lists or vectors===

To store (say) a collection of numbers (or anything, for that matter) into a list:

primeList = 2 3 5 7 11 13 17 19 23 29 31 37 41 43

 

/*very efficient for very large arrays (those */

/*with many many thousands of elements). */

The use of lists (in the above manner) is suitable for words (or numbers) that do not have

leading, embedded, or

To store (for instance) a collection of numbers (or anything, for that matter) into

a sparse stemmed array:

pr.2 = 1

pr.3 = 1

end /*k*/

 

 

=={{header|Ring}}==

text = list(2)

text[1] = "Hello "

text[2] = "world!"

see text[1] + text[2] + nl

Output:

<pre>

===Array===

Arrays are ordered, integer-indexed collections of any object.

a = [] #=> []

a[0] = 1 #=> [1]

a = Array.new(3) #=> [nil, nil, nil]

a = Array.new(3, 0) #=> [0, 0, 0]

 

===Hash===

A Hash is a dictionary-like collection of unique keys and their values. Also called associative arrays, they are similar to Arrays, but where an Array uses integers as its index, a Hash allows you to use any object type.

h = {} #=> {}

h["a"] = 1 #=> {"a"=>1}

#=> {}

p h[1] #=> "foo1"

 

===Struct===

A Struct is a convenient way to bundle a number of attributes together, using accessor methods, without having to write an explicit class.

 

Person = Struct.new(:name, :age, :sex)

 

c = Person["Daniel", 22, :Man]

 

===Set===

Set implements a collection of unordered values with no duplicates. This is a hybrid of Array's intuitive inter-operation facilities and Hash's fast lookup.

 

 

# different ways of creating a set

p s1.add(5) #=> #<Set: {1, 2, 3, 4, 5}>

p s1 << 0 #=> #<Set: {1, 2, 3, 4, 5, 0}>

 

===Matrix and Vector===

The Matrix and Vector class represents a mathematical matrix and vector.

 

# creating a matrix

 

p m1 * v1 #=> Vector[1, 3, 5]

 

===OpenStruct===

An OpenStruct is a data structure, similar to a Hash, that allows the definition of arbitrary attributes with their accompanying values.

 

# creating a OpenStruct

son.items = ["candy","toy"]

p son.items #=> ["candy","toy"]

 

=={{header|Rust}}==

====Array====

Arrays (<code>[T]</code>) are stack allocated, fixed size collections of items of the same type.

====Slice====

Slices (<code>&[T]</code>) are dynamically sized views into contiguous sequences (arrays, vectors, strings)

let slice = &array[0..2]

{{out}}

<pre>[1,2]</pre>

* You want a heap-allocated array.

 

v.push(1);

v.push(2);

v.push(3);

// Or (mostly) equivalently via a convenient macro in the standard library

====String====

<code>String</code>s are growable strings stored as a UTF-8 buffer which are just <code>Vec<u8></code>s under the hood. Like <code>str</code>s, they are not indexable (for the same reasons) but iterators can be created over the graphemes, codepoints or bytes therein.

let s = String::from(x);

// or alternatively

 

====VecDequeue====

The collections are available in two flavors; immutable (these have no methods to modify or update) and mutable. With these properties they are also available in concurrent version for parallel processing. Switching between sequential and parallel can easily be done by adding a .seq or .par post-fix.

 

Copyright (C) 2012 Microsoft Corporation. All rights reserved.

 

res19: queue.type = Queue("first", "second")

 

 

// super concurrent mutable hashmap

map.filter { k => k._1 > 3 } // Map(5 -> 6, 44 -> 99)

// // same with for syntax

 

=={{header|Scheme}}==

===list===

returns a newly allocated list of its arguments.

 

Example:

(newline)

(display (list))

{{out}}

<pre>(1 2 3)

 

===cons===

returns a newly allocated list consisting of <code>obj</code> prepended to <code>lst</code>.

 

Example:

{{out}}

<pre>(0 1 2 3)</pre>

===append===

returns a newly allocated list consisting of the elements of <code>lst</code> followed by the elements of the other lists.

 

Example:

{{out}}

<pre>(1 2 3 4 5 6)</pre>

 

===set===

 

enable_output(set of string);

incl(aSet, "silver");

writeln(aSet);

 

===array===

 

const proc: main is func

end for;

writeln;

 

===hash===

 

const type: aHashType is hash [string] string;

writeln(aKey <& ": " <& aValue);

end for;a

 

=={{header|Setl4}}==

 

===Set===

set = new('set 5 10 15 20 25 25')

add(set,30)

show.eval("exists(set,'eq(this,10)')")

show.eval("forall(set,'eq(this,40)')")

===Iter===

iter = new('iter 1 10 2')

show(iter)

show.eval("eq(set.size(iter),5)")

show.eval('member(iter,5)')

===Map===

map = new('map one:1 two:2 ten:10 forty:40 hundred:100 thousand:1000')

show(map)

show.eval("exists(map,'eq(get(map,this),2)')")

show.eval("forall(map,'eq(get(map,this),2)')")

 

=={{header|Sidef}}==

===Array===

Arrays are ordered, integer-indexed collections of any object.

var a = [] #=> []

a[0] = 1 #=> [1]

a[3] = "abc" #=> [1, nil, nil, "abc"]

 

===Hash===

A Hash is a dictionary-like collection of unique keys and their values. Also called associative arrays, they are similar to Arrays, but where an Array uses integers as its index, a Hash allows you to use any object type, which is automatically converted into a String.

var h = Hash() #=> Hash()

h{:foo} = 1 #=> Hash("foo"=>1)

h{:bar} = 2.4 #=> Hash("foo"=>1, "bar"=>2.4)

 

===Pair===

A Pair is an array-like collection, but restricted only to two elements.

var p = Pair('a', 'b')

say p.first; #=> 'a'

pair = pair.second;

pair == nil && break;

 

===Struct===

A Struct is a convenient way to bundle a number of attributes together.

struct Person {

String name,

say a.name #=> "Dr. John Smith"

say a.age #=> 42

 

=={{header|Slate}}==

{1. 2. 3. 4. 5} select: #isOdd `er. "--> {1. 3. 5}"

({3. 2. 7} collect: #+ `er <- 3) sort. "--> {"SortedArray traitsWindow" 5. 6. 10}"

 

=={{header|Smalltalk}}==

* '''Dictionary''': objects are ''indexed'' by an arbitrary key, e.g. a string

 

 

anOrdered := OrderedCollection new.

at: 'Set' put: aSet;

at: 'SortedCollection' put: { aSorted. aSorted2 }.

 

Output:

 

A Tcl list is called an array in other languages (an integer-indexed list of values).

# fill it

lappend c 10 11 13

puts [llength $l]

}

 

A Tcl array is an associative array (aka hash). Arrays are collections of ''variables'' indexable by name, and not collections of values. An array cannot be passed to a procedure be value: it must either be passed by name or by its serialized representation. Tcl arrays also are strictly one-dimensional: arrays cannot be nested. However, multi-dimensional arrays can be simulated with cleverly constructed key strings.

 

array set h {}

# add some pair

puts "array has [llength [array names arr]] keys"

}

 

{{works with|Tcl|8.5}}

A Tcl dictionary is an associative array ''value'' that contains other values. Hence dictionaries can be nested and arbitrarily deep data structures can be created.

 

set d [dict create]

dict set d one 1

set f [dict merge $d $e]

dict set f nested [dict create five 5 more [list 6 7 8]]

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

 

collection=APPEND(collection,morestuff)

TRACE *collection

Output:

<pre>

{{works with|bash}}

{{works with|ksh}}

a_index+=(four five) # append some elements

a_index[9]=ten # add a specific index

for idx in "${!a_index[@]}"; do # interate over the array indices

printf "%d\t%s\n" $idx "${a_index[idx]}"

===Associative arrays===

{{works with|bash}}

a_assoc+=([four]=4 [five]=5) # add some elements

a_assoc[ten]=10

for key in "${!a_assoc[@]}"; do # interate over the array indices

printf "%s\t%s\n" "$key" "${a_assoc[$key]}"

{{works with|ksh}}

 

=={{header|Ursala}}==

Lists are written as comma-separated sequences enclosed in

angle brackets, or with the head and tail separated by a colon.

y = <'foo','bar'>

This function takes a pair of a new head and an existing list,

and returns one that has the new head "added" to it.

===Sets===

 

The order and multiplicities of elements are ignored, so that the followng

declarations are equivalent.

y = {'b','a'}

 

===Modules===

Modules are lists in a particular form used to represent

key:value pairs, with the key being a character string.

A module or any list of pairs can be reified into a function

(a.k.a., a hash or finite map) and used in any context where a function is usable,

where <math>r</math> is the root and <math>s</math> is a list of subtrees, which can

be of any length.

 

'z'^: <

'a'^: <'E'^: <>,'j'^: <>>,

'b'^: <'i'^: <>>,

 

===A-trees===

representation wherein data are stored only in the leaves at a

constant depth.

 

[

4:2: 'baz',

4:3: 'volta',

===Grids===

 

of its descendents in the next level.

 

 

<

4:12: -3.460494e+00^: <>,

4:9: 2.840319e+00^: <>,

 

=={{header|V}}==

A quote is used for the same purpose in V

 

=={{header|VBA}}==

VBA has a built in collection type

coll.Add "apple"

 

=={{header|Vim Script}}==

=={{header|Visual Basic .NET}}==

 

toys.Add("Car")

toys.Add("Boat")

 

=={{header|Visual FoxPro}}==

Visual FoxPro has a built in Collection class.

 

LOCAL loColl As Collection, o, a1, a2, a3

a1 = CREATEOBJECT("animal", "dog", 4)

 

ENDDEFINE

 

=={{header|Wren}}==

Wren has only Map(hash) and List(array).

list = [1, 2, 3, 4]

list.add(5)

for (e in map.keys) {

// Do stuff

 

=={{header|Z80 Assembly}}==

A list is just a consecutive section of memory. Lists are mutable if they are in RAM, and are immutable if they are in ROM. Whether they are located in RAM or in ROM depends mostly on the hardware that uses the Z80 CPU. (Typically, programs that are run from CD-ROM or floppy disks can create mutable lists using the method below, but ROM cartridges cannot, even if those cartridges have internal RAM.)

 

 

To append to a list you need to know where it ends, unfortunately the CPU can't know this without some sort of metadata placed at the beginning of a list. In addition, it is important to have enough free space after a list to append to it successfully. Otherwise you'll "clobber" whatever is stored after the list, which could be other data or executable code. (The Z80 has no segfaults or memory protection of any kind; writes to ROM are silently ignored, and executable code in RAM is overwritten like any other mutable data.)

 

byte 5 ;size byte

byte 1,2,3,4,5 ;the actual list

pop hl ;go back to beginning of the list.

inc (hl) ;add 1 to the size byte.

 

 

 

=={{header|zkl}}==

Read only list: ROList(1,2,3).append(4); // creates two lists

 

Data(0,Int,"foo\n","bar").readln() //-->"foo\n"

Data(0,String,"foo ","bar") //-->9 bytes (2 \0s)