J語言

J語言，是一種陣列程式語言，由肯尼斯·艾佛森和許國華 (電腦科學家)於1990年代初發明。J語言是APL語言的一種方言，延續了APL鮮明的簡潔性，它在數學和統計學程式設計上十分高效，特別是在需要進行矩陣運算的場合。

J語言最初起步於肯尼斯·艾佛森在1987年發表的《APL字典》，它實現了其中至關重要的秩的概念。J語言提供隱式定義機制包括秩、鉤子、叉子和多種函數複合 (電腦科學)，並介入了作為頭等對象的動名詞，用以建立控制結構，它常被作為隱式編程的典範之一。

## 簡介

J語言的運算符，承襲APL傳統，沒有優先級並且最右先行，`2 * 3 + 4`按照`2 * (3 + 4)`來運算。以歷史上APL使用的典型符號為例，符號`/`被用來指示摺疊函數`foldr1`，所以`+/1 2 3`等價於`1 + (2 + 3)`；在APL中，除法被表示為數學除號，它將減號和冒號一起重複列印在EBCDIC和ASCII二者的紙質文本終端上；J語言使用`%`表示除法，是對除號的一種近似或提示。

為了避免APL使用特殊的字符而遇到的問題，J語言只需基本的ASCII字符集，但使用點號`.`和冒號`:`作為「屈折」。點號和冒號除了前導著空白字符的情況之外，都與緊前字符形成類似雙字符組的短字。多數「基礎」或「原始」的J單字，都充當數學符號，通過點號或冒號來擴展這些可用基本字符的含義。在其他語言中經常是成對的很多字符，比如 {} "" `` <>，在J語言中被當作單獨的字，或者在有屈折的時候，作為多字符字的單字符字根。

J語言不再支持從1968年的APL\360就有的`[;]`形式的方括號索引，轉而支持叫做「來自」（from）的索引機制，它起源自Kenneth E. Iverson於1978年在《算子和函數》中提出的，依據基數解碼定義

```J
   decode=: {{x #."(1 _) (0|: y)}}
```

並用符號`⌷`表示的索引

```J
   from=: {{(($ y) #. x) {::"(0 _) (, y)}}
   ]m=: 3 4$i.12
0 1  2  3
4 5  6  7
8 9 10 11
   2 2 from m
10
   3 2$3|i.6
0 1
2 0
1 2
   (3 2$3|i.6)from m
1 8 6
```

J語言承襲IBM APL\360採用了平坦陣列模型，不支持由NARS（嵌套陣列研究系統）於1981年介入，並被IBM APL2所採納的嵌套陣列模型；J語言增加了Kenneth E. Iverson於1978年在《算子和函數》中提出的盒裝數據類型，它由SHARP APL於1981年介入，並於1983年在I. P. Sharp協會研究報告《理性化APL》中，列入與APL2相比較的「限定子集」（RS）而著重強調。

J語言支持AVX2指令集進行SIMD運算。為了包裝用面向對象程式語言開發的API和框架，J語言提供了層級命名空間機制，這裡所有名字都存在於特定語境（locale）中，可以避免軟體包之間的名字衝突，並能有效的用作基於類的面向對象編程的框架。

J語言解釋器默認裝載標準庫。通過包管理器，還可以安裝各種插件，如果是在管理員權限下安裝的J語言解釋器，則安裝插件也需要同樣的管理員權限。J語言擁有常規調試機制，還有叫做Dissect的可視調試器。除了科學計算和統計分析，它還被用於關係資料庫管理系統如Jd、極限編程和網路性能分析。

2011年3月，J語言採用了GNU通用公共許可證版本3，從而成為自由和開源軟體，人們還可以在Jsoftware的商業許可證下利用原始碼。

## 文檔與詞類

J語言的文檔包括在官網的NuVoc中，在其中將主要的字羅列為「J原語」，並使用顏色標示出它們分別的詞類。早期的文檔還有入門和字典。在J語言中的字，被識別為名詞、動詞、定語（副詞和連詞）、系詞、標點、控制字。一個程序或例程，如果接受數據作為輸入並產生數據作為輸出，則被稱為「動詞」，與之相對，數據參數被稱為「名詞」。

J術語｜APL術語

名詞｜陣列

動詞｜函數

副詞，連詞｜算子

字母｜字符集

單詞構成｜詞法分析（lexing）

標點｜控制結構，括號界定等

句子｜表達式

字典｜參考手冊

雋語（epigram）｜單行代碼（one-liner）

動詞有兩種形式：只有右側一個參數的一元（monad）形式，和有左右兩側參數的二元（dyad）形式，例如在`-1`中減號是一元動詞，而在`3-2`中減號是二元動詞。J語言預定義了很豐富的動詞，它們都自動的作用於多種數據類型之上。使用者定義的程序可以自行命名，並用在任何允許使用原始動詞的地方。無論原始動詞還是派生動詞，它們的一元定義與二元定義，在很大程度上是獨立的。

## 起步示例

J語言可以寫出非常精簡的程序，特別是存在重度的對符號的函數重載，以至於一些編程者將它稱為難以閱讀的只寫語言。在電腦的終端上執行`ijconsole`，即可進入J語言的REPL解釋器界面。

### Hello, World!

J語言的「Hello, World!」程序：

```j
   'Hello, world!'
Hello, world!
```

這個Hello World的實現反映了J語言的傳統用法，就是把程序錄入到J解釋器會話中，顯示出表達式結果。還可以準備J腳本來作為獨立程序來執行，比如在Linux系統上，可以編輯如下內容的一個文本文件，並命名為比如`test01.ijs`：

```j
#!/usr/bin/ijconsole
   echo 'Hello, world!'
   exit ''
```

注意第一行的`#!`必須頂頭，這裡的`echo`和`exit`，是與Unix shell中同名命令功能類似的動詞。然後在終端界面中執行這個文件：

```console
$ ijconsole test01.ijs
Hello, world!
$ chmod +x test01.ijs # 另一种执行方式，授予这个文件可执行权限
$ ./test01.ijs
Hello, world!
```

### 平均

在J語言中函數一般稱為動詞，例如定義一個叫做`avg`的動詞，計算一序列數的平均：

```j
   avg=: +/ % #
   avg 1 2 3 4
2.5
```

一元動詞`#`「計數」（tally），總計陣列中項目的總個數。動詞`+`「加」（plus）和副詞`/`「插入」（insert），派生出的動詞`+/`，合計這個陣列的項目的總和。二元動詞`%`「除」（divide）將這個總和除以這個總個數。而使用者定義的動詞`avg`，用到了由連串（strand）的三個動詞（`+/`、`%`和 `#`）構成的一個「叉子」（fork）。叉子`(f g h) y`↔`(f y) g (h y)`，這裡的`f`、`g`和`h`指示動詞，而`y`指示一個名詞。

使用`avg`的一些例子：

```j
   ]a=: ?. 20 $100  NB. 产生100以内20个随机整数的一个向量
94 56 8 6 85 48 66 96 76 59 33 72 63 1 89 52 17 20 9 65
   avg a
50.75
   4 avg\ a         NB. 周期大小为4的移动平均
41 38.75 36.75 51.25 73.75 71.5 74.25 66 60 56.75 42.25 56.25 51.25 39.75 44.5 24.5 27.75
   ]b=: ?. 4 5 $50  NB. 产生50以内20个随机整数的一个矩阵
44  6  8  6 35
48 16 46 26  9
33 22 13  1 39
 2 17 20  9 15
   avg b
31.75 15.25 21.75 10.5 24.5
   avg"1 b          NB. 应用avg于m的每个秩为1的子阵列
19.8 29 21.6 12.6
```

一元副詞`/`「插入」（insert），接受位於它左側的一個運算元，並產生將這個動詞應用於其參數的每個項目之間的一個動詞。就是說，`+/`是一個動詞，定義為應用`+`於給它的參數的各個項目之間。計算移動平均用到的二元副詞`\`「中綴」（infix），將作為數據參數的列表劃分成一系列的指定大小的連續項目的子列表，將所修飾動詞應用於其上，並將這些結果形成一個列表。

一元動詞`]`「相同」（same），恆等於給它的單一右參數，常像這樣用來在賦值之後顯示變量的內容。一元動詞`?.`「擲骰/固定種子」（roll/fixed seed），不同於一元動詞`?`「擲骰」（roll），在生成數據參數項目所指定大小範圍內的隨機數之時，採用固定的種子。這裡確定對矩陣按行還是按列進行平均，用到了連詞`"`「秩」（rank），它在後面的定語章節和單獨條目中論述。

### 查找與排序

二元動詞`i.`「出現索引」（index of），和二元動詞`i:`「最後出現索引」（index of last），在任何大小的陣列內查找匹配者，並返回它的位置索引，如果未找到匹配者，則返回這個陣列的大小。例如：

```j
   a=: 3 1 4 1 5 9
   a i. 1 2  NB. 找到1和2的第一次出现的索引
1 6
   a i: 1 2  NB. 找到1和2的最后一次出现的索引
3 6
```

在J語言中，排序可以按APL傳統的兩步驟方式，使用一元動詞`/:`「升序索引」（grade up）或`\:`「降序索引」（grade down），和用二元副詞`~`「被動」修飾的二元動詞`{`「出自」（from），二者連串（strand）形成的一個「鉤子」來完成。一元鉤子`(f g) y`↔`y f (g y)`；副詞`~`「反身·被動」，其一元定義為`f~ y`↔`y f y`，二元定義為`x f~ y`↔`y f x`。J語言還提供專用的二元動詞`/:`「上升排序」（sort up）或`\:`「下降排序」（sort down）。下面是用例：

```j
   a=: 2 0 4 7 15 9 8 0 4 9 18 8 1 18
   /: a       NB. 产生参数阵列的升序索引
1 7 12 0 2 8 3 6 11 5 9 4 10 13
   ({~ /:) a  NB. 从参数阵列中按升序索引选取出各个项目
0 0 1 2 4 4 7 8 8 9 9 15 18 18
   /:~ a
0 0 1 2 4 4 7 8 8 9 9 15 18 18
   (a - 10) /: a
_10 _10 _9 _8 _6 _6 _3 _2 _2 _1 _1 5 8 8
```

### CSV插件

安裝用來支持CSV文件的插件：

```j
   load 'pacman'                NB. 加载包管理器
   'install' jpkg 'tables/csv'  NB. 安装CSV文件插件
   'showinstalled' jpkg ''      NB. 查看已经安装插件
```

一個CSV文件簡單用例：

```j
   load 'tables/csv'                  NB. 加载CSV插件
   a=: i. 2 3
   a writecsv jpath '~/test01.csv'    NB. 将一个阵列写入一个CSV文件
12
   ]b=: readcsv jpath '~/test01.csv'  NB. 从一个CSV文件读入一个盒子阵列
┌─┬─┬─┐
│0│1│2│
├─┼─┼─┤
│3│4│5│
└─┴─┴─┘
   ]c=: makenum b                     NB. 尽可能的将盒子阵列转换成数值阵列
0 1 2
3 4 5
```

下面演示使用J語言編寫在管道中的過濾器，例如，在具有隱式編程機制Unix管道的Linux系統中，建立如下內容的文本文件，並命名為比如`filter01.ijs`：

```j
#!/usr/bin/ijconsole
load 'tables/csv'
stdout makecsv 10 + makenum fixcsv stdin ''
exit ''
```

然後在終端界面中執行如下命令行：

```console
$ cat test01.csv | ijconsole filter01.ijs
10,11,12
13,14,15
```

## 數據類型

J語言支持三種簡單類型：

- 數值
- 文字（字符）
- 盒裝

其中數值有很多變種。J語言提供的唯一搜集（collection）類型，是任意維度的陣列。多數演算法可以使用這些陣列來簡潔的表達。

### 數值

J語言的數值類型之一是「位」。位有兩個值：`0`和`1`。位還可以形成列表，例如`1 0 1 0 1 1 0 0`，是8個位的列表。在語法上，J分析器將位當作一個字。空格字符被識別為字形成字符，它處在屬於其他數值字的字符之間。

J語言支持任意長度的列表。J語言進一步的在這些位列表之上，支持所有常見二元運算，比如動詞`*.`「與」（and）、`+.`「或」（or）、`-.`「非」（not）、`|.`「反轉·旋轉」（reverse·rotate）、`|.!.f`「移位」（shift）等。J語言還支持位的二維、三維等陣列。上面的運算同樣運行在這些陣列之上。

其他數值類型包括整數（比如3、42）、浮點數（3.14、8.8e22）、複數（0j1、2.5j3e88）、擴展精度整數（12345678901234567890x）和（擴展精度）有理分數（1r2、3r4）。同位一樣，它們可以形成列表或任意維度的陣列。同位的情況一樣，運算可以在一個陣列的所有數值之上。下面例子展示π的前50位，超出了IEEE 754雙精度浮點數的53位二進位尾數能精確表示的最大範圍，這就要用到J語言的擴展精度整數：

```j
   0j15 ": o. 1   NB. π在双精度浮点数下精确值的位数
3.141592653589793
   <.@o. 10x ^50  NB. π乘以扩展精度10的50次幂
314159265358979323846264338327950288419716939937510
```

這裡採用一元動詞`o.`「π乘以」（pi times），和一元動詞`<.`「下取整」（floor）二者的複合，得到預期的結果。位的列表可以使用一元動詞`#.`「基數2」（base 2）解碼成整數。整數可以使用一元動詞`#:`「反基數2」（antibase 2）編碼為位的列表。

### 文字

J語言還支持文字即字符類型。文字包圍在撇號`'`之間，比如`'a'`或`'b'`。文字的列表，通過將多個字符用撇號包圍起來的常規字串約定來表示，比如`'abcdefg'`。在字串內的`''`表示`'`字符本身。單個的文字，典型的是`8`位寬即單字節的ASCII字符，此外J語言還支持Unicode文字。

不支持在文字上的數值和布爾運算，但支持面向搜集的運算，比如旋轉等。使用動詞`".`「執行·數值」（do·numbers），將字節陣列轉換成數值；使用動詞`":`「預設格式·格式」（default format·format），將數值轉換成字節陣列。

### 盒裝

盒裝類型的值是0維標量，而不管所包含的是怎樣的數據結構。使用一元動詞`<`「盒裝」（box），將數據放置入盒子中；使用一元動詞`>`「打開」（open），打開盒子中取出其中數據。還可以通過二元動詞`;`「連結」（link）建立盒子的列表，通過一元動詞`;`「拆除」（raze）移除一層盒子的列表。盒子內可以裝入其他盒子，還可以通過二元動詞`$`「重製形狀」（reshape）和二元動詞`#`「計件複製」（copy）等操作盒子及其列表。

### 陣列

J語言的陣列，具有同質（homogeneous）的項目類型，例如列表`1 2 3`是整數的列表，儘管`1`還可以是一個位。這種類型問題，在極大程度上對於編程者是透明的。只有特定的特殊運算，會顯露出在類型上的不同。例如列表`1.0 0.0 1.0 0.0`，對大多數運算，將被當作是完全同於列表`1 0 1 0`。

J語言支持數值稀疏陣列，通過它們的下標存儲非零數值。這在非零數值相對很少的情況下，是有效率的機制。

### 其他

J語言還支持類和對象，但是它們並非數據類型，實際上使用盒裝文字來提及類和對象，它們實為命名語境和編號語境。

此外還有一個偽類型即記憶體映射文件，它將變量映射到文件系統中的持久文件。

## 簡要詞彙表

下面的表格簡要列出了常用詞彙。如果含義中用了間隔號（·）分隔，通常前者是只有一個右側參數的一元含義，後者是左右兩側都有參數的二元含義。列出的對應APL符號，是Dyalog等現代APL所採用的符號。

### 基本

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`=`｜動詞｜`0 0`｜（二元）等於（equal）｜`3 = i. 5`

`<`｜`<`｜動詞｜`0 0`｜（二元）小於（lesser）｜`8 < 7 8 9`

`⊂`｜動詞｜`_`｜（一元）盒裝（box）在APL中，一元`⊂`稱為包裝（enclose）。｜`(< i. 2 3) , < i. 3 2`

`>`｜`>`｜動詞｜`0 0`｜（二元）大於（greater）｜`8 > 7 8 9`

`↑`｜動詞｜`0`｜（一元）打開（open）在APL中，一元`↑`叫做混合（mix），另有逆向的一元`↓`叫做分離（split）。｜`> (i. 2 3) ; i. 3 2`

`<:`｜`≤`｜動詞｜`0 0`｜（二元）小於等於（less or equal）｜`8 <: 7 8 9`

`>:`｜`≥`｜動詞｜`0 0`｜（二元）大於等於（larger or equal）｜`8 >: 7 8 9`

`~.`｜`∪`｜動詞｜`_`｜（一元）唯一值（nub）｜`~. 'abracadabra'`

`~:`｜動詞｜`_`｜（一元）唯一值篩選（nub sieve）｜`~: 'abracadabra'`

`≠`｜動詞｜`0 0`｜（二元）不等於（not-equal）｜`3 ~: i. 5`

`L.`｜`≡`｜動詞｜`_`｜（一元）最大盒裝層數（level of）｜`L. (<1),(<<2),<<<3`

`-:`｜動詞｜`_ _`｜（二元）匹配（match）這個J單字另有一元形式，見數學表格。｜`'no' -: 'yes'`

`e.`｜`∊`｜動詞｜`_ _`｜（二元）成員關係（member/in）｜`'a' e. 'alpha'`

`E.`｜`⍷`｜動詞｜`_ _`｜（二元）尋找匹配子陣列起點（find match）｜`'co' E. 'cocoa'`

### 數學

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`+`｜動詞｜`0 0 0`｜共軛複數（conjugate）· 加（plus）｜`2 + 3 30`

`+.`｜動詞｜`0`｜（一元）實部/虛部（real/imaginary）｜`+. 3j5`

`∨`｜動詞｜`0 0`｜（二元）最大公約/或（GCD/or）｜`0 0 1 1 +. 0 1 0 1`

`+:`｜動詞｜`0`｜（一元）雙倍（double）｜`+: 7`

`⍱`｜動詞｜`0 0`｜（二元）或非（not-or）｜`0 0 1 1 +: 0 1 0 1`

`*`｜`×`｜動詞｜`0 0 0`｜符號函數（signum）· 乘（times）｜`3 30 * 2`

`*.`｜動詞｜`0`｜（一元）模長/幅角（length/angle）｜`*. 3j4`

`∧`｜動詞｜`0 0`｜（二元）最小公倍/與（LCM/and）｜`0 0 1 1 *. 0 1 0 1`

`*:`｜動詞｜`0`｜（一元）平方（square）｜`*: 7`

`⍲`｜動詞｜`0 0`｜（二元）與非（not-and）｜`0 0 1 1 *: 0 1 0 1`

`-`｜`−`｜動詞｜`0 0 0`｜相反數（negate）· 減（subtract）｜`1 10 - 5 6`

`-.`｜`∼`｜動詞｜`0 _ _`｜非（not）· 差（less）｜`-. 0 1`

`-:`｜動詞｜`0`｜（一元）一半（halve）這個J單字另有二元形式，見基本表格。｜`-：7`

`%`｜`÷`｜動詞｜`0 0 0`｜倒數（reciprocal）· 除（divide）｜`2 3 5 % 3 4 6`

`%:`｜動詞｜`0 0 0`｜平方根（square root）· 方根（root）｜`%: 49`

`|`｜動詞｜`0 0 0`｜幅值（magnitude）· 餘數（residue）｜2 `|` i. 7

`<.`｜`⌊`｜動詞｜`0 0 0`｜下取整（floor）· 極小（minimum）｜`2 3 4 <. 9 1 2`

`>.`｜`⌈`｜動詞｜`0 0 0`｜上取整（ceiling）· 極大（maximum）｜`>. 1.1 0.5 1.9`

`<:`｜動詞｜`0`｜（一元）減少（decrement）｜`<: 7 8 9`

`>:`｜動詞｜`0`｜（一元）增加（increment）｜`>: 7 8 9`

`^`｜`⋆`｜動詞｜`0 0 0`｜指數（exponential）· 冪（power）｜`2 ^ i. 17`

`^.`｜`⍟`｜動詞｜`0 0 0`｜自然對數（natural log）· 對數（log）｜`2 10 ^. 4 100`

`o.`｜`○`｜動詞｜`0 0 0`｜$\pi \,$乘以（pi times）· 圓函數（circle function）｜`sin=: 1&o.`

`j.`｜動詞｜`0 0 0`｜$i \,$乘以（imaginary）· 形成複數（complex）｜`3 j. 4`

`!`｜動詞｜`0 0 0`｜階乘（factorial）· 抽取（out of）｜`2 ! 10`

`?`｜動詞｜`0 0 0`｜擲骰（roll）· 隨機置換（deal）｜`3 ? 10`

`#.`｜`⊥`｜動詞｜`1 1 1`｜基數2（base 2）· 基數（base）｜`_ 60 60 #. 24 0 1`

`#:`｜`⊤`｜動詞｜`_ 1 0`｜反基數2（antibase 2）· 反基數（antibase）｜`24 60 60 #: 86401`

`.`｜連詞｜`2`｜（一元）行列式（determinant）在APL中，通常不為行列式專設符號，J語言的行列式是一元的`(-/ . *)`。｜`(-/ . *) i. 3 3`

`.`｜連詞｜`_ _`｜（二元）矩陣積（matrix product）在APL中，`.`稱為內積（inner product），其標準形式`(+/ . *)`叫做矩陣積。｜`(i. 3 2) (+/ . *) i. 2 3`

`%.`｜`⌹`｜動詞｜`2 _ 2`｜逆矩陣（matrix inverse）· 矩陣除（matrix divide）｜`%. ? 3 3 $ 10`

### 結構

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`$`｜`⍴`｜動詞｜`_ 1 0`｜形狀（shape of）· 重製形狀（reshape）｜`2 2 4 $ 1 2 11 22`

`|`.｜`⊖` `⌽`｜動詞｜`_ _ _`｜反轉（reverse）· 旋轉（rotate）｜`|`. 2 `|`. i. 6 2

`|`:｜`⍉`｜動詞｜`_ 1 _`｜轉置（transpose）· 重排軸（rearrange axes）J的二元轉置，在對軸置換的規定方式上，不同於其他主要APL。｜`|`: 'abc' ,: 'def'

`,`｜`,`｜動詞｜`_`｜（一元）散開（ravel）｜`, i. 2 3 4`

`⍪`｜動詞｜`_ _`｜（二元）附加（append）｜`(i. 2 3) , i. 3 2`

`,.`｜動詞｜`_`｜（一元）散開項目（ravel items）在APL中，一元`⍪`也叫做表格（table）。｜`,. i. 2 3 4`

`,`｜動詞｜`_ _`｜（二元）縫合（stitch）｜`(i. 2 3) ,. i. 2 4`

`,:`｜動詞｜`_ _ _`｜項目化擴秩（itemize）· 疊加（laminate）在APL中，疊加使用小數形式的函數軸來指定，比如`,[0.5]`。｜`(i. 2 3) ,: i. 3 2`

`;`｜動詞｜`_ _ _`｜拆除（raze）在SHARP APL中，拆除（raze）對應一元`↓`，對於現代APL，拆除近似於`↑⍪/`。· 連結（link）｜`; (i. 2 3) ; i. 3 2`

`;.±1``;.±2`｜副詞｜`_`｜（一元）自有區間（self intervals）在APL中，二元`⊆`「劃分」（partition），左參數元素數值指示分段，`(≠⊆⊢)`按左參數字符進行劃分。｜`<;._1 ' a b c'`

`⊂`｜副詞｜`1 _`｜（二元）區間（intervals）在APL中，二元`⊂`「劃分包裝」（partitioned enclose），左參數元素真值指示分界起始。｜`1 0 1 0 0 <;.1 'abcde'`

`;.±3`｜`⌺`｜副詞｜`2 _`｜（二元）子陣列鑲嵌（subarrays）｜`(2 2,:2 4) <;.3 i. 5 6`

`;:`｜動詞｜`1`｜（一元）劃分單字（words）｜`;: 'ab cde'`

### 選取

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`#`｜`≢`｜動詞｜`_`｜（一元）計數（tally）計數最早於1989年出現在A中。在APL中，還可表達為`''`⍴⍴，另有二元`≢`不匹配。｜`# 1 2 3`

`⌿` `/`｜動詞｜`1 _`｜（二元）計件複製（copy）在APL中，`⌿` `/`複製（replicate）擴展自壓縮（compress），另有二元`⍀` `\`擴張（expand）。｜`1 0 2 # 1 2 3`

`{.`｜動詞｜`_`｜（一元）頭部（head）J的頭部（head），類似於APL的一元`⊃`首位（first），它取ravel次序首個元素。｜`{. 'foot'`

`↑`｜動詞｜`1 _`｜（二元）採取（take）｜`3 {. 'foot'`

`}.`｜動詞｜`_`｜（一元）斷頭（behead）｜`}. 1 2 3 4`

`↓`｜動詞｜`1 _`｜（二元）捨棄（drop）｜`2 }. 1 2 3 4`

`{:`｜動詞｜`_`｜（一元）尾部（tail）｜`{: 'foot'`

`}:`｜動詞｜`_`｜（一元）截短（curtail）｜`}: 1 2 3 4`

### 索引

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`i.`｜`⍳`｜動詞｜`1 _ _`｜整數生成（integers）J的整數生成，允許向量和負數參數；現代APL的「索引生成」，接受向量參數，產生此形狀所有的坐標。· 出現索引（index of）｜`i. 10`

`i:`｜動詞｜`0 _ _`｜階梯序列（steps）· 最後出現索引（index of last）｜`'abcd' i: 'c'`

`I.`｜`⍸`｜動詞｜`1 _ _`｜真值位置索引（indices）· 區間索引（interval index）｜`I. 0 0 1 0 1 0`

`/:`｜`⍋`｜動詞｜`_`｜（一元）升序索引（grade up）｜`({~ /:) 10 ? 20`

動詞｜`_ _`｜（二元）上升排序（sort up）｜`/:~ 10 ? 20`

`\:`｜`⍒`｜動詞｜`_`｜（一元）降序索引（grade down）｜`({~ \:) 10 ? 20`

動詞｜`_ _`｜（二元）下降排序（sort down）｜`\:~ 10 ? 20`

`{`｜動詞｜`1`｜（一元）目錄彙編（catalogue）｜`{ 0 1 ; 2 3 4 ; 5 6`

`⌷`｜動詞｜`0 _`｜（二元）出自（from）｜`2 4 { 'abcde'`

`}`｜`@`｜副詞｜`_ _`｜（二元）修改（amend）｜`'gw' 0 3} 'cross'`

`{::`｜`⊃`｜動詞｜`1 _`｜（二元）獲取（fetch）｜`1 {:: (<1),(<<2),<<<3`

### 算子

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`/`｜`∘.`｜副詞｜`_ _`｜（二元）形成表格（table）在APL中，表格算子`∘.`叫做外積（outer product）。｜`*/~ >: i. 6`

`⌿` `/`｜副詞｜`_`｜（一元）插入（insert）｜`([ + 2&*@])/ 1 10 100`

`\`｜副詞｜`_ _`｜（二元）中綴（infix）在APL中，中綴稱為「窗口歸約」（windowed reduce）或「逐n項歸約」（n-wise reduce）。｜`3 <\ 'abcdefg'`

`⍀` `\`｜副詞｜`_`｜（一元）前綴和（prefix）｜`]\ 'banana'`

`\.`｜副詞｜`_ _ _`｜後綴（suffix）· 外綴（outfix）｜`_1 ]\. 1 2 3 4`

`/.`｜副詞｜`_`｜（一元）斜對角（oblique）｜`</. i. 4 4`

`⌸`｜副詞｜`_ _`｜（二元）分組 (SQL)（key）｜`1 0 0 1 0 </. 'AbcDe'`

`~`｜`⍨`｜副詞｜`_ <small>lu</small> <small>ru</small>`｜返身（reflex）· 被動（passive）｜`+~ 1 2 3`

`"`｜`⍤`｜連詞｜秩（rank）｜`+/"1 i. 2 3 4`

`@:`｜連詞｜`_ _ _`｜在於（at）｜這些連詞對於隱式編程有重大意義，在後面的定語章節中專門論述。

`@`｜連詞｜`<small>mv</small> <small>lv</small> <small>rv</small>`｜頂上（atop）

`&`｜連詞｜`<small>mv</small> <small>mv</small> <small>mv</small>`｜合成（compose）

`∘`｜連詞｜`_ 0 _`｜粘上（bond）

`&:`｜`⍥`｜連詞｜`_ _ _`｜並列（appose）

`&.`｜連詞｜`<small>mv</small> <small>mv</small> <small>mv</small>`｜對偶（dual）

`&.:`｜`⍢`｜連詞｜`_ _ _`｜底下（under）

`@.`｜連詞｜`<small>mv</small> <small>lv</small> <small>rv</small>`｜議程（agenda）

`｜連詞｜連結動名詞（tie or gerund）

`:｜连词｜`_ _ _`｜喚起動名詞 （evoke gerund）

`^:`｜`⍣`｜連詞｜`_ _ _`｜動詞冪（power of verb）｜`+: ^:(6&<)"0 ] 5 12`

`!.`｜`⍠`｜連詞｜`<small>mu</small> <small>lu</small> <small>ru</small>`｜調整/定製（fit/customize）｜2 `|`.!._ i. 6

`!:`｜`)`｜連詞｜`0 0 0`｜外界（foreign）/系統函數｜6!:0 `''`

### 雜類

J詞彙｜APL符號｜詞類｜秩｜含義｜例子

`=.`｜`←`｜系詞｜是（is），局部作用域（local）｜`loc=. 1 2`

`=:`｜系詞｜是（is），全局作用域（global）｜`'a b' =: 3 ; 4`

`NB.`｜`⍝`｜系詞｜注釋（comment）｜`NB. for comments`

'字串'｜名詞｜字串（character string）｜`'Hello, World!'`

`_`｜`¯` `∞`｜名詞｜負號（negative sign）/ 無窮（infinity）｜`_3 = -3`

0$0｜`⍬`｜空數值向量（empty numeric vector）｜`$ 0$0`

`a:`｜名詞｜Ace (撲克牌)即盒裝空值（boxed empty）｜`a: -: <0$0`

`[`｜`⊣`｜動詞｜`_ _ _`｜相同（same）· 左參數（left）｜`p=: 3 [ q=: 5`

`]`｜`⊢`｜動詞｜`_ _ _`｜相同（same）· 右參數（right）｜`i."0 ] 3 4 5`

`[:`｜動詞｜遮帽（cap）｜`({~ [: ? #) 3 1 4`

`".`｜`⍎`｜動詞｜`1 _ _`｜執行（do）· 數值（numbers）｜`9999 ". '56 NULL'`

`":`｜`⍕`｜動詞｜`_ 1 _`｜預設格式（default format）· 格式（format）｜`10j2 ": 6`

`{{&nbsp;`｜{`&nbsp;`}｜控制｜直接定義（direct definition）｜dist=: `{{`%:+/、:x-y

`:`｜`∇`｜連詞｜定義（definition）｜add=: 0&$: : `{{`x+y

`$:`｜動詞｜`_ _ _`｜自引用（self-reference）｜fact=: 1:`(、$:@<:)@.*

## 定語

J語言的能力，很大程度上來自它的「定語」（modifier：修飾詞），這個範疇包括「副詞」和「連詞」：這些符號接受名詞和動詞作為運算元（operand），並以指定方式應用這些運算元。定語都可以應用於任何動詞，包括使用者寫的動詞，使用者可以寫自己的定語。

J語言的二元動詞有右結合性，或稱為儘量長右作用域，即它有儘可能多的右參數。定語即算子有左結合性，或稱為儘量長左作用域，即它有儘可能多的左運算元。如果表達式中存在定語即算子，首先應用這些定語，然後應用其生成的動詞。

### 副詞

一元副詞`/`「插入」（insert），副詞`\`「前綴·中綴」（prefix·infix），副詞`\.`「後綴·外綴」（suffix·outfix），和連詞`;.`「剪切」（cut），指定參數的諸個規則或不規則子集，並在其上執行運算。在J語言實現中，前綴和`+/\`、極小值`<./\`和極大值`>./\`運算，是典型的會對其進行速度優化的特殊組合。

副詞`~`「反身·被動」（reflex·passive），其一元形式`f~ y`↔`y f y`，將提供給動詞的右參數重複放置在左參數位置上；二元形式`x f~ y`↔`y f x`，將提供給動詞的左右兩個參數對換位置。

### 秩

名詞的秩（rank）是排布其原子所依據的軸的數目，即它的形狀中項目的數目。動詞的秩是它能夠在其上直接運算的右（和左）名詞參數的最高秩，典型的表示為三個原子的一個列表：`<small>一元秩</small> <small>二元左秩</small> <small>二元右秩</small>`。對副詞和連詞標示的秩，是所形成的動詞的秩。

秩在特定動詞和特定名詞的上下文下，將名詞的諸維，劃分成前綴諸維的序列，稱為框架（frame）；和後綴諸維的序列，稱為單元（cell）。秩採用連詞`"`「秩」來操縱，對應於APL符號`⍤`，它有三種形式：`u"n`「指定秩」（assign），`m"n`「常量動詞」（constant），`u"v`和`m"v`「複製秩」（copy），這裡的`u`、`v`表示動詞運算元，而`m`、`n`表示名詞運算元。正數動詞秩，指示單元諸維的數目，負數動詞秩，指示框架諸維的數目，`_`指示整體。

二元動詞的左右參數的框架經常是匹配的，就是說二者有相同的形狀，從而保證了它們有相同數目的單元。如果左右參數的框架不匹配，有三種可以運算的情況：

- 標量一致，如果指定了兩參數中某一側的框架為空，即秩為`_`，這一個整體單元被應用於另一側參數的所有單元。
- 前綴一致，兩參數中有一側的短框架是另一側長框架的前綴，短框架的每個單元，被應用於對應的長框架去掉前綴餘下諸維形成的單元陣列的所有單元。
- 後綴一致，兩參數中有一側的短框架是另一側長框架的後綴，這時需要以兩側加上相同正數增量的方式指定秩，使原短框架側的框架為空，原短框架的諸維形成的這一個單元陣列，被應用於原長框架去掉後綴餘下諸維形成陣列的每個單元陣列。

### 複合連詞

連詞`@:`「在於」（at）、`@`「頂上」（atop）、`&:`「並列」（appose）、`&`「合成」（compose），是四種複合（composition）。J語言支持叫作「鉤子」（hook）和「叉子」（fork）的隱形連詞，二種隱形連詞和四種複合連詞，規定了如何將參數或將所飾動詞應用於參數的結果，提供給所飾動詞來進行應用的規則。下表列出它們的定義：

連詞｜APL符號｜一元｜二元｜秩

鉤子｜(u v) y ↔ y u (v y)｜x (u v) y ↔ x u (v y)｜`_ _ _`

叉子｜(f g h) y ↔ (f y) g (h y)｜x (f g h) y ↔ (x f y) g (x h y)｜`_ _ _`

`@:`｜`⍤`｜(u @: v) y ↔ u (v y)｜x (u @: v) y ↔ u (x v y)｜`_ _ _`

`@`｜(u @ v) y ↔ (u @: v)"v y｜x (u @ v) y ↔ x (u @: v)"v y｜`mv lv rv`

`&:`｜`⍥`｜同於`@:`而應棄用｜x (u &: v) y ↔ (v x) u (v y)｜`_ _ _`

`&`｜同於`@`而應棄用｜x (u & v) y ↔ x (u &: v)"mv y｜`mv mv mv`

在上面表格中，`mv=: 0{v b.0`，`lv=: 1{v b.0`，`rv=: 2{v b.0`，這裡的副詞`b.0`給出動詞`v`的三個秩。在應用四種複合連詞形成新動詞的表達式中，`@:`和`&:`，要對第一步運算的中間結果，按所在子表達式的秩或整個表達式的秩`_`進行匯集（assembly），並在有需要的情況下進行框架填充，然後在這個匯集成的框架內進行第二步運算；而`@`和`&`，直接在第一步運算的框架內，對中間結果進行第二步運算；在整個表達式求值結束時，最終結果在有需要的情況下要進行整體填充。

在x (u @ v) y中，一元`u`直接在二元`v`所劃分的框架內進行自己的運算。在x (u @: v)"v y中，`@:`將二元`v`的運算結果，匯集成`"v`所指定的框架。在x (u & v) y，二元`u`直接在一元`v`所劃分的兩個框架內進行自己的運算。在x (u &: v)"mv y中，`&:`將一元`v`的兩個運算結果，匯集成`"mv`所指定的框架。

下面例子展示四種複合的中間結果的單元差異：

```j
   ] a =: >:i. 2 3
1 2 3
4 5 6
   ] b =: 0.1*>:i. 2
0.1 0.2
   a (< @: +) b
┌───────────┐
│1.1 2.1 3.1│
│4.2 5.2 6.2│
└───────────┘
   a (< @ +) b
┌───┬───┬───┐
│1.1│2.1│3.1│
├───┼───┼───┤
│4.2│5.2│6.2│
└───┴───┴───┘
   a (; &: |) b
┌─────┬───────┐
│1 2 3│0.1 0.2│
│4 5 6│       │
└─────┴───────┘
   a (; & |) b  NB. 这里的框架仍是2 3
┌─┬───┐
│1│0.1│
├─┼───┤
│2│0.1│
├─┼───┤
│3│0.1│
└─┴───┘

┌─┬───┐
│4│0.2│
├─┼───┤
│5│0.2│
├─┼───┤
│6│0.2│
└─┴───┘
```

當連詞`&`的一個運算元是名詞的時候，表示「粘上」（bond），它通過向二元動詞固定提供其一個參數的值而產生一個動詞：

連詞｜APL符號｜秩

`&`｜`∘`｜`_ 0 _`

`&`派生的動詞經常作為一元動詞使用，即m&v y或u&n y；如果作為二元動詞使用，即x m&v y或x u&n y，左參數表示應用這個派生動詞於右參數的次數。需要確保通過`&`定義的一元動詞，不出現在能夠取用左右兩個的參數的上下文中；如此定義的二元動詞，也不應該出現在只能取用一個右參數的上下文中。需要注意`m&v`、`v/`和`v\`等的左參數的作用域，有時遇到其左側的複合連詞會產生並非預期的效果，經常需要將表達式整體加以圓括號包圍。

J語言還提供連詞`&.:`「底下」（under）和`&.`「對偶」（dual）。下面定義中的動詞冪`^:_1`表示逆運算：

連詞｜APL符號｜定義｜秩

`&.:`｜`⍢`｜u &.: v ↔ v^:_1 @: u &: v｜`_ _ _`

`&.`｜u &. v ↔ (u &.: v)"mv｜`mv mv mv`

`@`、`&`和`&.`合稱為「緊密複合」（close composition）。現代APL中另有`¨`「每個」（each），`f¨`相當於J語言中的`f &.>`。例如：

```j
   1 2 + &.:> 0.1 0.2
┌───────┐
│1.1 2.2│
└───────┘
   1 2 + &.> 0.1 0.2
┌───┬───┐
│1.1│2.2│
└───┴───┘
```

在J語言中，孤立的動詞序列叫做「列車」（train）， `e f g h`意味著`(e (f g h))`，`d e f g h`意味著`(d e (f g h))`；以此類推，動詞列車的一般模式`(a b c ...)`，依賴於動詞的數目，在偶數時形式為`(a (b c ...))`，最外層是個鉤子；而在奇數時形式為`(a b (c ...))`，最外層是個叉子；二者的內部都是可能有多層的嵌套的叉子。

叉子、`@:`再加上`[`和`]`，可以將很多常用複合寫為列車。在慣用法`([: f g)`中，並不實際執行的隱式動詞`[:`「遮帽」（cap），屏蔽了叉子的左分支，形成了等價於`f @: g`的特殊化叉子。

與現代APL如Dyalog等對照，複合連詞`@:`對應於同秩連詞共享APL符號`⍤`的「頂上」（atop），而`&:`對應於`⍥`「上方」（over），共享`&`符號的「粘上」，對應於APL中的「綁上」（bind），APL的「綁上」和「邊上」（beside）共享符號`∘`，「邊上」的一元形式同於`⍤`，而二元形式同於鉤子。在《APL字典》中，`@`對應其`⍥`，而`&`列入秩連詞`⍤`之內，鉤子對應於符號`⍩`「枝條」（withe），`&.`對應於符號`¨`。

#### 用例

下面的簡單例子是計算歐幾里得範數，和生成數位與維度坐標一致的整數：

```j
   ]d=: (1 1),(1 1 1),:(3 4)
1 1 0
1 1 1
3 4 0
   norm=: %: @ (+/) @: *:"1    NB. 它可加圆括号为((%: @ (+/)) @: *:)"1
   norm d
1.41421 1.73205 5
   coor=: 10&#. @ > @ { @: (< @: >: @ i."0)
   coor 2 3 4
111 112 113 114
121 122 123 124
131 132 133 134

211 212 213 214
221 222 223 224
231 232 233 234
```

在`coor`中採用的圓括號包圍，使得`@:`處在整個表達式的最外層，從而形成了兩步驟運算；右側的第一步是圓括號包圍的子表達式，它的完全加圓括號（fully-parenthesized）形式為：`(((< @: >:) @ i.)"0)`；左側的第二步是`{`與複合到其上諸運算構成的子表達式，它的完全加圓括號形式為：`(((10 & #.) @ >) @ {)`。一元動詞`{`「目錄彙編」（catalogue），應用在盒裝列表的列表之上，是接受可變數目的變長參數的典型的動詞。

下面通過對圓括號包圍的子表達式加以變化，辨析秩連詞和複合連詞的特性。這裡的動詞`]`，劃分開了給連詞或副詞的名詞運算元，和給所生成的動詞的名詞參數：

```j
   ]a=: < @: >: @ i."0 ] 2 3 4    NB. 运算式可加圆括号为((< @: >:) @ i.)"0
┌───┬─────┬───────┐
│1 2│1 2 3│1 2 3 4│
└───┴─────┴───────┘
   a -: < @: (>: @ i.)"0 ] 2 3 4  NB. 运算式可加圆括号为(< @: (>: @ i.))"0
1
   a -: < @ (>: @ i."0) 2 3 4     NB. 运算式可加圆括号为< @ ((>: @ i.)"0)
1
   < @ >: @ i."0 ] 2 3 4          NB. 运算式可加圆括号为((< @ >:) @ i.)"0
┌─┬─┬─┬─┐
│1│2│ │ │
├─┼─┼─┼─┤
│1│2│3│ │
├─┼─┼─┼─┤
│1│2│3│4│
└─┴─┴─┴─┘
   < @: (>: @ i."0) 2 3 4         NB. 运算式可加圆括号为< @: ((>: @ i.)"0)
┌───────┐
│1 2 0 0│
│1 2 3 0│
│1 2 3 4│
└───────┘
```

下面的例子展示並聯電阻電路計算：$\frac{1}{R_\mathrm{total}} = \frac{1}{R_1} + \frac{1}{R_2} + \cdots + \frac{1}{R_n}$，它可以如下這樣表達：

```j
   Rtotal=: +/ &.: %
   Rtotal 10 5 15
2.72727
```

### 動詞冪

連詞`^:`動詞冪」（power of verb），有兩種形式：

- `^:n`，是運算元為名詞的「固定冪」。
- `^:v`，是運算元為動詞的「動態冪」。

對於固定冪`u ^:n`，如果`x`缺席，`u ^:n y`在以`y`為運算對象的迭代中，將動詞`u`應用`n`次；如果`x`存在，`x u ^:n y`在以`y`為運算對象的迭代中，將動詞`x&u`應用`n`次。如果`n`是陣列，則按每個原子項目都執行一次動詞冪，結果的框架為這個陣列的形狀；如果`n`是取值為`0`或`1`的變量，則形成布爾值條件執行；如果`n`是`_1`，則進行`u`的逆運算；如果`n`是`_`，則意味著「收斂」（converge），即反覆應用`u`直到結果不再變化。例如：

```j
   (1+*&3) ^:0 1 ] 1 2 3 4
1 2  3  4
4 7 10 13
   ' ' , ^:4 'abc'
    abc
   (1+*&3) ^:_1 ] 4 7 10 13
1 2 3 4
   (-:@(]+%)) ^:_ &1 ] 0.25 3 25  NB. 以巴比伦方法即一种牛顿法特例来计算平方根
0.5 1.73205 5
```

對於動態冪`u ^:v`，如果`x`缺席，`u ^:v y`在以`y`為運算對象的迭代中，將動詞`u`應用`v y`次；如果`x`存在，`x u ^:v y`在以`y`為運算對象的迭代中，將動詞`x&u`應用`x v y`次。動詞冪可以形成動態條件執行，這裡的動詞`v`必須總是產生布爾值結果，應用動詞`u`若且唯若`v`返回`1`。進而`u ^:v ^:_ y`可以形成while循環構造，只要`v`返回`1`，就反覆的執行`u`，直到`v`返回`0`，或者`u`將它的參數無變化的返回。例如：

```j
   -&2 ^:(>&4) "0 ] 1 3 6 12                    NB. 对大于阈值4的列表项目减去2
1 3 4 10
   4 (0.25&*@[+(1-0.25)&*@]) ^:< "0 ] 1 3 6 12  NB. 对大于阈值4的列表项目在其超出部份上扣除25%
1 3 5.5 10
   +&3 ^:(<&100) ^:_ "0 ] 2 3 100               NB. 只要列表项目小于100就对它加上3
101 102 100
```

#### 用例

下面的例子用來辨析秩指定與框架劃分及匯集的性質，其中涉及的直接定義等內容可見於後面的定義章節：

```j
   itemize=: ,: : {{,: ^:x ] y}}"(0 _)  NB. 定义具有一元和二元两种形式的项目化扩秩运算
   <@itemize~ i.3
┌─────┬─────┬─────┐
│0 1 2│0 1 2│0 1 2│
└─────┴─────┴─────┘
   $&.> <@itemize~ i.3
┌─┬───┬─────┐
│3│1 3│1 1 3│
└─┴───┴─────┘
   $ <"2@itemize~ i.3
3 1
   $&.> <"2@itemize~ i.3
┌───┐
│3  │
├───┤
│1 3│
├───┤
│1 3│
└───┘
   $ <"_1@itemize~ i.3
3 3
   $&.> <"_1@itemize~ i.3
┌───┬─┬─┐
│   │ │ │
├───┼─┼─┤
│3  │0│0│
├───┼─┼─┤
│1 3│0│0│
└───┴─┴─┘
   #&.>@<"_1@itemize~ i.3
┌─┬─┬─┐
│1│1│1│
├─┼─┼─┤
│3│ │ │
├─┼─┼─┤
│1│ │ │
└─┴─┴─┘
   $ 1

   $ 0$0
0
   # 0$0
0
   $ <"1@itemize~ i.3
3 1 1
   $ <"_2@itemize~ i.3
3 1 3
   $ <"0@itemize~ i.3
3 1 1 3
   $ <"_3@itemize~ i.3
3 1 1 3
```

### 動名詞

在J語言中，動名詞（gerund）是叫做「原子表示」的特殊盒子的一個列表，這種盒子可以像任何其他盒子一樣使用，並可以最終轉變回到要執行的動詞。關於動名詞的運算有：

- 連詞`「連結動名詞」（tie or gerund），建立動名詞。
- 連詞`:「喚起動名詞」（evoke gerund），在加以運算元之後成為：
- `:6，將動名詞轉變成動詞列車。
- `:0，將轉變回來的這些動詞分別單獨應用，並將它們的結果收集入一個列表。
- 連詞`@.`「議程」（agenda），`m @. n`從動名詞`m`中，選擇出第`n`個原子表示，將它轉變回到動詞並執行它。

下面是動名詞簡單示例和考拉茲猜想示例：

```j
   grd =: * ` (+&2)  NB. 建立一个动名词
   grd               NB. 显示原子表示，这里的符号'0'标识名词
┌─┬─────────────┐
│*│┌─┬─────────┐│
│ ││&│┌─┬─────┐││
│ ││ ││+│┌─┬─┐│││
│ ││ ││ ││0│2││││
│ ││ ││ │└─┴─┘│││
│ ││ │└─┴─────┘││
│ │└─┴─────────┘│
└─┴─────────────┘
   {. grd            NB. 动名词可以像普通盒子一样操纵
┌─┐
│*│
└─┘
   grd `:6 i. 4      NB. 将动名词转换成动词列车来执行
0 3 8 15
   grd `:0 i. 4      NB. 将动名词转换成并行执行的动词
0 1 1 1
2 3 4 5
   Collatz=: -: ` (1+*&3) @. (2&|)  NB. 考拉兹猜想的算式
   Collatz "0 ] 1 2 3 4 5 6 7
4 1 10 2 16 3 22
   >./@(Collatz^:(>&1)^:_"0@>:@?@$&1e6) 1000  NB. 取1000个在1e6内的随机数测试考拉兹猜想
1
```

## 定義

J語言支持使用者進行顯式定義，和``形式的直接函數。下面以五種複合作為顯式定義的例子：

```j
   at=: conjunction define
    u (v y)
   :
    u (x v y)
   )
   atop=: conjunction def '(u at v)"v'
   beside=: conjunction define
    u (v y)
   :
    x u (v y)
   )
   appose=: conjunction define
    u (v y)
   :
    (v x) u (v y)
   )
   compose=: conjunction def '(u appose v)"(0{v b.0)'
```

下面以矩陣乘法作為直接定義的例子，並順帶演示秩連詞的用法：

```j
   a=: ? @ $&1000 @: >: 4?10
   b=: |: a
   p=: a (+/ . *) b
   matmul=: {{x u@:v"(1 _) y}}
   (a (+/ matmul *) b) -: p
1
   inner=: {{x (u@:v"1)"(1 _) y}}
   (a (+/ inner * 0&|:) b) -: p
1
   outer=: {{x u@(v/"_1~ |:)~"(2 _) y}}
   (a (+/ outer *) b) -: p
1
   revmul=: {{x (i.<:#$y)&|:@(u@:v"(_ 1)~ |:)~"(2 _) y}}
   (a (+/ revmul * 0&|:) b) -: p
1
```

APL傳統上的將內積Pf.gQ解釋為f/PgQ，J語言的矩陣乘法要求寫為Pf/ .gQ，不隱含的為左運算元`f`附加一元`/`。轉置也是有較大開銷 (計算)的運算，不同的矩陣乘法算法有不同的參照局部性。

- `matmul`通過`"(1 _)`將`u@:v`的右參數從向量擴展為一般陣列，它用於右參數為行主序和列主序陣列的情況。在向量與向量列表二者諸項之間逐對的進行乘積累加運算，是BLAS的標準演算法。
- `inner`採用了兩向量之間的點積運算`u@:v"1`，它適宜直接用於右參數為行主序和列主序陣列的情況。在右參數為行主序陣列之時，需要如例子代碼這樣，對右參數陣列進行二元轉置`0&|:`，這裡的`0`指示將第一軸安排至最後位置而其他軸保持原序前移。這種基於點積的實現，通常需要進一步加以循環嵌套優化。
- `outer`可以看作`matmul`的變體，它首先對左參數陣列進行轉置，然後進行多組的向量與一般陣列之間二元的張量積運算`v/"_1`，最後在各組結果的列表上進行`u`計算，每組運算之後參與其中的左右兩陣列的元素不會被其他組的運算再次訪問。
- `revmul`同`inner`一樣適宜直接用於右參數為列主序陣列的情況，但採用了同`matmul`類似的計算方法，它在乘法之前對左參數陣列和在乘法之後對結果要做轉置，`matmul`與`revmul`的關係如同$\,(\mathrm{AB})^\mathsf{T} = \mathrm{B}^\mathsf{T}\mathrm{A}^\mathsf{T}\,$。`matmul`一次性訪問左參數陣列，反覆多次訪問右參數陣列；`revmul`一次性訪問右參數陣列，反覆多次訪問左參數陣列。

在隱式定義中，遞歸定義可以不通過名字引用自身，轉而使用動詞`$:`「自引用」。例如遞歸的計算斐波那契數列：

```j
   fibonacci=: 1: ` ($:@-&2 + $:@<:) @. (>&2) "0 : [:
   fibonacci >:i.9
1 1 2 3 5 8 13 21 34
```

`_9:`到`9:`是常量動詞。動詞`[:`「遮帽」，用在連詞`u : v`「一元與二元定義」所應用的動詞位置上，即充任了一元動詞`u`或二元動詞`v`，可分別在如下兩種情況下報錯：定義的是二元動詞，卻不適當的被用作一元動詞；或定義的是一元動詞，卻不適當被用作二元動詞。

在顯式定義和直接定義中，提供了類似其他過程語言的控制結構。這裡列出的是每個範疇內的代表性控制字：

範疇｜控制結構

斷言觸發｜`assert.`

返結果退出｜`return.`

跳轉到標號｜`goto_lbl. label_lbl.`

條件執行｜`if. T do. B else. B1 end.`

情況執行｜`select. T case. T0 do. B0 end.`

條件循環｜`while. T do. B end.`

逐項執行｜`for_ijk. A do. B end.`

終止循環｜`break.`

終止本次迭代｜`continue.`

嘗試執行捕獲異常｜`try. B catch. B1 end.`

拋出異常｜`throw.`

## 索引

J語言的索引機制採用二元`{`「來自」（from）動詞來完成，它的秩為`0 _`，它有兩種形式，分別為左參數為索引陣列的主軸索引，和左參數為二層或一層盒裝結構的逐軸索引，二者分別對應APL中，方括號內為單個軸的主軸索引選取，和方括號內為`;`分隔的多個軸的逐軸索引選取。

### 主軸索引

索引陣列的每個項目指定對主軸的項目單元的一個選取，將它們的結果再匯合為一個陣列。負值索引表示從末尾往前記數。在APL中，這種形式的索引被稱為「來自」（from），也叫做「選取」（select）或幽默地稱為「明智」（sane）索引，最早出現在SAX（SHARP APL for UNIX）對其`@`「來自」索引的擴展中，部份現代APL，將它表示為符號`⊇`。例如：

```j
   i. 2 3
0 1 2
3 4 5
   1 0 { i. 2 3
3 4 5
0 1 2
   1 0 {"1 i. 2 3
1 0
4 3
   (i. 2 3) { 'abcdefg'
abc
def
   _1 { 'abcdefg'
g
```

### 逐軸索引

逐軸選取可以形成子陣列，在現代APL中，它被表示為`⌷`，故而也被稱為「扁方塊」（squad：squish quad）索引（indexing）或就叫做「索引」（index）函數。裝在二層盒裝結構中的，是對應諸軸的一層盒裝子結構的列表，其中每個一層盒裝子結構內都是數值列表，它對應在此軸內一個或多個項目選擇。默認全選使用名詞`a:`「麼點」（ace）指示，它是盒裝空列表`<0$0`。在尾部的連續多個默認全選不需要寫出。例如：

```j
   i. 3 4
0 1  2  3
4 5  6  7
8 9 10 11
   (<<1 2) { i. 3 4
4 5  6  7
8 9 10 11
   (<1 2;0 2 3) { i. 3 4
4  6  7
8 10 11
   (<a:;0 2 3) { i. 3 4
0  2  3
4  6  7
8 10 11
   (<a:;0 2 3)
┌──────────┐
│┌──┬─────┐│
││┌┐│0 2 3││
│││││     ││
││└┘│     ││
│└──┴─────┘│
└──────────┘
```

它還支持一層盒裝結構，裝在其中的是數值列表，它的元素指示每軸選取一個項目，如果單選了所有軸，則指定一個原子項目。一層盒裝結構中的這個數值列表，等價於二層盒裝結構中一層盒裝的單一數值的列表。兩種索引形式可以結合使用，即可以將盒裝結構的陣列作為給`{`的左參數，它按這個陣列的形狀匯合多個逐軸選取的結果。例如：

```j
   (<1 2) { i. 3 4
6
   ((<0 0),(<2 2),(<1 1)) { i. 3 4
0 10 5
   (<0 0),(<2 2),(<1 1)
┌───┬───┬───┐
│0 0│2 2│1 1│
└───┴───┴───┘

```

例如`(<<1 2),(<a:;0 2 3)`這樣的選取是合法的，將形狀不一致的選取結果匯合在一起，會導致結果值填充。

### 重排軸

重排軸也叫做二元轉置。APL的二元轉置對軸次序的指定，類似於組合數學中置換的一行形式的柯西表示法，它被稱為「可能是APL編程者最後掌握的原始運算之一」。J語言的二元轉置對軸次序的指定，不涉及將多個軸映射到結果中的一個軸的情況，使用了普通的索引形式的置換向量

```J
   transpose=: {{(/: x) |: y}}
   a=: >:i. 2 3 5 7
   $ a
2 3 5 7
   p=: 2 3 4 1
   $ p transpose a
7 2 3 5
```

在置換向量的元素個數小於陣列軸的數目之時，J語言在置換結果中將其指定的諸軸安排在尾部，而其他軸保持原來相對次序前移。

針對向量的索引運算，是不加盒裝的主軸索引。要訪問一般陣列的特定原子項目，其選取向量需要一層盒裝，從而對其進行逐軸索引。置換向量`p`所對應的逆向置換向量是/:p，對於兩個置換向量`p`和`q`，則有 ↔。

二元轉置與索引機制有密切關聯，它有兩個重要性質

```j
   (<k){i|:j|:a
   (<(/:i){k){j|:a
   (<(/:j){(/:i){k){a
   (<k){(/:(/:j){(/:i))|:a
   (<k){(i{j)|:a
```

- 兩次連續的二元轉置，可以變換成等價形式：`p|:q|:A` ↔ `(p{q)|:A`，即先將後者置換向量`p`對前者置換向量`q`進行置換，然後用結果的置換向量做一次二元轉置。
- 對二元轉置後的陣列，進行原子項目的選取，可以變換成等價形式： ↔，即先用置換向量`p`的逆置換向量`/:p`，對選取向量`k`進行置換，然後用結果的選取向量來選取未轉置陣列。

下面是演示例子代碼：

```j
   a=: ? @ $&1000 @: >: 4?10
   n=: # @ $ a
   p=: ?~ n
   q=: ?~ n
   (/:/:p) -: p
1
   ((/:p) { p) -: i. n
1
   (/: p{q) -: (/:q) { /:p
1
   (p |: q|:a) -: (p{q) |: a
1
   k=: ? $ p |: a
   ((<k) { p|:a) -: (<(/:p){k) { a
1
```

## 示例

### 帕斯卡三角

下面例子形成帕斯卡三角的二項式係數的直接定義，並順帶展示基本的矩陣與盒裝運算：

```j
   pascal=: {{(0&, + ,&0) ^: y 1}}"0
   pascal @ i. ] 5
1 0 0 0 0
1 1 0 0 0
1 2 1 0 0
1 3 3 1 0
1 4 6 4 1
   ({. (+//. @: pascal @ i.)) 9      NB. 斐波那契数列
1 1 2 3 5 8 13 21 34
   ((+/ . *) |:) @: pascal @ i. ] 5  NB. 帕斯卡矩阵
1 1  1  1  1
1 2  3  4  5
1 3  6 10 15
1 4 10 20 35
1 5 15 35 70
   <"0 @ pascal @ i. ] 5
┌─┬─┬─┬─┬─┐
│1│ │ │ │ │
├─┼─┼─┼─┼─┤
│1│1│ │ │ │
├─┼─┼─┼─┼─┤
│1│2│1│ │ │
├─┼─┼─┼─┼─┤
│1│3│3│1│ │
├─┼─┼─┼─┼─┤
│1│4│6│4│1│
└─┴─┴─┴─┴─┘
   ]t=: < @ pascal @ i. ] 5
┌─┬───┬─────┬───────┬─────────┐
│1│1 1│1 2 1│1 3 3 1│1 4 6 4 1│
└─┴───┴─────┴───────┴─────────┘
   (<@#&a:"0@|.@i.@# ,&> }:@,@:(,.&a:@<"0)&.>) t
┌─┬─┬─┬─┬─┬─┬─┬─┬─┐
│ │ │ │ │1│ │ │ │ │
├─┼─┼─┼─┼─┼─┼─┼─┼─┤
│ │ │ │1│ │1│ │ │ │
├─┼─┼─┼─┼─┼─┼─┼─┼─┤
│ │ │1│ │2│ │1│ │ │
├─┼─┼─┼─┼─┼─┼─┼─┼─┤
│ │1│ │3│ │3│ │1│ │
├─┼─┼─┼─┼─┼─┼─┼─┼─┤
│1│ │4│ │6│ │4│ │1│
└─┴─┴─┴─┴─┴─┴─┴─┴─┘
```

二項式係數也可以寫成隱式定義形式：

```j
   pascal=: ((0&, + ,&0)@] ^:[ 1:)"0 : [:
```

### 簡易圖表

下面是基於二元副詞`/`「形成表格」（table），製作條形圖和散點圖的簡易圖表例子：

```j
   barChartH=: {&('.',u:16b2584) @ (>/ i.@(>./)) : [:
   barChartH 3 1 4 1 5 9 2 6 5
▄▄▄......
▄........
▄▄▄▄.....
▄........
▄▄▄▄▄....
▄▄▄▄▄▄▄▄▄
▄▄.......
▄▄▄▄▄▄...
▄▄▄▄▄....
   barChartV=: {&('.',u:16b258c) @ (</~ |.@i.@(>./)) : [:
   barChartV 3 1 4 1 5 9 2 6 5
.....▌...
.....▌...
.....▌...
.....▌.▌.
....▌▌.▌▌
..▌.▌▌.▌▌
▌.▌.▌▌.▌▌
▌.▌.▌▌▌▌▌
▌▌▌▌▌▌▌▌▌
   scatterChart=: {&('.',u:16b2588) @ (=/~ >:@|.@i.@(>./)) : [:
   scatterChart 3 1 4 1 5 9 2 6 5
.....█...
.........
.........
.......█.
....█...█
..█......
█........
......█..
.█.█.....
```

這裡用到的Unicode方塊元素字符也出現在IBM PC代碼頁437之中。

這裡的`scatterChart`可以使用二元副詞`}`「修改」（amend）來實現：

```j
   scatterChart=: {&('.',u:16b2588) @ ((>./ , #) {{
    1 y } $&0 x}} (#~ <&9@{."1)@((-~ >./) ,. i.@#)) : [:
```

### 對角線選取

APL的二元轉置，在多個軸映射到結果中的一個軸的情況下，將其依次安排到前導位置上並進行對角線選取。下面基於一元動詞`I.`「真值位置索引」，定義進行對角線選取的動詞`diag`，它的左參數是布爾值列表，其中的真值`1`指示與其位置對應的軸，要依次安排在前導位置上並進行對角線選取，其他的假值`0`所對應的軸相對位置不變。

```j
   diag=: {{
    s=. (I. , I.@:-.) @ ({.~ #@$)
    t=. <"1 @ (i.@(<./)@({. $) */ #&1@[)
    ({~ (+/x)&t) @ (|:~ x&s) y}}
```

這裡局部定義了`s`，它的左右參數同於給`diag`的參數，它生成二元轉置需要的置換向量，這是由要安排到前導位置上的那些軸的位置索引，和餘下其他軸的位置索引串接而成。這裡的`{.~ #@$`以右參數的諸軸數目選取左參數，用來在左參數的真值和假值的總數小於右參數的諸軸數目之時，對左參數填充上假值。

接著局部定義了`t`，它的左參數是給`diag`的布爾值列表中真值`1`的個數，右參數是要對其指定數目的前導軸進行對角線選取的陣列，它生成對角線選取所需要的一層盒裝選取列表。這裡的`(<./)@({. $)`選取出要進行對角線選取的前導諸軸的最小長度，用`i.`形成這個長度的整數數列，再用`#&1@[`形成其長度為左參數的全為`1`的列表，通過`*/`在二者之上形成表格矩陣。

最後的表達式先進行指定的二元轉置，再對其結果進行相應的對角線選取。下面是簡單用例：

```j
   >:i. 3 5
 1  2  3  4  5
 6  7  8  9 10
11 12 13 14 15
   1 1 diag >:i. 3 5
1 7 13
   i. 2 3 2
 0  1
 2  3
 4  5

 6  7
 8  9
10 11
   1 1 diag i. 2 3 2
0 1
8 9
   0 2 1 |: i. 2 3 2
0 2  4
1 3  5

6 8 10
7 9 11
   1 0 1 diag i. 2 3 2
0 2  4
7 9 11
```

### 快速排序

J語言提供的排序機制基於了穩定排序算法，下面的例子代碼是快速排序的直接定義：

```j
   cmp=: * @ -
   quicksort=: {{
    if. 1 >: #y do. y return. end.
    s=. y u y {~?# y
    (u quicksort (s<0)#y),((s=0)#y),(u quicksort (s>0)#y)}}
```

這裡定義一個動詞`cmp`，它通過逐個做兩個數的差並取其符號，得到取值為`_1`、`0`或`1`的平衡三進位值。`cmp`將作為左運算元傳遞給副詞`quicksort`。

在`quicksort`的定義中，向局部變量`s`賦值的表達式，第一步隨機選擇支點（pivot）運算，首先計算`?#y`，生成在數據總個數範圍內的隨機數，接著在其上計算`{~`，選擇出在隨機數指定的位置上的支點值；它的第二步運算，將運算元`u`，應用到其左參數的數據列表，和右參數的支點值二者之上。

隨後是串接分治運算結果，首先將平衡三進位值列表，分別與`0`做逐項的三分法比較，得到三個布爾值列表；然後以這種列表中的`0`和`1`作為件數，複製出數據列表的符合這個條件一個新的子列表，其中兩個作為參數傳遞給遞歸調用進行排序。

下面的快速排序實現，展示了隱式編程，即將函數複合在一起，而不顯式的引用任何變量，不提及要應用於其上的形式參數。這裡將前面代碼中向局部變量`s`賦值時所求值的表達式改為隱式定義，進而以作為鉤子的第一步運算的方式，代入引用這個變量的表達式之中，並且採用鉤子的參數複製機制消隱了形式參數`y`：

```j
   cmp=: * @ -
   quicksort=: {{((($:@#~ <&0),(#~ =&0),($:@#~ >&0)) (u ({~ ?@#))) ^: (1<#) y}}
   cmp quicksort 2 0 4 7 15 9 8 0 4 9 18 8 1 18
0 0 1 2 4 4 7 8 8 9 9 15 18 18
```

提供給連詞`^:`的左側運算元，外層是個一元鉤子，它將提供給它的單一右數據參數，重複放置在它的左數據參數位置上。這個外層一元鉤子的第一步運算，是生成平衡三進位值列表的嵌套的二層一元鉤子`(u ({~ ?@#))`；而外層一元鉤子的第二步運算，將生成的三個子列表串接起來。生成三個子列表的表達式，以數據列表是作為左參數，以平衡三進位值列表作為右參數；這裡的三個二元鉤子首先生成布爾值列表，接著進行對換了左右參數位置的二元複製運算，最後它們中有兩個通過自引用`$:`進行了遞歸調用。

這個定義中的`$:`是在這個副詞的私有語境內調用的動詞，所以不像前面直接定義那樣需要加上運算元`u`以副詞形式來調用。這裡沒有對字串長度小於等於`1`的情況進行處理，這是因為迭代運算在條件不滿足時返回初始值，也就是返回這個字串本身。將`cmp`的表達式，代入定義中的左運算元`u`，就能定義出動詞，同時也不再需要外在的採用直接定義的形式。

將一元鉤子替代為左分支為`]`的叉子，形成的動詞列車更具可讀性：

```j
   quicksort=: {{(] (($:@#~ <&0),(#~ =&0),($:@#~ >&0)) ] u ] {~ [:?#) ^: (1<#) y}}
```

下面的例子定義基於一元`/:`進行字串比較的`cmp`：

```j
   cmp=: -/ @ (-.@-: * /:@;)
   'alpha' cmp 'beta'
_1
   'beta' cmp 'alpha'
1
   'beta' cmp 'beta'
0
   t=: ' the heart has its reasons that the reason does not know'
   ]words=: <;._1 t
┌───┬─────┬───┬───┬───────┬────┬───┬──────┬────┬───┬────┐
│the│heart│has│its│reasons│that│the│reason│does│not│know│
└───┴─────┴───┴───┴───────┴────┴───┴──────┴────┴───┴────┘
   cmp&> quicksort words
┌────┬───┬─────┬───┬────┬───┬──────┬───────┬────┬───┬───┐
│does│has│heart│its│know│not│reason│reasons│that│the│the│
└────┴───┴─────┴───┴────┴───┴──────┴───────┴────┴───┴───┘
```

在這個`cmp`定義中，`/:@;`先將兩個字串參數進行盒裝串接，然後一元`/:`給出二者的升序索引，二者之間為升序或相同時為`0 1`，而二者為降序時為`1 0`；至此是升序還是相同仍需區分，`-.@-:`判斷兩參數是否為「不相同」，不相同時為`1`，而相同時為`0`。這裡的副詞`;._1`「自有區間」，使用字串的第一個字符作為分隔符，對字串進行劃分並去除分隔符，然後應用所修飾的動詞於這些子字串之上。

### 全排列

下面的例子給出`n`個項目的所有置換的有次序的矩陣。首先定義名詞`p3`，它是置換長度為`3`的全排列矩陣：

```j
   ]p3=: (i.@! A. i.) 3
0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0
```

這裡用到了動詞：`A.`「易位詞」（anagram），`x A. y`的左參數`x`，指定了長度為`#y`的所有置換中給特定一個置換的編號，其對應的置換向量在組合數學中被稱為逆序向量，據此編號置換`y`的項目。這裡求全排列的數目，用到了一元動詞`!`「階乘」。接著在`p3`的基礎上，實現置換長度為`4`的全排列矩陣：

```j
   =/~ @ i. ] 4             NB. 生成4×4单位矩阵
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
   \:"1 @ (=/~) @ i. ] 4    NB. 生成第1列为0 1 2 3，每行后3个元素升序的4×4“奇妙”矩阵
0 1 2 3
1 0 2 3
2 0 1 3
3 0 1 2
   0&,. @: +&1 p3           NB. 对3元素全排列的每个元素增1，并在每个排列头部添0
0 1 2 3
0 1 3 2
0 2 1 3
0 2 3 1
0 3 1 2
0 3 2 1
   perm0=: (0&,.@:+&1 p3) {"(_ 1) \:"1@(=/~)@i.
   <"_1 perm0 4
┌───────┬───────┬───────┬───────┐
│0 1 2 3│1 0 2 3│2 0 1 3│3 0 1 2│
│0 1 3 2│1 0 3 2│2 0 3 1│3 0 2 1│
│0 2 1 3│1 2 0 3│2 1 0 3│3 1 0 2│
│0 2 3 1│1 2 3 0│2 1 3 0│3 1 2 0│
│0 3 1 2│1 3 0 2│2 3 0 1│3 2 0 1│
│0 3 2 1│1 3 2 0│2 3 1 0│3 2 1 0│
└───────┴───────┴───────┴───────┘
   $ perm0 4
4 6 4
```

這裡的`{"(_ 1)`，其左側是從6×3全排列矩陣加工而成6×4選取矩陣，用它分別對其右側的4×4「奇妙」矩陣的每一行進行主軸索引運算，即將選取矩陣每行第1個元素保持為「奇妙」矩陣此行的第1個元素，而每行後面3個元素是對「奇妙」矩陣此行後面3個元素的排列。這一步寫出的排列動詞的結果是4×6×4的三維陣列，將它重製形狀為24×4全排列矩陣：

```j
   perm1=: (,~ !) $ ,@((0&,.@:+&1 p3) {"(_ 1) \:"1@(=/~)@i.)
   $ p4=: perm1 4
24 4
```

二元動詞`$`的左參數的值為`(!y) , y`，這裡的`y`是給排列動詞的數據參數；而它的右參數是用一元動詞`,`將三維陣列散開後形成的一個向量。

然後將其中的`p3`，替代為遞歸的自引用`$:@-&1`；並通過名詞秩，形成常量動詞`(1 0$0)"_`，設置長度為`0`時的基礎值為`1 0$0`：

```j
   perm=: (1 0$0)"_ ` ((,~ !) $ ,@(0&,.@:+&1@$:@-&1 {"(_ 1) \:"1@(=/~)@i.)) @. (>&0) : [:
   (perm 4) -: p4
1
   $ perm 0
1 0
   $ perm 1
1 1
   invertVec=: I.@(, -:"1 perm@#) : ({ perm)
   1 _1 invertVec 4
0 1 3 2
3 2 1 0
   invertVec 3 2 1 0
23
```

最後將遞歸形式改為迭代形式，可採用連詞`F..`「單結果正向摺疊」（fold single forward），使用它需要事先安裝插件`dev/fold`。這個連詞所形成的動詞，從左至右遍歷右參數列表，將其項目逐個作為動詞運算元所見到的左參數；它的左參數是迭代對象的初始值，動詞運算元所見到的右參數是迭代對象：

```j
   load 'dev/fold/foldr'
   perm=: (1 0$0)&(]F..((,~ !)@[ $ ,@(0&,.@:+&1@] {"(_ 1) \:"1@(=/~)@i.@[)))@:(>:@i.) : [:
```

如果不採用連詞`F..`，可以基於一元副詞`/`「插入」，自行實現正向摺疊算子：

```j
   foldl=: {{m"_ ` (v&:>/@,&(<m)@(<"_1@|.)) @. (>&0@#)}}
   perm=: (1 0$0)foldl((,~ !)@[ $ ,@(0&,.@:+&1@] {"(_ 1) \:"1@(=/~)@i.@[))@:(>:@i.) : [:
```

### 生命遊戲

在J語言中，提供了二元副詞`;.±3`「子陣列」（subarrays），它是`;.`「剪切」（cut）的三種形式之一，也被稱為密鋪（tessellate）或鑲嵌（tile）。`x(u;._3)y`應用動詞`u`於由`x`指定的`y`的有相同形狀的每個正規鑲嵌之上。`;.3`與之類似，但不丟棄結果中不完整的鑲嵌。

現代APL所使用的二元算子`⌺`「模板 (數值分析)」（stencil），在邊緣的處理上不同於J語言的鑲嵌，它要求鑲嵌子陣列每個軸的中心，在長度為奇數時是`y`的元素，在長度為偶數時在其元素之間，並且用填充（fill）元素填滿超出的部份，它的預設移動步長是`1`。下面在`;._3`的基礎上，利用二元動詞`{.`「採取」（take）的填充特性，定義一個`stencil`實現：

```j
   stencil=: {{
    p=. 1&,:`|.@.(>&1@#@$) n
    r=. <.-:<:{: p
    t=. -r+s=. r+$y
    p u;._3 t&{.s&{. y}}
```

這個定義只提供一個右名詞運算元`n`，它是鑲嵌子陣列的規定矩陣，不提供同每個子陣列對應的諸軸填充數目作為左名詞運算，APL`⌺`算子提供它，意圖在需要時籍此移除填充。這裡的鑲嵌規定矩陣定義，其第1行是子陣列的每軸長度，第2行是每軸的移動步長，這個行次序與`;.±3`的規定相反。這裡的`p`是給`;._3`的鑲嵌規定矩陣，`r`是每軸在頭部和尾部的填充數量，`s`是正值控制尾部填充，`t`是負值控制頭部填充。在下面的簡單用例中，數值陣列的填充元素是`0`：

```j
   ]d=: 4 4 $ >: i. 9
1 2 3 4
5 6 7 8
9 1 2 3
4 5 6 7
   < stencil 2 3 d
┌─────┬─────┬─────┬─────┐
│0 1 2│1 2 3│2 3 4│3 4 0│
│0 5 6│5 6 7│6 7 8│7 8 0│
├─────┼─────┼─────┼─────┤
│0 5 6│5 6 7│6 7 8│7 8 0│
│0 9 1│9 1 2│1 2 3│2 3 0│
├─────┼─────┼─────┼─────┤
│0 9 1│9 1 2│1 2 3│2 3 0│
│0 4 5│4 5 6│5 6 7│6 7 0│
└─────┴─────┴─────┴─────┘
```

下面實現康威生命遊戲，它是基於Edward F. MooreMoore鄰域的一種細胞自動機：

```j
   life=: {{3=s-y*.4=s=. (+/@,) stencil 3 3 ] y}}
   glider=: ".;._2 noun define
0 0 1 0 0
1 0 1 0 0
0 1 1 0 0
0 0 0 0 0
0 0 0 0 0
)
   life glider
0 1 0 0 0
0 0 1 1 0
0 1 1 0 0
0 0 0 0 0
0 0 0 0 0
   {&('.',u:16b2596) &.> (i.8) {{life ^:x ] y}} &.> <glider
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│..▖..│.▖...│..▖..│.....│.....│.....│.....│.....│
│▖.▖..│..▖▖.│...▖.│.▖.▖.│...▖.│..▖..│...▖.│.....│
│.▖▖..│.▖▖..│.▖▖▖.│..▖▖.│.▖.▖.│...▖▖│....▖│..▖.▖│
│.....│.....│.....│..▖..│..▖▖.│..▖▖.│..▖▖▖│...▖▖│
│.....│.....│.....│.....│.....│.....│.....│...▖.│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
```

這裡的實現演算法，將生命遊戲規則合併入一個單一表達式中，它由Arthur Whitney提出。演算法的第一步驟用`+/@,`合計每個格點及其周圍格點中`1`數目，並將它局部保存在`s`中。第二步驟將為前面的結果與`4`做相等比較，再與當前狀態`y`做邏輯與運算，只有在當前格點為`1`，而且周圍格點合計為`3`的情況下，當前格點得到真值`1`。第三步驟用`s`減去前面的結果真值，再與`3`做相等比較。在這個最終結果中，當前格點得到真值`1`有兩類情況：⑴它在`s`中的值為`4`，並減去了真值`1`，這就是第二步驟運算所選定的情況；⑵它在`s`中的值為`3`，並減去第二步驟運算在這種情況下必然得出的假值`0`，這又可細分為兩種情況：當前格點為`0`，而且周圍格點合計為`3`；或者當前格點為`1`，而且周圍格點合計為`2`。

這個演算法可以寫為隱式定義形式：

```j
   life=: (=&3@] +. (*. =&4)) (+/@,) stencil 3 3 : [:
```

在J語言中，實現以遞推關係定義的序列，避免出現$\,O(n^2)\,$的時間複雜度，可以採用連詞`F:.`「多結果正向摺疊」（fold multiple forward），使用它需要事先安裝插件`dev/fold`。這個連詞所形成的動詞，不輸出左參數的初始值，如果提供的右參數為空值，它的輸出為空值，否則它輸出每次迭代的結果。上例中的迭代算式可以改寫為：

```j
   load 'dev/fold/foldr'
   {&('.',u:16b2588) &.> (< , <F:.(life@])&(7$0)) glider
```

如果不採用連詞`F:.`，可以自行實現輸出中間結果的正向摺疊算子：

```j
   foldlist=: {{
    if. 1 > # y do. '' return. end.
    r=. '' [ a=. x
    for_i. y do. r=. r , u a=. i v a end.
    r }}
   {&('.',u:16b2588) &.> (< , <foldlist(life@])&(7$0)) glider
```

在這裡的`foldlist`中，將r=. `''` a=. x改為`r=. u a=. x`，則`(< , <foldlist(life@])&(7$0))`可改為`<foldlist(life@])&(7$0)`。

### 鍵分組

在J語言中，提供了二元副詞`/.`「鍵分組」（key），它按左參數中的唯一鍵，對右參數進行分組（group）或稱為分區（partition），並將所修飾動詞應用到這些分組之上。分組次序同於一元動詞`~.`「唯一值」處理結果的次序，它除去匹配前面出現過的項目的任何項目。下面在它的基礎之上，定義對應現代APL使用的二元算子`⌸`「鍵分組」（key）的一個副詞，它將所修飾動詞應用在唯一鍵和相應的分組二者之上，它還具有一元和二元兩種形式：

```j
   key=: {{
    (<"0 ~. y) u (y </. i.#y)
   :
    (<"0 ~. x) u (x </. y)}}
```

它的二元形式的左參數含有唯一鍵，而右參數是要分組的數據；它的一元形式的右參數含有唯一鍵，所分組的是右參數諸項目的索引值。下面是這個鍵分組副詞所適用的動詞的簡單示例：

```j
   x=: 'Mississippi'
   [ key x
┌─┬─┬─┬─┐
│M│i│s│p│
└─┴─┴─┴─┘
   ] key x
┌─┬────────┬───────┬───┐
│0│1 4 7 10│2 3 5 6│8 9│
└─┴────────┴───────┴───┘
   ,. key x
┌─┬────────┐
│M│0       │
├─┼────────┤
│i│1 4 7 10│
├─┼────────┤
│s│2 3 5 6 │
├─┼────────┤
│p│8 9     │
└─┴────────┘
   ([ ,. #&.>@]) key x
┌─┬─┐
│M│1│
├─┼─┤
│i│4│
├─┼─┤
│s│4│
├─┼─┤
│p│2│
└─┴─┘
```

下面的例子通過鍵分組來找到一個單詞列表中的易位詞：

```j
   ]a=: <;._1 ' pats spat teas sate taps etas past seat eats tase star east seta'
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│pats│spat│teas│sate│taps│etas│past│seat│eats│tase│star│east│seta│
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
   /:~ &.> a
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│apst│apst│aest│aest│apst│aest│apst│aest│aest│aest│arst│aest│aest│
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
   (]key~  /:~&.>) a
┌─────────────────────┬─────────────────────────────────────────┬──────┐
│┌────┬────┬────┬────┐│┌────┬────┬────┬────┬────┬────┬────┬────┐│┌────┐│
││pats│spat│taps│past│││teas│sate│etas│seat│eats│tase│east│seta│││star││
│└────┴────┴────┴────┘│└────┴────┴────┴────┴────┴────┴────┴────┘│└────┘│
└─────────────────────┴─────────────────────────────────────────┴──────┘
```

### 隨機數

在J語言中，提供了二元動詞`I.`「區間索引」，它左參數`x`必須是有次序的，從而定義了`1+#x`個區間，除了最後一個之外的每個區間，都含有並結束於`x`的一個項目，而最後一個結束於正無窮，第一個開始於負無窮；它應用於右參數`y`，給出`y`所位於的區間的索引。

下面的例子產生符合指定離散機率分布的隨機數列表，這裡定義了動詞`ran`，它依據左參數`x`給出的正實數向量中的這些權重，從`i.#x`中選取出由右參數`y`指定個數的隨機數列表：

```j
   ran=: [: : ((I.~ (+/\ % +/))~ ?@$&0)
   wt=: 7 5 6 4 7 2 0.4
   # t=: wt ran 1e6
1000000
   10 {. t
0 1 1 5 0 1 3 4 4 0
   ] r=: wt (+/@(=/ i.@#)~ % #@]) t  NB. 实测的出现比率
0.222618 0.159083 0.19152 0.127394 0.222795 0.06378 0.01281
   ] p=: (% +/) wt                   NB. 期望的出现概率
0.22293 0.159236 0.191083 0.127389 0.22293 0.0636943 0.0127389
   0j6 ": r - p
_0.000312 _0.000153 0.000437 0.000005 _0.000135 0.000086 0.000071
```

這裡首先通過`?@$&0`，生成指定數目的在區間`(0,1)`中的隨機浮點數，它也可以寫為等價的`?@($ 0:)`。然後在叉子`+/\ % +/`中，使用一元副詞`\`「前綴」修飾動詞`+/`，從而計算權重向量的前綴和，再用前綴和除以總和得出累積分布函數。最後通過區間索引，在有隨機浮點數落入特定區間的時候，生成這個區間對應的隨機整數。

動詞`ran`的表達式是個二層二元鉤子，外層鉤子的第一步運算應用到右參數上，它的第二步運算即內層鉤子，整體修飾了二元副詞`~`「被動」而對換了兩個參數的位置。內層鉤子的第一步運算`+/\ % +/`所應用的右參數實際上是外層鉤子的左參數，它的第二步運算`I.`修飾了`~`，從而將它所面對的內層鉤子的左右兩參數，再次對換回到外層鉤子即整體表達式原先的位置上。

下面是將區間索引和鍵分組結合起來的例子，演示了Jarl Waldemar Lindeberg－萊維中心極限定理：

```j
   histogram =: {{
    {&('.',u:16b258c) @ ((|.i.x)&(</)) @ (>.@*&x) @ (% >./) y}}
   summary=: {{ l=. 0 [ r=. 1
    -&1@#/.~ @ ((i.x)&,) @ ((l+(}.i.x)*%&x(r-l))&I.) y}}
   sampleMean=: {{%&m @ (+/) @ (m&, $ v@*&m) y}}
   24&histogram @ (80&summary) @ (10 sampleMean (?@$&0)) 1e6
......................................▌▌▌▌......................................
.....................................▌▌▌▌▌▌.....................................
....................................▌▌▌▌▌▌▌▌....................................
....................................▌▌▌▌▌▌▌▌....................................
...................................▌▌▌▌▌▌▌▌▌▌...................................
..................................▌▌▌▌▌▌▌▌▌▌▌▌..................................
..................................▌▌▌▌▌▌▌▌▌▌▌▌..................................
.................................▌▌▌▌▌▌▌▌▌▌▌▌▌▌.................................
.................................▌▌▌▌▌▌▌▌▌▌▌▌▌▌.................................
................................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌................................
................................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌................................
...............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...............................
...............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...............................
..............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌..............................
..............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌..............................
.............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌.............................
............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌............................
............................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌............................
...........................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌...........................
..........................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌..........................
.........................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌.........................
........................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌........................
......................▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌......................
.........▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌▌........
   lineChart=: {{
    s=. (|.i.x)&(</) @ (>.@*&x) @ (% >./)
    t=. >&0 @ (2&(-/\)) @ (2&(-~/\))"1 @ ,.&1 @ (1&,.)
    {&('.',u:16b2588) @ (2&(-~/\)@(0&,) +. t) @ s y}}
   24&lineChart @ (+/\) @ (80&summary) @ (10 sampleMean (?@$&0)) 1e6
....................................................████████████████████████████
..................................................██............................
................................................██..............................
...............................................█................................
..............................................█.................................
............................................██..................................
............................................█...................................
...........................................█....................................
..........................................█.....................................
.........................................█......................................
........................................█.......................................
.......................................█........................................
.......................................█........................................
......................................█.........................................
.....................................█..........................................
....................................█...........................................
...................................█............................................
...................................█............................................
.................................██.............................................
................................█...............................................
...............................█................................................
.............................██.................................................
...........................██...................................................
.........██████████████████.....................................................
```

這裡定義的`summary`局部賦值了兩個局部變量`l`和`r`，可以將這兩個局部賦值去掉，並將這兩個局部變量的出現替代為運算元`m`和`n`，如此對它的調用將變成`(80&(0 summary 1))`這樣的形式。接下的代碼結合前面兩個例子，採用了不同於上例連續型均勻分布的其他分布作為獨立同分布，和不同的樣本平均和樣本協方差：

```j
   ratio=: [: : (-&1@#/.~@(,~ i.)~ % #@])
   10&histogram @ ((#wt)&ratio) @ (wt&ran) 1e6
   random=: [: : (#@[ %~ (?@$&0@] + ((I.~ (+/\ % +/))~ ?@$&0)))
   20&lineChart @ (80&summary) @ (wt&random) 1e6
   20&lineChart @ (80&summary) @ (2 sampleMean (wt&random)) 1e6
   20&lineChart @ (80&summary) @ (4 sampleMean (wt&random)) 1e6
```

### SQLite插件

操縱SQLite資料庫的需要安裝相應插件：

```j
   load 'pacman'                NB. 加载包管理器
   'install' jpkg 'data/sqlite' NB. 安装SQLite数据库插件
   load 'data/sqlite'           NB. 加载SQLite数据库插件
   getbin_psqlite_ ''           NB. 安装SQLite数据库的共享库
```

SQLite資料庫的簡單用例：

```j
   load 'data/sqlite'                   NB. 加载SQLite数据库插件
   db=: sqlopen_psqlite_ '~addons/data/sqlite/db/sandp.db'  NB. 打开样例数据库文件
   sqltables__db ''                     NB. 查看所有表格名字
┌─┬─┬──┐
│p│s│sp│
└─┴─┴──┘
   sqlmeta__db 's'                      NB. 查看表格s的结构
┌───┬──────┬────┬───────┬──────────┬──┐
│cid│name  │type│notnull│dflt_value│pk│
├───┼──────┼────┼───────┼──────────┼──┤
│0  │sid   │text│0      │NULL      │1 │
│1  │name  │text│0      │NULL      │0 │
│2  │status│int │0      │NULL      │0 │
│3  │city  │text│0      │NULL      │0 │
└───┴──────┴────┴───────┴──────────┴──┘
   ds=: sqlread__db 'select * from s'   NB. 读取表格s，结果表格形状扁长不适合直接展示
   dict=: |: @:>                        NB. 以字典方式显示表格数据
   ] rs=: dict ds
┌──────┬──────────────────────────────────┐
│sid   │┌──┬──┬──┬──┬──┐                  │
│      ││s1│s2│s3│s4│s5│                  │
│      │└──┴──┴──┴──┴──┘                  │
├──────┼──────────────────────────────────┤
│name  │┌─────┬─────┬─────┬─────┬─────┐   │
│      ││smith│jones│blake│clark│adams│   │
│      │└─────┴─────┴─────┴─────┴─────┘   │
├──────┼──────────────────────────────────┤
│status│20 10 30 20 30                    │
├──────┼──────────────────────────────────┤
│city  │┌──────┬─────┬─────┬──────┬──────┐│
│      ││london│paris│paris│london│athens││
│      │└──────┴─────┴─────┴──────┴──────┘│
└──────┴──────────────────────────────────┘
   rs -: sqldict__db 's'
1
   cols=: {: @:>                       NB. 表格数据的诸列列表
   cs=: cols ds
   cs -: sqlexec__db 's'
1
   ('s_'&, &.> @ {. @:> ds) =: cs      NB. 将表格的诸列并行赋值给添加了表名前缀的诸列名
   s_status
20 10 30 20 30
   s_sid
┌──┬──┬──┬──┬──┐
│s1│s2│s3│s4│s5│
└──┴──┴──┴──┴──┘
   ({. @:> ds) -: sqlcols__db 's'
1
   reads=: ({. , (,@> &.>)@}.) @:>    NB. 格式化显示表格数据
   ] rs=: reads ds
┌───┬─────┬──────┬──────┐
│sid│name │status│city  │
├───┼─────┼──────┼──────┤
│s1 │smith│20    │london│
│s2 │jones│10    │paris │
│s3 │blake│30    │paris │
│s4 │clark│20    │london│
│s5 │adams│30    │athens│
└───┴─────┴──────┴──────┘
   $ @ (2&{:: @ {:) rs                NB. 第3列数据的形状
5 1
   rs -: sqlreads__db 's'
1
   readm=: ({. ; <@|:@:(< @ > @ >)@{:) @:>  NB. 以矩阵显示表格数据
   ] rs=: readm ds
┌──────────────────────┬────────────────────┐
│┌───┬────┬──────┬────┐│┌──┬─────┬──┬──────┐│
││sid│name│status│city│││s1│smith│20│london││
│└───┴────┴──────┴────┘│├──┼─────┼──┼──────┤│
│                      ││s2│jones│10│paris ││
│                      │├──┼─────┼──┼──────┤│
│                      ││s3│blake│30│paris ││
│                      │├──┼─────┼──┼──────┤│
│                      ││s4│clark│20│london││
│                      │├──┼─────┼──┼──────┤│
│                      ││s5│adams│30│athens││
│                      │└──┴─────┴──┴──────┘│
└──────────────────────┴────────────────────┘
   rs -: sqlreadm__db 's'
1
   cp=: '~addons/data/sqlite/db/sandp.db' ; '~/test_sandp.db'
   db=: sqlcopy_psqlite_ cp           NB. 复制数据库并打开复本
   cls=: sqlcols__db 's'              NB. 得到表格s的列名列表
   dat=: ('s6';'s7') ; ('brown';'eaton') ; 40 10 ;< 'rome';'madrid'
   sqlinsert__db 's' ; cls ;< dat     NB. 将数据插入表格s
0
   3 sqltail__db 's'                  NB. 返回最后3个格式化记录
┌───┬─────┬──────┬──────┐
│sid│name │status│city  │
├───┼─────┼──────┼──────┤
│s5 │adams│30    │athens│
│s6 │brown│40    │rome  │
│s7 │eaton│10    │madrid│
└───┴─────┴──────┴──────┘
   sqlclose__db ''                    NB. 关闭数据库
1
```

### 字典類

J語言採用命名語境實現類，採用編號語境實現對象，下面示例建立字典類：

```j
cocurrent 'Dict'
  create=: {{o [ DEFAULT__o=: 0$0 [ o=. conew 'Dict'}}
  get=: {{". 'ITEM_',y}}
  set=: {{
    ('ITEM_',y)=: DEFAULT
   :
    ('ITEM_',y)=: x}}
  del=: {{erase 'ITEM_',y}}
  pop=: {{r [ del y [ r=. get y}}
  default=: {{DEFAULT=: y}}
  filt=: {~ I.@:({.@('ITEM_'&E.)@>)
  len=: {{# filt namelist 0}}
  list=: {{5&}.&.> filt namelist 0}}
  in=: {{+/@:(-:&y@>) list ''}}
  clear=: {{#@,@:(erase @>) filt namelist 0}}
  copy=: {{o=. conew 'Dict'
    o [ ".@(,&'__o=:',(5!:5)@<)&.> 'DEFAULT';filt namelist 0}}
  destroy=: codestroy
cocurrent 'base'
```

在家目錄中建立一個`dict.ijs`文件並錄入上述代碼，接著以如下代碼建立字典對象並對其進行檢視和簡單操作：

```j
   load '~/dict.ijs'
   conl 0            NB. 检视命名语境
┌────┬────┬─┬────────┬──────┬─────┬─┐
│Dict│base│j│jcompare│jregex│jtask│z│
└────┴────┴─┴────────┴──────┴─────┴─┘
   namelist_Dict_ 3  NB. 检视Dict类的动词
┌─────┬────┬──────┬───────┬───┬───────┬────┬───┬──┬───┬────┬───┬───┐
│clear│copy│create│default│del│destroy│filt│get│in│len│list│pop│set│
└─────┴────┴──────┴───────┴───┴───────┴────┴───┴──┴───┴────┴───┴───┘
   d=: create_Dict_ ''
   d                 NB. 变量保存的是盒装字符串
┌─┐
│0│
└─┘
   namelist__d 0     NB. 检视d对象的名词
┌─────────┬───────┐
│COCREATOR│DEFAULT│
└─────────┴───────┘
   conl 1            NB. 检视编号语境
┌─┐
│0│
└─┘
   copath <'0'       NB. 检视编号语境的查找路径
┌────┬─┐
│Dict│z│
└────┴─┘
   set__d 'i1'

   (2 3) set__d 'i2'
2 3
   'abc' set__d 'i3'
abc
   len__d ''
3
   list__d ''
┌──┬──┬──┐
│i1│i2│i3│
└──┴──┴──┘
   e=: copy__d ''
   get__d 'i2'
2 3
   del__d 'i2'
1
   in__d 'i3'
1
   pop__d 'i3'
abc
   clear__d ''
1
   list__e ''
┌──┬──┬──┐
│i1│i2│i3│
└──┴──┴──┘
```

## 外部連結

- JSoftware，J的官方網站
- jsoftware – Repository
- Learning J – An Introduction to the J Programming Language by Roger Stokes
- J for C Programmers by Henry Rich
- J for the APL Programmer by Chris Burke and Roger Hui
- An Implementation of J by Roger K.W. Hui
- APL to J Phrasebook
- J － APL Wiki
- 郭平欣譯J字典

## 基本資料

- 日語原文：J
- 文件擴展名：.ijs
- 編程范型：陣列、隱式、反射式、函數式
- 發行日期：1990年
- 設計者：Kenneth E. Iverson、許國華 (電腦科學家)
- 開發者：JSoftware
- 類型系統：動態類型
- 軟體實現：J
- 語言家族：APL
- 受影響於：SHARP APL
- 施影響於：Dyalog APL, NARS2000, BQN, SuperCollider
- 作業系統：跨平台: Windows, Linux, macOS
- 許可證：GPLv3