List 是有序的物件集合，具有索引特性，長度可以變動。要建立 List，可以使用內建的 List 類別，每個元素，使用逗號 , 區隔，例如：
lt = new List(1, 2)
# 逐行顯示元素
i = 0
while i < lt.length() {
println(lt.get(i))
i += 1
}
lt.add(3).add(4)
println(lt) # 顯示 [1,2,3,4]
除了使用 List 之外，也可以使用 [] 實字，這是建立 List 的便捷方式，例如：
lt = [1, 2, 3, 4]
println(lt) # [1,2,3,4]
lt.remove(1)
println(lt) # [2,3,4]
lt2 = lt.concat([10, 20])
println(lt2) # [2,3,4,10,20]
List 是 List 類別的實例，List 類別上定義了一些迭代處理元素的便捷方法，例如：
([1, 2, 3, 4, 5].filter(elem -> elem >= 2)
.map(elem -> elem * 100)
.forEach(println)) # 顯示 200、300、400、500
在 ToyLang 中，如果運算式需要跨越多行，必須使用 () 將之含括，另一個方式是使用 \：
[1, 2, 3, 4, 5].filter(elem -> elem >= 2) \
.map(elem -> elem * 100) \
.forEach(println) # 顯示 200、300、400、500
如上所示，filter、map、forEach 等方法，可以接受函式，也就是說在 ToyLang 中，函式是一級值，而這邊指定的是 lambda 運算式，它會產生函式實例，對於可以在一行內完成的小函式，使用 lambda 運算式是比較方便的。
如果要建立的 List 數值是某個範圍，可以使用 range 函式，例如：
(range(2, 6).filter(elem -> elem >= 2)
.map(elem -> elem * 100)
.forEach(println)) # 顯示 200、300、400、500
range 可根據指定的數值範圍，產生 List 實例，預設的步進值是 1，可以用第三個引數來指定步進值，步進值可以是負數：
println(range(1, 30, 5)) # 顯示 [1,6,11,16,21,26]
println(range(100, 90, -2)) # 顯示 [100,98,96,94,92]
甚至可以使用 lambda 運算式來指定範圍的終點以及步進方式：
println(range(1, n -> n < 30, n -> n + 5)) # 顯示 [1,6,11,16,21,26]
println(range(100, n -> n > 90, n -> n - 2)) # 顯示 [100,98,96,94,92]
如果只是需要迭代，不需要實際產生 List，可以使用 iterate 函式：
iterate(1, 5).forEach(println) # 顯示 1 到 4
與 range 不同的是，iterate 產生的並不是 List 實例，而是個迭代器，這個迭代器具有 hasNext、next、forEach、select 以及 collect 方法，舉例而言，range(1, 100) 會產生 List，內含元素值 1 到 99，然而 iterate(1, 100) 並沒有馬上產生 1 到 99 的數值，只有在 next 等方法呼叫之時，才會進一步產生出值來。
也就是說，如果只是要迭代，而不是真的要有個 List，那麼 iterate 會比較有效率，若需要將數值收集起來，可以使用 collect 方法，若需要先做個條件過濾再收集起來，可以使用 select，這兩個方法是會產生 List 實例，用以銜接 List 的 API。
(iterate(2, 6).select(elem -> elem >= 2)
.forEach(println)) # 顯示 2、3、4、5
在實作 ToyLang 的過程中，List 是放在很後期才實作出來的 API，因為它是個類別，顯然地，就必須在有函式與類別的語法，以及相對應的語法節點之後，才能夠進一步實作。
為了儘早讓 ToyLang 可以做些比較實際的運算，List 底層實際銜接了 JavaScript 原生的 Array API，這沒有什麼好意外地，許多語言為了效率，有些函式在底層也都會銜接至 C 語言的程式庫。
對於 ToyLang 來說，銜接至 JavaScript 程式庫的實作，都放在 builtin 之中，現在要解釋裏頭的實作原理還太早，這部份會等到談到函式與類別之後，再來逐步說明。
然而如同〈字串與註解〉裏說過的，老是將函式或方法，直接對應至底層 JavaScript 的 API 沒有意思，因而後來，除了真的必須得用到 JavaScript 環境的一些 API 之外，我就直接用 ToyLang 來寫函式或方法了，例如 range 與 iterate，就是實作在 builtin.toy 之中：
def stopLambda(stop, step) {
if typeof(stop) == 'number' {
if noValue(step) or ((typeof(step) == 'number') and step > 0) {
return i -> i < stop
}
else {
return i -> i > stop
}
}
return stop
}
def stepLambda(step) {
if noValue(step) {
return i -> i + 1
}
if typeof(step) == 'number' {
return i -> i + step
}
return step
}
def iterate(start, stop, step) {
n = start
p = stopLambda(stop, step)
s = stepLambda(step)
class Iter {
def hasNext() {
return p(n)
}
def next() {
v = n
nonlocal n = s(n)
return v
}
def forEach(action) {
while this.hasNext() {
action(this.next())
}
}
def select(predicate) {
lt = []
while this.hasNext() {
nx = this.next()
if predicate(nx) {
lt.add(nx)
}
}
return lt
}
def collect(mapper) {
lt = []
this.forEach(elem -> lt.add(mapper(elem)))
return lt
}
}
return new Iter()
}
def range(start, stop, step) {
lt = []
iterate(start, stop, step).forEach(n -> lt.add(n))
return lt
}
你也可以從這個程式碼中，先預覽一下 ToyLang 的函式與類別語法風格，這某些程度也是在測試 ToyLang 的文法是否足以勝任一般性的任務，另一方面，現代開發者，應該很少有機會自行實作標準程式庫吧！偶而地，想要搞點小實驗，像是自行實現個亂數函式，就可以 ToyLang 裏試試，別有一番樂趣。
方才談到，ToyLang 中若運算式要跨越多行，必須使用 () 或者是 \，這是因為先前提過的，為了簡化 Parser 的設計，ToyLang 採逐行剖析，強硬地運用了 Regular expression 來處理了大半的事情，然而，若不能跨行，上面範例那種流暢 API 風格，撰寫時就會受到一定的限制。
ToyLang 在預處理原始碼時，會將 () 或 \ 標示的多行合併為一行，然後再進行剖析，tokenizer.js 裏的 concatExpr 函式做的，就是這件事。
然而，多行合併為一行，也就會造成顯示除錯訊息時的小問題，例如：
([1, 2, 3, 4, 5].filter(elem -> elem >= 2)
.map(elem -> elem * 100)
.foreach(println))
顯示的錯誤訊息會是：
ReferenceError: foreach is not defined
at [1, 2, 3, 4, 5].filter(elem -> elem >= 2) .map(elem -> elem * 100) .foreach(println) (/main.toy:1)
也就是原本換行排版好的原始碼，在錯誤訊息中也被合併為一行了，這個嘛，必須從一開始的 Parser 設計就解決，就當成日後有機會實現下門語言的課題吧！
回到 List 本身，[] 的寫法，在建立語法樹時，實際上等同於 new List()，這在 expr_parser.js 中可以看到：
['list', {
burst(elemTokenables) {
const NewOperator = UNARY_OPERATORS.get('new');
const args = elemTokenables.length === 1 && elemTokenables[0].value === '' ? [[]] :
[elemTokenables.map(elem => EXPR_PARSER.parse(elem))]
return new NewOperator(
new FunCall(
Variable.of('List'),
args
)
);
}
}]
如果編譯器會產生中介的位元碼（byte code）之類，最後寫出的位元碼會是相同的，這就是所謂的語法糖吧！雖然 List 可以使用 [] 建立，不過以索引取值或設值，還是透過 List 的 get、set 方法，理由之一是，後期我把心力都放在語法樹上，lt[0]、或 lt[1] = 10 這類的語法，必須在 Parser 實作，有點懶得去做，另一個原因，等到後面談到函式時，再來說吧！