摘要：接下來幾章將進入語言的核心內容函數表數據轉換查詢和等等，函數說明在中，函數是可以修改全局變量的，所以并不是一個純正的函數式語言。函數體內最大的局部變量個數為個。當執行操作時，當前項是函數的左運算元，前一項是函數的右運算元。

接下來幾章將進入Q語言的核心內容——函數、表、數據轉換、查詢和I/O等等， excited :)

在q中，函數是可以修改全局變量的，所以q并不是一個純正的函數式語言。
1. 函數定義
使用花括號{和}，函數的輸入輸出類型不用指定，甚至函數名都可以不用指定。如下是一個完整的函數定義：

q) {[x] x*x}

調用函數時，參數用中括號包圍起來，參數通過分號;分隔

q){[x] x*x}[3]
9

函數可以賦值給一個變量：

q)f:{[x] x*x}
q)f[3]
9

2. 函數標識和術語
函數的正式定義為{[p1;...;pn] e1; ...; em}，其中可選的p1;...;pn是正式的參數，e1; ...; em是執行的表達式，雖然是從左向右寫的，但是仍然是從右向左執行的。

函數的參數個數被稱為函數的valence， 最常見的函數是monadic(valence 1)和dyadic(valence 2)。

一個niladic函數是指一個沒有輸入的函數，表示如下：

f:{[] … }

例子如下：

q){[] 42} / pure function returns constant 42
42
q){[] a*a} / impure function: references global a
{[] a*a}

函數最大的參數個數(valence)為8，超過8個參數將會報錯。如果參數較多的話，將參數打包成list或者dictionary輸入函數。

函數的輸出值為函數最后一個表達式的結果：

q){[x] x*x}
q){[x;y] a:x*x; b:y*y; r:a+b; r}

Keep it short. 很多q語言中的函數都是緊湊并且模塊化的，很多函數都是僅僅一行

3. 函數應用
函數的調用是嚴格的，意味著在參數替換之前，表達式就已經被執行了：

q)f:{[x] x*x}
q)f[0N!3+1]
4
16

當提供的參數多于函數定義的參數時，會報"rank錯誤。

q) {[x] x*x}[3;4]
"rank

4. 沒有返回值的函數
函數體最后只有一個分號;，返回::。

q)fvoid:{[x] `a set x;}
q)fvoid 42
q)a
42

注意在q中，分號;是分隔符而并不是終止符。

5. 參數的并列寫法
類似于列表索引和字典取值，函數的參數也可以是并列寫法：

q){[x] 2*x} 42
84
q)f:{[x] x*x}
q)f 5
25

6. 函數名的應用
當函數被賦值給一個全局變量時，可以通過symbol形式的函數名來調用：

q)f:{x*x}
q)f[5]
25
q)`f[5]
25
q)`f 5
25
q).my.name.space.f:{2*x}
q)`.my.name.space.f[5]
10

7. 隱含的參數
當一個函數沒有參數被明確定義時，三個隱含的參數x, y, z會被自動定義，下面的函數定義是等價的：

{[x] x*x}
{x*x}

{[x;y] x+y}
{x+y}

三個參數x, y, z的調用是按照先后順序的，意味著x總是第一個被調用，y第二個，z第三個。下面這個函數只有提供三個參數值時才會返回值

q)g:{x+z}  / likely meant x+y; requires 3 args in call
q)g[1;2]   / still waiting for 3rd arg – i.e., a projection
{x+z}[1;2]
q)g[1;2;3] / 2nd arg is required but ignored
4

8. 匿名函數和lambda表達式
一個沒有函數名稱的函數叫做匿名函數，匿名函數的常見的兩個用處：

定義在函數內的匿名函數

f{[...] ...; {...}[...]; ...}

函數容器

q)powers:({1}; {x}; {x*x}; {x*x*x})
…
q)selected:2
q)powers[selected]
{x*x}

9. 恒等函數::
恒等函數::返回它的輸入作為輸出；裸的恒等函數不能使用并列的形式，它必須使用中括號調用。

q)::[42]
42
q)::[`a`b`c]
`a`b`c
q):: 42 / error
"
q)(::) 42
42

10. 函數是數據
類似于python中的函數是對象一樣，在q語言中函數都是數據，可以作為輸入和輸出。

q)apply:{x y}
q)sq:{x*x}
q)apply[sq; 5]
25

常規的函數使用傳值調用(call-by-value)，意味著參數在被傳遞時是按值傳遞的，在這個過程中，原始值被拷貝了一份，以保證之前的原始數據不會被修改。但這樣做的一個問題是，當輸入參數的size非常大時，拷貝是被禁止的。這個時候就有一個新的方法：call-by-name，在這種情況下變量的名字被傳遞而不是變量的值。

Call-by-name沒有特別的語法。一個例子就是內置函數get，傳遞全局變量的名字，返回對應的值

q)a:42
q)get `a
42

另一個例子是函數set，是給全局變量賦值

q)`a set 43
`a
q)a
43

1. 定義局部和全局變量
在函數體內使用:定義的變量被稱為局部變量。函數體內最大的局部變量個數為24個。

q)f:{a:42; a+x}

q語言不遵循詞法作用域規則，意味著在函數體內的函數并沒有獲得上層函數體內變量的權限，例如下例中， helper函數并沒有獲取局部變量a的值的權限

q)f:{[p1] a:42; helper:{[p2] a*p2}; helper p1}

然而，你必須對該局部函數聲明一個額外的參數來傳遞局部變量

q)f:{[p1] a:42; helper:{[a; p2] a*p2}[a;]; helper p1}
q)f 5
210

在所有函數定義以外的變量被稱為全局變量。

2. 在函數內對全局變量賦值
當函數體內沒有同名的局部變量時，可以使用雙冒號::來對全局變量進行賦值；
`q)b:6
q)f:{b::7; x*b}
q)f[6]
42
q)b
7`
而當函數體內有同名的局部變量時，雙冒號符操作的是局部變量，并不是全局變量

q)b:6
q)f:{b:42; b::x; b}
q)f[98]
98
q)b
6

相比::，更推薦使用set來進行全局變量修改, 這樣就不會有局部變量名沖突了。

q)a:42
q)f:{a:98.6; `a set x}
q)f 43
`a
q)a
43

投影是指只指定函數的一部分參數，其結果會是其余參數的函數。

1. 函數投影
一個函數投影的例子為：

q)add:{x+y}
q)add[42;]
{x+y}[42;]

q)add[42;][3]
45

q)add3:{x+y+z}
q)add3[2][3][4]
9

上式可以理解為add3作用于參數2，返回一個函數；該函數作用于參數3，返回一個函數；最后作用于4，返回結果9。上式等價于add3[2;3;4]。

No second look. 被賦值的函數投影變量不會隨著原函數的改變而改變

q)f:{x-y}
q)g:f[42;]
q)g
{x-y}[42;]
q)g[6]
36
q)f:{x+y}
q)g
{x-y}[42;]
q)g[6]
36

2. 運算符投影
當使用運算符中綴形式的時候，一個q的運算符可以通過固定其左運算元來進行投影，這時需要括號。

q)(7*) 6
42

由于任何操作符都是一個函數，當然可以使用其前綴形式進行投影：

q)-[;42] 98
56

上面兩個公式中的空格符都不是必須的：

q)(7*)6
42
q)-[;42]98
56

3. 多維投影
當函數有多個參數的時候(valence > 2)，函數可以有多個投影，例如下例

q){x+y+z}[1;;3]
{x+y+z}[1;;3]
q){x+y+z}[1;;3] 2
6

一個Atomic函數是指該函數直接作用于一個q數據結構中的atom數據。

1. Monadic Atomic函數和map
回憶一下，monadic函數是指只作用于一個參數的函數，如下是一個monadic atomic函數的例子，該函數作用于一個字典

q)neg 10
-10
q)neg 10 20 30
-10 -20 -30
q)neg (10 20 30; 40 50)
-10 -20 -30
-40 -50
q)neg `a`b`c!10 20 30
a| -10
b| -20
c| -30
q)neg `a`b`c!(10 20; 30 40 50; 60)
a| -10 -20
b| -30 -40 -50
c| -60

2. Dyadic atomic函數和zip
Dyadic函數是指作用于兩個參數的函數。若將dyadic函數的非atomic部分固定下來(可以看成一個函數的投影)，那么dyadic函數就變為monadic函數。如下例中的dyadic操作符?。

q)10 20 30?10
0
q)10 20 30?10 20 30 40 50
0 1 2 3 3
q)(enlist 10)?10
0
q)10 20?10
0
q)10 20 30 40 50?10
0

在算術中，比較和關系運算符都是atomic的，在這種應用下會有四種情況：

atom和atom

atom和list

list和atom

list和list

在最后一種情況下，兩個list元素的長度必須相等

q)1+10
11
q)1+10 20 30
11 21 31
q)1 2 3+10
11 12 13
q)1 2 3+10 20 30
11 22 33

這個功能相當于傳統語言中的zip

3. 構造atomic函數
簡單想一想就可以明白，由atomic函數構成的函數仍然是atomic的，因此構造一個atomic函數的方法就是去包含內置的atomic函數。

構造Monadic atomic函數：

q)f:{(x*x)+(2*x)-1}
q)f 0
-1
q)f til 10
-1 2 7 14 23 34 47 62 79 98

構造Dyadic atomic函數：

q)pyth:{sqrt (x*x)+y*y}
q)pyth[1; 1]
1.414214
q)pyth[1; 1 2 3]
1.414214 2.236068 3.162278
q)pyth[1 2 3; 1 2 3]
1.414214 2.828427 4.242641

副詞是高階的函數，用以改變函數在列表上的應用方式。這個術語來自于將q操作符當做動詞。

Proficiency in the use of adverbs is one skill that separates q pretenders from q contenders. :)

1. Monadic each
合并函數例如count只會作用在嵌套列表的最高層級：

q)count 10 20 30
3
q)count (10 20 30; 40 50)
2

如果我們想知道嵌套列表中每個元素的長度，這個時候副詞each就派上用場了，它使得monadic函數能夠作用于列表的每個元素而不是整個列表，each有兩種使用方法：

中綴形式：each緊跟在函數的后面

q) count each (10 20 30; 40 50)
3 2

前綴形式

q) each[count] (10 20 30; 40 50)
3 2

對于層數較深的嵌套矩陣，可能需要對each進行迭代

q)(count each) each ((1 2 3; 3 4); (100 200; 300 400 500))
3 2
2 3
q)each[each[count]] ((1 2 3; 3 4); (100 200; 300 400 500))
3 2
2 3

一些例子：

q)reverse "live"
"evil"
q)reverse ("life"; "the"; "universe"; "and"; "everything")
q)reverse each ("life"; "the"; "universe"; "and"; "everything")

當想要將一個長度為n的向量轉換為一個大小為n*1的矩陣時，可以使用enlist each來實現，但flip enlist在大列表上執行更快。

q)enlist each 1001 1002 1004 1003
1001
1002
1004
1003
q)flip enlist 1001 1002 1004 1003
1001
1002
1004
1003

2. each-both"
副詞each-both符號"作用在一個dyadic函數上，使得函數能夠成對地作用在對應的列表元素上，符號"讀作"zip"。

q)("abc"; "uv"),"("de"; "xyz")
"abcde"
"uvxyz"

q)1,"10 20 30
1 10
1 20
1 30
q)1 2 3,"10
1 10
2 10
3 10
q)2#"("abcde"; "fgh"; "ijklm")
"ab"
"fg"
"ij"

當熟練的時候，可以使用each-both的前綴形式：

q),"[("abc"; "uv"); ("de"; "xyz")]
"abcde"
"uvxyz"

一個table的例子：

q)t1:([] c1:1 2 3)
q)t2:([] c2:`a`b`c)
q)t1,"t2
c1 c2
-----
1  a
2  b
3  c

3. each-left :
each-left操作符作用于一個dyadic函數，使第一個參數下的每一項都應用于第二個參數：

("abc"; "de"; enlist "f") ,: ">"
"abc>"
"de>"
"f>"

4. each-right /:
each-right 作用于一個dyadic函數，使第一項作用于第二個參數的每一項：

q)"
5. Cross Product
叉積(Cross Product)成對地作用于左側的每一項和右側的每一項。 如果我們對join執行each-right和each-left操作，再內置函數raze對得到的嵌套矩陣夷平，就可以得到我們想要的結果
q)1 2 3,/::10 20
1 10 1 20
2 10 2 20
3 10 3 20
q)raze 1 2 3,/::10 20
1 10
1 20
2 10
2 20
3 10
3 20
上述操作還是較為復雜，我們可以通過內置函數cross來得到上述結果
q)1 2 3 cross 10 20
1 10
1 20
2 10
2 20
3 10
3 20
可以注意到，若我們組合each-left和each-right時，我們便可以得到上述結果的轉置
q)raze 1 2 3,:/:10 20
1 10
2 10
3 10
1 20
2 20
3 20
6. Over /
Over操作符/是一個提供遞歸機制的高階函數。它最簡單的形式是修改一個dyadic函數，使其在一個list上累積函數作用的結果
q)0 +/ 1 2 3 4 5 6 7 8 9 10
55
注意： 在運算符和/之間不能存在空格，因為/可以被用作注釋。
運算符左運算元為累積計算的初始值，右運算元為待累積計算的列表。
但我們也可以省略左運算元(即初始值)，這個時候需要我們對表達式做一些變換，被作用函數和Over運算符/用括號包住，這時右邊列表的第一個元素就是初始值。
q)(+/) 1 2 3 4 5 6 7 8 9 10
55
上面的括號是必需項，被修改的函數實際上是一個monadic函數。
一些有用的over形式：
q)(*/) 1 2 3 4 5 6 7 8 9 10 / product
3628800
q)(|/) 7 8 4 3 10 2 1 9 5 6 / maximum
10
q)(&/) 7 8 4 3 10 2 1 9 5 6 / minimum
1
使用,/可以高效地移除列表的頂層嵌套，其對應的內置函數為raze。
q)(,/)((1 2 3; 4 5); (100 200; 300 400 500))
1 2 3
4 5
100 200
300 400 500
q)raze ((1 2 3; 4 5); (100 200; 300 400 500))
1 2 3
4 5
100 200
300 400 500
7. Iteration
/的另一種用法是作為循環代碼的等價形式。在這個版本下，左運算元表示了循環的次數，右運算元為初始值。例如，計算Fibonacci數列：
q)fib:{x, sum -2#x}
q)10 fib/ 1 1
1 1 2 3 5 8 13 21 34 55 89 144
q)fib/[10;1 1]
1 1 2 3 5 8 13 21 34 55 89 144
另一個版本的/控制了循環的進行直至收斂，或者檢測到一個環的存在。下面以牛頓法為例介紹這種循環的使用，我們使用牛頓法來尋找函數{-2+x*x}的根：
q)f:{-2+x*x}
q)secant:{[f;x;e] (f[x+e]-f x-e)%2*e}
q){x-f[x]%secant[f; x; 1e-6]}/[1.5]
1.414214
q語言會判斷當前的輸出值與之前的輸出值之間的大小，如果兩個值之間相差在一定的tolerance以內，則認為算法收斂并且迭代完成；否則繼續執行循環任務。
此外，q語言通過每次比較運算結果和初始值是否match(~)來判斷當前程序是否存在環(loop)，如果存在環，程序則終止：
q)newtcycle:{[xn] xn-((xn*xn*xn)+(-2*xn)+2)%-2+3*xn*xn}
q)newtcycle/[0.0]
1f
如果運算的結果與初始值相等，但是類型不同(not match)，程序則不會停止；例如上例中如果提供初始值0，則程序會一直運行下去。
運算符/的最后一種重載用法，等價于使用while循環，它提供了一個判斷條件，若每次的運算結果滿足條件，則繼續執行；否則，終止計算
q)fib:{x,sum -2#x}
q)fib/[{1000>last x}; 1 1]
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
8. Scan 
Scan操作符同樣是一個高階函數，其作用與操作符/一樣，與其不同的是，Scan會返回中間的計算結果。可以把Scan當做是Over/的"running"版本。
q)0+1 2 3 4 5 6 7 8 9 10
1 3 6 10 15 21 28 36 45 55

q)(*)1 2 3 4 5 6 7 8 9 10

q)(|)7 8 4 3 10 2 1 9 5 6
7 8 8 8 10 10 10 10 10 10

q)(&)7 8 4 3 10 2 1 9 5 6
7 7 4 3 3 2 1 1 1 1

q)100 f1 2 3 4 5 6 7 8 9 10

q)(f)1 2 3 4 5 6 7 8 9 10
所有over操作符/的用法都適用于Scan操作符，使用Scan操作符的好處是可以看到函數中間過程的運行結果。
q)fib:{x, sum -2#x}
q)fib[{1000>last x}; 1 1]
9. each-previous ":
each-previous操作符對列表的每項和其前一項執行dyadic函數操作。當執行Dyadic操作時，當前項是Dyadic函數的左運算元，前一項是Dyadic函數的右運算元。
由于列表中第一項沒有前項，所以我們必須在運算符:"左運算元的位置提供初始值，如下例
q)100 -": 100 99 101 102 101
0 -1 2 1 -1
與其它副詞一樣，each-previous :"也有一個monadic函數的形式。但在這種形式下，列表中的第一個元素不會被當做初始的前項，相反，它直接返回該項。
q)(-":)100 99 101 102 101
100 -1 2 1 -1
q)deltas 100 99 101 102 101
100 -1 2 1 -1
q)(%":)100 99 101 102 101
100 0.98999999999999999 1.0202020202020201 1.0099009900990099 0.99019607843137258
q)ratios 100 99 101 102 101
100 0.98999999999999999 1.0202020202020201 1.0099009900990099 0.99019607843137258
保留第一項的動機是，可以通過保留的第一項來恢復整個list
q)sums deltas 100 99 101 102 101
100 99 101 102 101
q)deltas sums 100 99 101 102 101
100 99 101 102 101
當我們需要返回的結果中都是變化值時，可以通過如下方法得到
q)deltas0:{first[x] -": x}
q)deltas0 100 99 101 102 101
0 -1 2 1 -1
一個使用each-previous的非常有用的工具是使用~判斷連續項是否是match的。實際中，我們經常會關注兩個連續項不同的情況，這種情況下使用內置函數differ
q)(~":) 1 1 1 2 2 3 4 5 5 5 6 6
011010001101b
q)not (~":) 1 1 1 2 2 3 4 5 5 5 6 6
100101110010b
q)differ 1 1 1 2 2 3 4 5 5 5 6 6
100101110010b
可以對differ的結果使用where和cut來分隔列表
q)L:1 1 1 2 2 3 4 5 5 5 6 6
q)where differ L
0 3 5 6 7 10
q)(where differ L) cut L
1 1 1
2 2
,3
,4
5 5 5
6 6
下面我們來做一些q的練習
q)runs:(where differ L) cut L / store runs
q)ct:count each runs / store count of each run
q)runs where ct=max ct / find the runs of maximum length
1 1 1
5 5 5
用一行代碼來實現上面的代碼
q) runs where ct=max ct:count each runs:(where differ L) cut L
同樣，我們可以上述技術來找到上升和下降子序列
q)L:9 8 7 11 10 12 13
q)(where -0W>":L) cut L
9 8 7
11 10
,12
,13
q)(where 0W<":L) cut L
,9
,8
7 11
10 12 13
8. 一般應用
Thorough understanding of the general application is another test that separates the q pretenders from the contenders.
1. 動詞 @
q語言的基礎操作包括：從list中通過索引取值，在字典中通過鍵取值或執行一個monadic函數。
高階函數@是q語言中基礎操作的真正形式，它將一個monadic映射(可能是索引取值，字典取值或者monadic函數)作用于一個元素之上。與所有的內置函數一樣，它同樣有中綴和前綴的表示形式
q)10 20 30 40@1
20
q)L:10 20 30 40
q)L@1
20
q)@[L; 1]
20
q)count@L
4
q)@[count; L]
4
q){x*x}@L
100 300 900 1600
q)d:`a`b`c!10 20 30
q)d@`a
10
q)@[d;`b]
20
當@與niladic函數應用時，可以使用空元素::來代表空值
q)f:{6*7}
q)f[]
42
q)@[f; ::]
42
q)f@(::)
42
q)f@43
42
2. 動詞.
q語言中，多元映射包括了：深度索引一個列表，從一個字典中取一個被嵌套的值和執行一個帶有多個參數的函數等。高階函數.是q語言中多元應用的真正形式。它將多元映射投影到多個參數上，并且可以被寫為中綴和前綴形式。
.的右側必須是一個list
q)L:(10 20 30; 40 50)
q)L[1][0]
40
q)L[1; 0]
40
q)L . 1 0
40
q)d:`a`b`c!(10 20 30; 40 50; enlist 60)
q)d[`b][0]
40
q)d[`b; 0]
40
q)d . (`b; 0)
40
q)g:{x+y}
q)g[1; 2]
3
q)g . 1 2
3
可以配合monadic函數使用.，其效果如下
q)f:{x*x}
q)f@5
25
q)f . enlist 5
25
q)f . enlist 1 2 3
1 4 9
為了表示一個隱藏的索引，可以使用::來代替
q)m:(1 2 3;4 5 6)
q)m[0;]
1 2 3
q)m . (0; ::)
1 2 3
q)m . (::; 1)
2 5
對于一個niladic函數的.執行形式，需要使用::生成一個list。
q)f:{6*7}
q)f . enlist (::)
42
q)f . enlist 42
42
All data structures in q are composed from lists and dictionaries.
一些很好的練習：
q)L:10 20 30
q)L . enlist 1
_
q)m:(10 20 30; 100 200 300)
q)m . 0 1
_
q)ds:(`a`b`c!10 20 30; `x`y!100 200)
q)ds . (0; `b)
_
q)mix:(10 20 30; `a`b`c!(1; 2; (300 400)))
q)mix . (1; `c; 1)
_
q)dc:`c1`c2!(1 2 3; `a`b`c)
q)dc . (`c2; 1)
_
q)t:([]c1:1 2 3;c2:`a`b`c)
q)t . (1; `c2)
_
答案分別是
20 
20 
20 
400 
`b 
`b
3. 應用Monadic函數的@
回憶@的一般操作:
q)L:10 20 30 40 50
q)@[L;1]
20
q)@[L;0 1]
10 20
現在除了取值外，我們同時應用一個函數：
q)@[L;1;neg]
10 -20 30 40 50
q)@[L;0 2;neg]
-10 20 -30 40 50
注意到上述結果與正常在列表子集上的運算不同，正常只會返回在子集上運算的結果
q)neg L@0 1
-10 -20
而這個提升的版本會返回修改后的整個列表。
Monadic函數使用@的一般應用 的語法是
@[L;I;f]
其中L是列表，I為索引的容器。這個形式可以泛化到任何可以被視為映射的數據結構，例如給定一個字典和一個鍵值列表
q)d:`a`b`c!10 20 30
q)ks:`a`c
q)@[d; ks; neg]
a| -10
b| 20
c| -30
上述操作都是在輸入數據結構的拷貝上完成的。我們也可以通過pass-by-name的方法來進行in-place修改
q)L:10 20 30 40
q)@[L; 0; neg]
-10 20 30 40
q)L
10 20 30 40
q)@[`L; 0 ; neg]
`L
q)L
-10 20 30 40
4. 應用Dyadic函數的@
當Dyadic函數使用@時，需要提供一個額外的運算元，顯然運算元要與子集的大小匹配。除了一種額外的情況，當運算元是atom時，會被自動拓展到與子集相同大小。
q)L:10 20 30 40
q)@[L; 0 1; +; 100 200]
110 220 30 40
q)@[L; 0 1; +; 100]
110 120 30 40
q)d:`a`b`c!10 20 30
q)@[d; `a`b; +; 100 200]
a| 110
b| 220
c| 30
q)@[d; `a`b; +; 100]
a| 110
b| 120
c| 30
Dyadic函數使用@的一般應用 的語法是
@[L;I;g;v]
其中L和I與上小節定義一樣，可以是任意能夠被視為映射的數據結構；g是一個Dyadic函數；v是一個atom或者與I匹配的列表。
列表賦值: 一個非常有用的Dyadic函數應用是使用賦值符:在子集上賦值
q)L:10 20 30 40
q)@[L; 0 2; :; 42 43]
42 20 43 40
與Monadic函數一樣，in-place操作可以通過pass-by-name形式
q)L:10 20 30 40
q)@[`L; 0 2; :; 42 43]
`L
q)L
42 20 43 40
5. 應用Monadic函數的.
總結一下，@是作用在數據結構的頂層，而.則是深度索引。
重新回顧一下.的前綴用法
q)m:(10 20 30; 100 200 300)
q).[m; 0 1]
20
q)d:`a`b`c!(10 20 30; 40 50; enlist 60)
q).[d; (`a; 1)]
20
應用monadic函數的.形式：
q).[m; 0 1; neg]
10 -20 30
100 200 300
q).[d; (`a; 1); neg]
a| 10 -20 30
b| 40 50
c| ,60
同樣，若想in-place修改，則使用pass-by-name形式。
可以使用::來代替隱藏的索引
q).[m; (0; ::); neg]
-10 -20 -30
100 200 300
q)d:`a`b`c!(100 200 300; 400 500; enlist 600)
q).[d; (`a; ::); neg]
a| -100 -200 -300
b| 400 500
c| ,600
q).[d; (::; 0); neg]
a| -100 200 300
b| -400 500
c| ,-600
應用monadic函數的.一般形式為：
.[L; I; f]
7. 應用Dyadic函數的.
一般形式為
.[L;I;g;v]
其中g是Dyadic函數，v是atom或與I相對應的運算元
q)m:(10 20 30; 100 200 300)
q).[m; 0 1; +; 1]
10 21 30
100 200 300
q).[m; (::; 1); +; 1 2]
10 21 30
100 202 300
q)m
10 20 30
100 200 300
q).[`m; (::; 1); +; 1]
`m
q)m
10 21 30
100 200 300
q).[`m; (::; 1); :; 42]
`m
q)m
10 42 30
100 42 300
q)d:`a`b`c!(100 200 300; 400 500; enlist 600)
q).[d; (`a; 1); +; 1]
q).[d; (`a; ::); +; 1]
q).[d; (::; 0); +; 1]
q).[`d; (::; 0); :; 42]