Collections: Difference between revisions

In this example, we're creating a collection of strings associated with the vector table of the 68000's CPU. It's not too important what this data represents, it's more to showcase an actual application of the concept of a collection of pointers being more convenient than a collection of actual strings, so don't worry if you don't understand what these strings mean.

dc.l TrapString_Addr

dc.l TrapString_Illegal

TrapString_trace:

dc.b "Tracing",255

As mentioned earlier, 68000 Assembly doesn't know (or care) what types of data are stored in an array or collection, although if you try to read from an odd memory address at word or long length your CPU will suffer an alignment fault. The CPU doesn't care what types of data are actually stored in an array. It's the programmer's job to tell the CPU what the data actually means.

=={{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|Diego}}==

Diego operates in the real and abstract world. In the real world, collections exist as scalars, vectors, abilities, specifications, inventories, and, non-fungible tokens:

// Real world collections

;

In the abstract world, collections exist as variables, stacks, queues, arrays, matricies, clumps, lists, dictionaries, and, hashes:

// Abstract world collections

add_hash()_ary()_values()_img()_load(/img_027454322.jpg)_img()_load(/img_027454323.jpg);

=={{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

var myAl := new system'collections'ArrayList().append:"Hello".append:"World".append:"!";

//Create and initialize List

var myList := new system'collections'List().append:"Hello".append:"World".append:"!";

===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}}

=={{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