1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
# Arrays
Arrays in Limbo are dynamic and indexed by 0. They can be initialized providing a size, or declared and initialized in two separate statements if no size is specified.
Disclaimer: I don't like this example very much, but I'm not sure how to shore it up. The lesson here is to use lists.
## Source
### arrays.b:20,30
This shows the initialization of an array of integers using a variable, `width`, as the count of elements for the array.
Note that on `arrays.b:13,15` the array of integers, `nums`, and the integer, `width`, are declared.
### arrays.b:32,44
Limbo supports indexing strings. The length, as per `len`, of a string is equivalent to the number of utf-8 runes within a given string. All strings in Limbo are utf-8 strings.
This section demonstrates the copying of a string into an array of bytes.
### arrays.b:46,57
Since the size of arrays is dynamic, one can declare an array to the size of a dynamic value. The array of bytes, `dbl`, is initialized to double the size of the array `arr`.
Each index of `arr` is copied to two neighboring indices in `dbl`.
### arrays.b:59,67
Arrays can be initialized to a given set of values as well. In this case, the characters `[a-f]` are used as values to populate the array of strings, `chars`. The size of the array will be equal to the number of elements provided in the aforementioned set.
### arrays.b:69,84
Arrays can be declared to be arrays of other arrays. In this case, the array `nest` is an array of four arrays of strings of size `2 << i`.
### arrays.b:86,97
Arrays can be conditionally initialized to values. The syntax is similar to the `case` statement syntax. In this case, the first three indices are initialized to the byte value of 4. Indices three and greater are initialized to the byte value of 0.
Note: Multiple conditional sections are not necessary to initialize to a given value.
### arrays.b:99,123
This shows the declaration of an array of size 4 containing lists of string pairs. The lists begin as empty lists, comparable to nil.
The lists at indices 0 and 2 are prepended with pairs of strings. The head of the respective lists are then printed by extracting the pairs of strings prepended previously.
## Demo
; limbo arrays.b
; arrays
Len nums: 0
Len nums: 6
[ 0 2 4 6 8 10]
Len arr: 12
[ b a b y d u c k s ! !]
Len dbl: 24
[ b b a a b b y y d d u u c c k k s s ! ! ! !]
Len chars: 6
[ a b c d e f]
Len nest: 0
Len nest: 4
Lens: [ 2 4 8 16]
Len buf: 10
[ 4 4 4 3 3 3 3 3 3 3]
Len two: 4
Lens: [ 1 0 1 0]
[ (ducks quack) (nil, nil) (inferno os) (nil, nil)]
;
## Exercises
- Play with the widths of different arrays, what happens?
- What can you initialize to with the `* =>` operator, what can't you?
- Remove a case section from the `* =>` operator section, are all indices set to that value?
|
