# 編程構造

到目前為止，我們已經介紹了該語言的所有部分，這些部分使我們能夠從輸入 JSON 文檔中提取數據、使用字符串和數字運算符組合數據以及格式化輸出 JSON 文檔的結構。接下來是將其轉變為圖靈完備的函數式編程語言的部分。

## 說明

表達式可以使用“C”樣式注釋分隔符與注釋交錯。例如，

```
/* Long-winded expressions might need some explanation */
(
  $pi := 3.1415926535897932384626;
  $plot := function($x) {(
    $floor := $string ~> $substringBefore(?, '.') ~> $number;
    $index := $floor(($x + 1) * 20 + 0.5);
    $join([0..$index].('.')) & 'O' & $join([$index..40].('.'))
  )};

/* Factorial is the product of the integers 1..n */
  $product := function($a, $b) { $a * $b };
  $factorial := function($n) { $n = 0 ? 1 : $reduce([1..$n], $product) };

$sin := function($x){ /* define sine in terms of cosine */
    $cos($x - $pi/2)
  };
  $cos := function($x){ /* Derive cosine by expanding Maclaurin series */
    $x > $pi ? $cos($x - 2 * $pi) : $x < -$pi ? $cos($x + 2 * $pi) :
      $sum([0..12].($power(-1, $) * $power($x, 2*$) / $factorial(2*$)))
  };

[0..24].$sin($*$pi/12).$plot($)
)
```

如果您有興趣的話，可以制作[這個]()！

## 條件邏輯

可以使用三元運算符“？：”編寫 If/then/else 結構。

`predicate ? expr1 : expr2`

表達式 `predicate` 被求值。如果其有效布爾值（參見定義）為 `true`，則 `expr1` 求值并返回，否則 `expr2` 求值并返回。

**示例**

```
Account.Order.Product.{ 
  `Product Name`: $.Price > 100 ? "Premium" : "Basic"
} 
//結果
[
{
"Bowler Hat": "Basic"
},
{
"Trilby hat": "Basic"
},
{
"Bowler Hat": "Basic"
},
{
"Cloak": "Premium"
}
]
```

## 變量

任何以美元符號“$”開頭的名稱都是變量。變量是對值的命名引用。該值可以是語言[類型系統]()中的任意類型。

### 內置變量

* `$` 沒有名稱的變量指的是輸入 JSON 層次結構中任意一點的上下文值。示例
* `$$` 輸入 JSON 的根。僅當您需要脫離當前上下文以暫時導航到其他路徑時才需要。例如用于交叉引用或連接數據。示例
* 本機（內置）函數。請參閱函數庫。

### 變量綁定

值（類型系統中的任意類型）可以綁定到變量

`$var_name := "value"`

稍后可以使用表達式引用存儲的值 `$var_name`。

變量的作用域僅限于它所綁定的“塊”。例如

```
Invoice.(
$p := Product.Price;
$q := Product.Quantity;
$p * $q
)
```

返回發票中產品價格乘以數量。

## 功能

函數是一等類型，可以像任何其他數據類型一樣存儲在變量中。提供了內置函數庫（鏈接）并將其分配給全局范圍內的變量。例如，`$uppercase` 包含一個函數，當使用字符串參數調用時，`str` 將返回一個字符串，其中 中的所有字符都 `str` 更改為大寫。

### 調用函數

函數的調用是通過在其引用（或定義）后面加上包含逗號分隔的參數序列的括號來實現的。

**示例**

* `$uppercase("Hello")` 返回字符串“HELLO”。
* `$substring("hello world", 0, 5)` 返回字符串“hello”
* `$sum([1,2,3])` 返回數字 6

### 定義函數

可以使用以下語法定義匿名（lambda）函數：

`function($l, $w, $h){ $l * $w * $h }`

可以使用以下方式調用

`function($l, $w, $h){ $l * $w * $h }(10, 10, 5)` 返回 500

該函數還可以分配給變量以供將來使用（在塊內）

```(
$volume := function($l, $w, $h){ $l * $w * $h };
$volume(10, 10, 5);
)
```

### 函數簽名

函數可以用可選簽名來定義，該簽名指定函數的參數類型。如果提供，評估引擎將在調用函數之前驗證傳遞給函數的參數。如果參數列表與簽名不匹配，則會引發動態錯誤。

函數簽名是形式為 的字符串 `<params:return>`。`params` 是類型符號序列，每個符號代表一個輸入參數的類型。`return` 是表示返回值類型的單個類型符號。

類型符號的工作原理如下：

簡單類型：

* `b`- boolean
* `n`-number
* `s`- string
* `l`-`null`

復雜類型：

* `a`- array
* `o`- object
* `f`- function

聯合類型：

* `(sao)`- string、array、objct
* `(o)`- 等同 `o`
* `u`- 相當于 `(bnsl)` boolean、number、string、`null`
* `j`- 任何 JSON 類型。相當于 `(bnsloa)` boolean、number、string、 `null`、對象或數組，但不是函數
* `x`- 任何類型。相當于 `(bnsloaf)`

參數化類型：

* `a<s>`- 字符串數組
* `a<x>`- 任意類型的值數組

內置 函數簽名的一些示例：

* `$count` 有簽名 `<a:n>`；它接受一個數組并返回一個數字。
* `$append` 有簽名 `<aa:a>`；它接受兩個數組并返回一個數組。
* `$sum` 有簽名 `<a<n>:n>`；它接受一個數字數組并返回一個數字。
* `$reduce` 有簽名 `<fa<j>:j>`；它接受一個 Reducer 函數 `f` 和一個 `a<j>`（JSON 對象數組）并返回一個 JSON 對象。

每種類型符號也可能有應用的 *選項* 。

* `+`- 一個或多個此類型的參數
  * 例如 `$zip` 有簽名 `<a+>`；它接受一個數組，或兩個數組，或三個數組，或......
* `?`- 可選參數
  * 例如 `$join` 有簽名 `<a<s>s?:s>`；它接受一個字符串數組和一個可選的連接字符串（默認為空字符串）。它返回一個字符串。
* `-`- 如果缺少此參數，則使用上下文值（“focus”）。
  * 例如 `$length` 有簽名 `<s-:n>`；它可以被稱為 `$length(OrderID)`（一個參數），但等效于 `OrderID.$length()`。

### 遞歸函數

已分配給變量的函數可以使用該變量引用來調用自身。這允許定義遞歸函數。例如。

```
(
$factorial:= function($x){ $x <= 1 ? 1 : $x * $factorial($x-1) };
$factorial(4
) 
//結果 
24
```

請注意，實際上可以使用純匿名函數（即不將任何內容分配給變量）編寫遞歸函數。這是使用[Y-combinator]()完成的，對于那些對函數式編程感興趣的人來說，這可能是一個有趣的[消遣。]()

### 尾調用優化（尾遞歸）

遞歸函數每次調用自身時都會向調用堆棧添加一個新框架。如果函數回退超過一定限制，這最終會導致堆棧耗盡?？紤]階乘函數的經典遞歸實現

```
(
$factorial := function($x) {
$x <= 1 ? 1 : $x * $factorial($x-1)
};
$factorial(170)
)
```

此函數的工作原理是將數字推送到堆棧上，然后在堆棧展開時將其乘以數字階乘減一的結果。以這種方式編寫，評估器別無選擇，只能使用調用堆棧來存儲中間結果。如果數字足夠大，調用堆棧就會溢出。

這是函數式編程中公認的問題，解決方案是稍微重寫函數以避免需要*堆棧*來存儲中間結果。以下階乘的實現實現了這一點

```
(
$factorial := function($x){(
$iter := function($x, $acc) {
$x <= 1 ? $acc : $iter($x - 1, $x * $acc)
};
$iter($x, 1)
)};
$factorial(170)
)
```

這里，乘法是*在*函數調用自身之前完成的，中間結果放在第二個參數 `$acc`（累加器）中。調用自身是函數執行的*最后一*件事。這被稱為“尾部調用”，當 解析器發現這一點時，它會在內部將遞歸重寫為一個簡單的循環。因此它可以無限期地運行而不會增加調用堆棧。以這種方式編寫的函數被稱為[尾部遞歸]()。

### 高階函數

函數是一等數據類型，可以作為參數傳遞給另一個函數，也可以從函數返回。處理其他函數的函數稱為高階函數。請考慮以下示例：

```
(
$twice := function($f) { function($x){ $f($f($x)) } };
$add3 := function($y){ $y + 3 };
$add6 := $twice($add3);
$add6(7)
)
```

* 變量中存儲的函數 `$twice` 是高階函數。它接受一個 `$f` 函數參數，并返回一個接受參數的函數，該函數 `$x` 在調用時會將該函數應用 `$f` 兩次 `$x`。
* `$add3` 存儲一個將 3 添加到其參數的函數。`$twice` 或 都 `$add3` 尚未被調用。
* `$twice` 通過將函數作為其參數傳遞來調用。這將返回一個對其 `add3` 參數應用 `$add3` 兩次的函數。這個返回的函數尚未被調用，而是被分配給變量。`add6`
* 最后，使用參數 7 調用函數 `$add6`，結果將 3 加到該函數兩次。它返回 13。

### 函數是閉包

定義 lambda 函數時，求值引擎會獲取環境快照并將其與函數體定義一起存儲。環境由上下文項（即位置路徑中的當前值）以及當前范圍內的變量綁定組成。稍后調用 lambda 函數時，將在存儲的環境中執行，而不是在調用時的當前環境中執行。此屬性稱為*詞法作用域，是*  *閉包*的基本屬性。

請考慮以下示例：

```
Account.(
$AccName := function() { $.'Account Name' };

Order[OrderID = 'order104'].Product.{
'Account': $AccName(),
'SKU-' & $string(ProductID): $.'Product Name'
}
)
```

當函數被創建時，上下文項（用 '$' 表示）是 的值 `Account`。稍后，當函數被調用時，上下文項已在結構中向下移動到每個 `Product` 項的值。但是，函數體是在定義時存儲的環境中調用的，因此其上下文項是 的值 `Account`。這是一個有點牽強的例子，你實際上不需要一個函數來做到這一點。表達式產生以下結果：

```
{
"Account": "Firefly",
"SKU-858383": "Bowler Hat",
"SKU-345664": "Cloak"
}
```

### 部分函數應用

可以通過調用函數[來部分應用]()函數，其中一個或多個（但不是全部）參數用問號占位 `?` 符替換。這樣做的結果是另一個函數，其參數數量減少了提供給原始函數的參數數量。這個返回的函數可以像任何其他新定義的函數一樣處理，例如綁定到變量、傳遞給高階函數等。

**示例**

* `$substring` 通過部分應用函數創建一個函數來返回字符串的前五個字符

```
(
$first5 := $substring(?, 0, 5);
$first5("Hello, World")
)
//結果 
"Hello"
```

* 部分應用函數可以進一步部分應用

```
(
$firstN := $substring(?, 0, ?);
$first5 := $firstN(?, 5);
$first5("Hello, World")
)
//結果 
"Hello"
```

### 函數鏈

函數鏈接有兩種使用方式：

1. 當多個函數應用于一個值時，避免大量嵌套
2. 作為通過組合現有函數來定義新函數的高階構造

#### 調用鏈

`value ~> $funcA ~> $funcB`
相當于
`$funcB($funcA(value))`

**示例**

* `Customer.Email ~> $substringAfter("@") ~> $substringBefore(".") ~> $uppercase()`

#### 函數組合

[函數組合](https://en.wikipedia.org/wiki/Function_composition)是將一個函數應用到另一個函數中以產生第三個函數。

`$funcC := $funcA ~> $funcB`
相當于
`$funcC := function($arg) { $funcB($funcA($arg)) }`

**示例**

* 通過鏈接兩個現有函數來創建新函數

```
(
$normalize := $uppercase ~> $trim;
$normalize("   Some   Words   ")
) 
//結果
"SOME WORDS"
```

### 函數作為第一類值

函數組合可以與部分函數應用相結合，產生用于定義新函數的非常緊湊的語法。

**示例**

* 通過鏈接兩個部分求值的函數來創建新函數

```
(
$first5Capitalized := $substring(?, 0, 5) ~> $uppercase(?);
$first5Capitalized(Address.City)
) 
//結果
"WINCH"
```

### 高級示例——Y-combinator

沒有必要閱讀本節——它不會對您的理智或操作 JSON 數據的能力產生任何影響。

前面我們學習了如何編寫遞歸函數來計算數字的階乘，并暗示這可以在不命名任何函數的情況下完成。我們可以將高階函數發揮到極致，并編寫以下內容：

```
λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})}(λ($f) { λ($n) { $n < 2 ? 1 : $n * $f($n - 1) } })(6)
```

得出結果 `720`。希臘符號 lambda (λ) 可以代替單詞 `function`，如果你能在鍵盤上找到它，它將節省屏幕空間并讓[lambda 演算]()的粉絲們滿意。

上述表達式的第一部分是該語言中[Y 組合器]()的實現。我們可以將其分配給一個變量并將其應用于其他遞歸匿名函數：

```
(
$Y := λ($f) { λ($x) { $x($x) }( λ($g) { $f( (λ($a) {$g($g)($a)}))})};
[1,2,3,4,5,6,7,8,9] . $Y(λ($f) { λ($n) { $n <= 1 ? $n : $f($n-1) + $f($n-2) } }) ($)
)
```

產生斐波那契數列 `[ 1, 1, 2, 3, 5, 8, 13, 21, 34 ]`。

但我們不需要做任何這些。使用命名函數更為明智：

```(
$fib := λ($n) { $n <= 1 ? $n : $fib($n-1) + $fib($n-2) };
[1,2,3,4,5,6,7,8,9] . $fib($)
)
```

8、函數式編程