ref: ce87687bbc9586ae0ecb1ea646596a76410ef568
dir: /Arrays/README.md/
# 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?