姤：女壯，勿用取女。

彖曰：姤，遇也，柔遇剛也。勿用取女，不可與長也。天地相遇，品物咸章也。剛遇中正，天下大行也。姤之時義大矣哉！

象曰：天下有風，姤 ﹔后以施命誥四方。

䷫︰《》文說︰元，始也。从一从兀。組，綬屬。其小者以為冕纓。从糸，且聲。姤 ䷫ ，偶也。从女后聲。

派︰來知德講︰

杞，枸杞也，杞與瓜皆五月所有之物。乾為果，瓜之象也。因前爻有包魚之包，故此爻亦以包言之。含章者，含藏其章美也。此爻變離，有文明章美之意。又居中，有包含之意，故曰含章。含即杞之包，章即瓜之美。以杞包瓜，即含章之象也。

初六：系于金柅，貞吉，有攸往，見凶，羸豕踟躅。
象曰：系于金柅，柔道牽也。

九二：包有魚，無咎，不利賓。
象曰：包有魚，義不及賓也。

九三：臀無膚，其行次且，厲，無大咎。
象曰：其行次且，行未牽也。

九四：包無魚，起凶。
象曰：無魚之凶，遠民也。

九五：以杞包瓜，含章，有隕自天。
象曰：九五含章，中正也。有隕自天，志不舍命也。

上九：姤其角，吝，無咎。
象曰：姤其角，上窮吝也。

有情天地千絲萬縷，姤且遇也，但求其偶而已，奈何強冠之以柔道之『牽』？恐亦非所願耶！

天地相遇，如果引發『天雷』『地火』，也是乾坤本有之理。宇宙萬象『出』，或知或未知其所『入』，求之於天地相遇之『際』，為得其氣『機』，深入『組元』之道的吧。若自『 λ運算』觀之︰

λ演算是一套用來研究『函式』Function 的『抽象』Abstraction 、函式的『應用』Apply 、『變元』Variable 的『替換』Substitution 以及『函式』之『化約』reduction 的形式語言。λ演算對於泛函式程式語言的興起有著巨大的推動力，比方說人工智慧領域著名的 Lisp 語言，以及後來的 ML 語言和 Haskell 語言。更令人驚訝的是它自身就是一個『世界上最小的通用性程式語言』。由於『函式』與『變元』兩者是任何人不管想用哪種『□□程式語言』來寫『演算法』Algorithm 都需要清楚理解的概念。就讓我們踏上前人走過的足跡，回顧旅途上周遭景緻，說不定會有意外的收穫！！

首先請讀者參考在《Thue 之改寫系統《一》》一文中的『符號定義』，於此我們引用該文中談到數學裡『函數定義』的一小段︰

如此當數學家說『函數』 $f$ 的定義時︰

假使有兩個集合 $S$ 和 $T$ ，將之稱作『定義域』domain 與『對應域』codomain，函數 $f$ 是 $S \times T$ 的子集，並且滿足

$\forall x \ x \in S \ \exists ! \ y \ y \in T \ \wedge \ (x,y) \in f$

，記作 $x \mapsto y = f (x)$ ，『 $\exists \ !$ 』是指『恰有一個』，就一點都不奇怪了吧。同樣『二元運算』假使『簡記』成 $X \times Y \mapsto_{\bigoplus} \ Z$ ， $X=Y=Z=S$ ，是講︰

$z = \bigoplus ( x, y) = x \bigoplus y$ ，也是很清晰明白的呀！！

如果仔細考察 $y = f(x)$ ── 比方說 $y = x^2$ ──，那麼『函數 $f$ 』是什麼呢？『變數 $x, y$ 』又是什麼呢？如果從函數定義可以知道『變數』並不是什麼『會變的數』，而是規定在『定義域』或者『對應域』中的『某數』的概念，也就是講在該定義的『集合元素中』談到『每一個』、『有一個』和『恰有一個』…的那樣之『指稱』觀念。這能有什麼困難的嗎？假使設想另一個函數 $z = w^2$ ，它的定義域與對應域都和函數 $y = x^2$ 一樣，那麼這兩個函數是一樣還是不一樣的呢？如果說它們是相同的函數，那麼這個所說的『函數』就該是『 $\Box^2$ 』，其中 $y, z$ 『變數』只是『命名的』── 函數的輸出之數 ──，而且 $w, x$ 『變數』是『虛名的』── 函數的輸入之數 ──。如果從函數 $f$ 將『輸入的數』轉換成『輸出的數』的觀點來看，這個『輸入與輸出』本就是 $f$ 所『固有的』，所以和『輸入與輸出』到底是怎麼『命名』無關的啊！更何況『定義域或對應域』任一也都不必是『數的集合』，這時所講的『函數』或許稱作『函式』比較好，『變數』或該叫做『變元』。其次假使將多個函數『合成』composition，好比『輸出入』的串接，舉例來講，一般數學上表達成 $g(f(x)) = x^2 + 1$ ，此時假使不補足， $g(x) = x + 1$ 和 $f(x) = x^2$ ，怕是不能知道這個函數的『結構』是什麼的吧？進一步講『函數』難道不能看成『計算操作子』operator 的概念，定義著什麼是 $f + g$ 、 $f - g$ 、 $f * g$ 或 $f / g$ 的嗎？就像將之這樣定義成︰
$(f \otimes g) (x) \ =_{df} \ f(x) \otimes g(x)$

，而將函數合成這麼定義為︰
$(f (g) ) (x) \ =_{df} \ f(g(x))$

。如此將使『函數』或者『二元運算』的定義域或對應域可以含括『函數』的物項，所以說它是『泛函式』functional 的了。

，天地『虛‧匿』無名之情，或可以管窺豹，得見一斑乎！！

生︰以蠡難以測海，欲明程式語言之秘，須知那元語言之『理』，需究這組織之『則』，如是雖秘，終非密不透風，有所遇之哉！！

Toy Parser Generator

abstract

Toy Parser Generator is a lexical and syntactic parser generator for Python. This generator was born from a simple statement: YACC is too complex to use in simple cases (calculators, configuration files, small programming languages, …).

TPG can very simply write parsers that are usefull for most every day needs (even if it can’t make your coffee). With a very clear and simple syntax, you can write an attributed grammar that is translated into a recursive descendant parser. TPG generated code is very closed to the original grammar. This means that the parser works like the grammar. A grammar rule can be seen as a method of the parser class, symbols as method calls, attributes as method parameters and semantic values as return values. You can also add Python code directly into grammar rules and build abstract syntax trees while parsing.

The first application of TPG is TPG itself. The first (not released) version of TPG has been written by hand then was used to generate next versions. Now TPG can generate itself.

For an uptodate documentation, please read tpg.pdf.

Please let me know if you use TPG in one of your projects. I will add you in the list of projects using TPG.

△ TPG 派生三之安裝︰

wget http://cdsoft.fr/tpg/TPG-3.2.2.tar.gz
tar -zxvf TPG-3.2.2.tar.gz
cd TPG-3.2.2/
sudo python3 setup.py install

碼︰家習。請閱讀 tpg.pdf 文件，試將下面程式中文化，比方『 + 』改作『加』，『 * 』變為『乘』，…『 sqrt 』譯釋成『根號』。會心『俚語』，根號 179 之所指。

#!/usr/bin/env python

import math
import operator
import string
import tpg

if tpg.__python__ == 3:
    operator.div = operator.truediv
    raw_input = input

def make_op(op):
    return {
        '+'   : operator.add,
        '-'   : operator.sub,
        '*'   : operator.mul,
        '/'   : operator.div,
        '%'   : operator.mod,
        '^'   : lambda x,y:x**y,
        '**'  : lambda x,y:x**y,
        'cos' : math.cos,
        'sin' : math.sin,
        'tan' : math.tan,
        'acos': math.acos,
        'asin': math.asin,
        'atan': math.atan,
        'sqr' : lambda x:x*x,
        'sqrt': math.sqrt,
        'abs' : abs,
        'norm': lambda x,y:math.sqrt(x*x+y*y),
    }[op]

class Calc(tpg.Parser, dict):
    r"""
        separator space '\s+' ;

        token pow_op    '\^|\*\*'                                              
        token mul_op    '[*/%]'                                                
        token funct2    '(norm)\b'                                             
        token integer   '\d+'                                                  

        START/e ->
                'vars'                   self[v]=e
            |   Expr/e
        ;

        Var/ -> VarId/v ;

        Expr/e -> Term/e ( add_op/op Term/t      t=op(t,f)
                         )*
        ;

        Fact/f ->
                add_op/op Fact/f                 f=op(f,e)
                        )?
        ;

        Atom/a ->
                real/a
            |   integer/a
            |   Function/a
            |   Var/a
            |   ''
        ;

        Function/y ->
                funct1/f ''                y = f(x1,x2)
        ;

    """

    def mem(self):
        vars = sorted(self.items())
        memory = [ "%s = %s"%(var, val) for (var, val) in vars ]
        return "\n\t" + "\n\t".join(memory)

print("Calc (TPG example)")
calc = Calc()
while 1:
    l = raw_input("\n:")
    if l:
        try:
            print(calc(l))
        except Exception:
            print(tpg.exc())
    else:
        break