Add new tutorial section on rings and beef up lists

Author: samaaron

etc/doc/tutorial/08.1-Lists.md

@@ -20,7 +20,7 @@ play 59
 
 Let's look at other ways to represent this code.
 
-## Chords
+## Playing a List
 
 One option is to place all the notes in a list: `[52, 55, 59]`. Our
 friendly `play` function is smart enough to know how to play a list of
@@ -46,3 +46,51 @@ play [:E3, :G3, :B3]
 
 Now those of you lucky enough to have studied some music theory might
 recognise that chord as *E Minor* played in the 3rd octave.
+
+## Accessing a List
+
+Another very useful feature of a list is the ability to get information
+out of it. This may sound a bit strange, but it's no more complicated
+than someone asking you to turn a book to page 23. With a list, you'd
+say, what's the element at index 23? The only strange thing is that in
+programming indexes usually start at 0 not 1. 
+
+With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
+
+Let's look at this in a little more detail. Take a look at this list:
+
+```
+[52, 55, 59]
+```
+
+There's nothing especially scary about this. Now, what's the second
+element in that list? Yes, of course, it's `55`. That was easy. Let's
+see if we can get the computer to answer it for us too:
+
+```
+puts [52, 55, 59][1]
+```
+
+OK, that looks a bit weird if you've never seen anything like it
+before. Trust me though, it's not too hard. There are three parts to the
+line above: the word `puts` , our list `52, 55, 59` and our index
+`[1]`. Firstly we're saying `puts` because we want Sonic Pi to print the
+answer out for us in the log. Next, we're giving it our list, and
+finally our index is asking for the second element. We need to surround
+our index with square brackets and because counting starts at `0`, the
+index for the second element is `1`. Look:
+
+```
+# indexes:  0   1   2
+           [52, 55, 59]
+```
+
+Try running the code `puts [52, 55, 59][1]` and you'll see `55` pop up
+in the log. Change the index `1` to other indexes, try longer lists and
+think about how you might use a list in your next code jam. For example,
+what musical structures might be represented as a series of numbers...
+
+
+
+
+

etc/doc/tutorial/08.4-Rings.md

@@ -0,0 +1,98 @@
+# Rings
+
+An interesting spin on standard lists are rings. If you know some
+programming, you might have come across ring buffers or ring
+arrays. Here, we'll just go for ring - it's short and simple.
+
+In the previous section on lists we saw how we could fetch elements out
+of them by using the indexing mechanism:
+
+```
+puts [52, 55, 59][1]
+```
+
+Now, what happens if you want index `100`? Well, there's clearly no
+element at index 100 as the list has only three elements in it. So Sonic
+Pi will return you `nil` which means nothing.
+
+However, consider you have a counter such as the current beat which
+continually increases. Let's create our counter and our list:
+
+```
+counter = 0
+notes = [52, 55, 59]
+```
+
+We can now use our counter to access a note in our list:
+
+```
+puts notes[counter]
+```
+
+Great, we got `52`. Now, let's increment our counter and get another
+note:
+
+```
+counter = (inc counter)
+puts notes[counter]
+```
+
+Super, we now get `55` and if we do it again we get `59`. However, if we
+do it again, we'll run out of numbers in our list and get `nil`. What if
+we wanted to just loop back round and start at the beginning of the list
+again? This is what rings are for.
+
+## Creating Rings
+
+We can create rings one of two ways. Either we use the `ring` function
+with the elements of the ring as parameters:
+
+```
+(ring 52, 55, 59)
+```
+
+Or we can take a normal list and convert it to a ring by sending it the
+`.ring` message:
+
+```
+[52, 55, 59].ring
+```
+
+## Indexing Rings
+
+Once we have a ring, you can use it in exactly the same way you would
+use a normal list with the exception that you can use indexes that are
+negative or larger than the size of the ring and they'll wrap round to
+always point at one of the ring's elements:
+
+```
+(ring 52, 55, 59)[0] #=> 52
+(ring 52, 55, 59)[1] #=> 55
+(ring 52, 55, 59)[2] #=> 59
+(ring 52, 55, 59)[3] #=> 52
+(ring 52, 55, 59)[-1] #=> 59
+```
+
+## Using Rings
+
+Let's say we're using a variable to represent the current beat
+number. We can use this as an index into our ring to fetch notes to
+play, or release times or anything useful we've stored in our ring
+regardless of the beat number we're currently on.
+
+## Scales and Chords are Rings
+
+A useful thing to know is that the lists returned by `scale` and `chord`
+are also rings and allow you to access them with arbitrary indexes.
+
+## Ring Constructors
+
+In addition to `ring` there are a number of other functions which will
+construct a ring for us.
+
+* `range` invites you specify a starting point, end point and step size.
+* `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
+* `knit` allows you to knit a sequence of repeated values.
+
+Take a look at their respective documentation for more information.
+