"."（dot）可以被理解為繼續(xù)（continuation），或者反過來理解，阻塞（blocking）；它的意思是前綴必須先完成通訊，即接收或發(fā)送完成，"."之后的表達式才可以開始執(zhí)行，或者稱為估值；這是π里唯一表達順序（order）的地方；

你可以給一個表達式取一個名字，習慣上使用大寫字母P, Q, R...

每個π表達式都表達了一個過程。

"|"（vertical pipe）在π里的含義是并發(fā)組合，可以看作過程的運算符；U = P | Q | R就可以理解為過程U是由三個過程并發(fā)組成的。

π里的另一個組合過程的運算符是"+"，summation，我們暫不介紹。

標題的表達式里還有一個符號0，0表示一個無行為的過程（inaction）。

這一段可以在看了后面的代碼之后再回來對照理解。

Free name的含義和λ或編程語言里的定義一致；它是bound name的反義詞；bind的意思和λ也是一致的（λx)；

在π里有兩個符號會bind name，標題里的表達式只出現了一個，即輸入前綴，例如：x(z)。這很容易理解，在JavaScript代碼里我們常用listener函數接收消息：

emitter.on("data", data => {
    // do something with data
})

這里的data變量的scope就是在這個匿名函數內的，即bound name。一個過程P的Free name是它和外部產生行為交互的唯一方式。

這里是π process教材里的描述：

The free names of a process circumscribe its capabilities for action: for a name x, in order for P to send x, to send via x, or to receive via x, it must be that x ∈ fn(P). Thus in order for two processes to interact via a name, that name must occur free in both of them, in one case expressing a capability to send, and in the other a capability to receive.
from π calculus by Davide Sangiorgi and David Walker
譯：
一個過程的free name決定了它的行為能力，對于過程P中的name x，如果P能夠：

發(fā)送x
通過x發(fā)送其他name
通過x接收其他name

x必須是P的free name。所以如果兩個過程需要通過一個name交互，這個name必須在兩個過程中都是free name，其中一方用于發(fā)送，另一方用于接收。

這個詞在編程界被用爛了。但是它的含義沒有什么高大上的地方。一個數學公式的形式變換就是reduction，當然我們正常情況下是希望它越變越簡潔的（所以叫reduce），除了你的陰險的數學老師會在出題時有個相反的邪惡目的。

π只有一個reduction:

x.P | x(z).Q -> P | Q[y/z]

含義是y從channel x發(fā)送出去之后，P才可以繼續(xù)執(zhí)行；同時x(z)前綴收到了y，Q得以繼續(xù)執(zhí)行，此時Q里的所有z都要替換成y。

在編程中：

x(z).Q意味著如果x尚未收到數據，Q不能開始執(zhí)行；這個input prefix在程序語言里很容易實現，就是常見的listener或者callback。

x.P意味著只有y被讀走，P才會開始執(zhí)行；這類似lazy實現的stream，在數據沒有被讀走之前，不會再向buffer填充數據；在編程語言里實現這個表達式，和實現readable stream時，收到drain事件才開始填充數據類似。

我們先假定存在一個構造函數或工廠方法，可以構造一個channel對象；我們先不回答channel如何構造，以及它內部是什么。

我們要求channel對象有一對接口方法，按照π的邏輯應該叫做send和receive；

注意在π里我們沒有類型和值的概念，一切變量皆channel，寫成代碼就是一切變量皆channel對象，通過channel傳遞的變量也是channel，這是π系統(tǒng)的重要特性之一：pass channel via channel（因為它會讓name突破一個scope使用）。

我們首先發(fā)現這個表達式里的free name都得先聲明（why？）；x，y，w，a都聲明成channel（a在這個例子中沒有實際用于通訊，可以是任何東西）。

第一段代碼就是這個樣子。

class Channel {
    // placeholder
}

const channel = () => new Channel()

const x = channel()
const y = channel()
const w = channel()
const a = channel()

"."（dot）所表達的繼續(xù)，我們可以用調用一個函數來實現；.0，可以用調用空函數（() => {}）表示；

x.receive(z => z.send(a, () => {}))

receive方法形式上是提供一個函數f作為參數，channel x在接收到值z的時候調用這個函數f(z)；

第二個表達式：x.y.0，可以這樣寫：

x.send(w, () => y.send(w, () => {}))

注意這里要send成功之后才能繼續(xù)而不是調用send后就繼續(xù)，所以不能寫成：

x.send(w)
y.send(w)

最后一個表達式：y(v).v(u).0

y.receive(v => v.receive(u => (() => {})()))

到這里我們寫完了使用者代碼；在使用的時候我們也給Channel類的接口下了定義；如果你問哪個表示并發(fā)的vertical pipe（|）哪里去了？你想一下，我在文章的最后給出問題的答案。

在實現Channel類之前我們還要考慮一個順序問題。

π里的reduction是兩個并發(fā)過程之間發(fā)生的；在reduction的時候我們要調用兩個函數實現"."表示的繼續(xù)，分別是發(fā)送者繼續(xù)和接收者繼續(xù)，我們是否應該約定一個固定的順序？

答案是不應該；對于這里寫下的玩具代碼我們甚至故意加入了隨機性，這才是并發(fā)的含義，并發(fā)過程之間木有固定執(zhí)行順序。

我們先定義一個reduce函數；它的前提是send和receive兩個方法都被調用過了；這里存在兩種順序可能性：如果receive先被調用了，f被保存下來直到send被調用，這和常見的listener沒有區(qū)別；但π也允許反過來的順序，send先被調用了，則c和f都被保存下來，等到receive調用的時候再使用，這就是π里的兩個前綴會block后面的表達式估值的實現。

無論send和receive的實際調用順序如何，我們都希望reduce可以隨機執(zhí)行sender和receiver提供的回調函數。

class Channel {
    reduce () {
        if (!this.sendF || !this.receiveF) return
        let rnd = Match.random()
        if (rnd >= 0.5) {
            this.sendF()
            this.receiveF(this.c)
        } else {
            this.receiveF(this.c)
            this.sendF()
        }
    }

    send (c, f) {
        this.c = c
        this.sendF = f
        this.reduce()
    }

    receive (f) {
        this.receiveF = f
        this.reduce()
    }
}

寫出reduce之后send和receive就是無腦代碼了；在標題的表達式里每個channel都只用了一次，所以我們不用在這里糾結如果重復發(fā)送和接受的情況如何解決；各種參數檢查和錯誤處理也先不管了，先跑起來試試。

最后所有的代碼都在這里，加了一點打印信息，你可以運行起來感受一下，也思考一下：

π系統(tǒng)capture了并發(fā)編程里哪些最重要的特性？沒有capture下來哪些？這段代碼里有什么東西是可能在實際編程問題上可以派上用場？

callback，emitter，promise，async/await能用Channel表達或者實現嗎？如果能，大概會是什么樣？

rx和這個Channel有什么異同？

class Channel {
  constructor (name) {
    this.name = name
  }

  reduce () {
    if (!this.sendF || !this.receiveF) return
    console.log(`passing name ${this.c.name} via channel ${this.name}`)
    let rnd = Math.random()
    if (rnd >= 0.5) {
        this.sendF()
        this.receiveF(this.c)
    } else {
        this.receiveF(this.c)
        this.sendF()
    }
  }

  send (c, f) {
    console.log(`${this.name} sending ${c.name}`)
    this.c = c
    this.sendF = f
    this.reduce()
  }

  receive (f) {
    console.log(`${this.name} receiving`)
    this.receiveF = f
    this.reduce()
  }
}

const channel = name => new Channel(name)
const x = channel("x")
const y = channel("y")
const w = channel("w")
const a = channel("a")

x.receive(z => z.send(a, () => console.log("term 1 over")))
x.send(w, () => y.send(w, () => console.log("term 2 over")))
y.receive(v => v.receive(u => (() =>
  console.log(`term 3 over, received ${u.name} finally`))()))

為什么vertical pipe表示的并發(fā)組合沒了呢？因為連續(xù)執(zhí)行上面代碼段里最后三句的時候，就是并發(fā)了；一定要說語言上什么符號對應了"|"的話，對于JavaScript就是;號了；它本來在語言上是statement的順序組合，在我們這個代碼里，就是并發(fā)組合了。