\documentclass[12pt,a4paper]{article}
\usepackage{CJK}
\begin{CJK*}{GBK}{song}
\title{$\chi$ \\ 语言}
\author{Helen Wong, Maple Dance, Eefec Adge, Little Cat, Moon Sky}
\date{2013-10}
\begin{document}
\maketitle
\fontsize{12}{20pt}\selectfont

\section{例子1}

\begin{verbatim}
1    I CREATE chi AS ELF.
2    I CREATE omega AS ELF.

3    chi REFLECT omega TELLING ANY TO
4        THINK SELF, PLUS omega, SHOUT ANSWER.

5    omega REFLECT chi TELLING ANY TO
6        THINK SELF, PLUS chi, SHOUT ANSWER.

7    chi ANSWER "1".
8    omega SHOUT "1".

9    I REFLECT chi TELLING ANY TO
10        IF chi LARGER-THAN "20" THEN LULL chi.
\end{verbatim}

若此，吾应得：

\begin{verbatim}
1    omega say:    1
2    chi say:    1
3    omega say:    2
4    chi say:    3
5    omega say:    5
6    chi say:    8
7    omega say:    13
8    chi say:    21
\end{verbatim}

如其所示，所得为斐波那契数列。

\section{使用哪种语言？}
几个星期前，当Little Cat正在考虑她和Moon计划的新的游戏的时候，她想到
了这么一件事情：一个人无法完全理解另一个人。当我说“你好”的时候，你不知道
我是真的很高兴和你见面还是出于礼貌说出这句话。

但如果真是这样的话，我们怎么完成自己的工作呢？实际上，我们不需要理解
别人到底在表示什么，我们只需要做我们需要做的事情。当其他人说“你好”的
时候，作为对这个事件的反应——并不是出于礼貌或感情——，你说“你好”。

但有意思的是在代码的世界里，事件不是这么发生的。在代码的世界里，我们写下
的代码实际上是“命令”，然后电脑会按照我们的命令行事。按照Maple Dance的理解，
编程语言被他分为以下三种：

\begin{enumerate}
\item 基于指令。如汇编、C、FORTRAN以及其他的大部分语言。
\item 基于函数。如LISP、R、Haskell等。
\item 基于数学。如matlab，IDL等。
\end{enumerate}

也许你会认为C++与上述语言不同，是面向对象的。但是按照Maple Dance的看法，
那只是一种管理大量方法、成员的方法而已。

这些分类其实是基于你在写程序的时候到底是如何分解、叙述任务的。
例如，当你要计算斐波那契数列，如果你正在使用基于指令的语言，你会这么理解：

\begin{verbatim}
a[0] = 1
a[1] = 1
for i = 2..10 do
    a[i] = a[i-1] + a[i-2]
end for
\end{verbatim}

如果你正在使用基于函数的语言，你会这么理解：

\begin{verbatim}
(define fib (lambda (n)
    (if (<= n 2) 1
        (+ (fib (- n 1))
           (fib (- n 2))))))
\end{verbatim}

如果你正在使用基于数学的语言，你会这么理解：

\begin{verbatim}
a_0 = 1
a_1 = 1
a_i = {a_i-1 + a_i-2 | i=(2,10)}
\end{verbatim}

实际上，就算是matlab也无法直接运行上述代码，但这正是你希望一个
基于“数学”的语言所应当理解的。

遗憾的是上述语言都不符合Little Cat的需要，她希望有一个像是真实世界那么运行
的语言：每个人都只专注自己的工作，而不是基于命令、指令或者别的压力。
当然，她可以写出大量的代码撰写相关的类，然后告诉电脑如何操作这些类。

但不幸的是我们的Little Cat很懒（而且很中二很幼稚），所以她不想写这么多代码区告诉
计算机这个世界是什么样子。所以Maple Dance和我决定为她设计一种新的语言。
这个语言就是“chi语言”——0.1版本。

\section{发生了什么？}
于此 chi 语言中，只专注于个人工作之个体名之以“ELF”。
则，于前两行定义二ELF：chi与omega。

\begin{verbatim}
1    I CREATE chi AS ELF.
2    I CREATE omega AS ELF.
\end{verbatim}

若elf欲行某事，必有其因。“因某行某事”之事件名之以“reflection”。
若，I reflect that you say "hello" to say "hello"。
于下句为chi与omega定义reflection。

\begin{verbatim}
3    chi REFLECT omega TELLING ANY TO
4        THINK SELF, PLUS omega, SHOUT ANSWER.

5    omega REFLECT chi TELLING ANY TO
6        THINK SELF, PLUS chi, SHOUT ANSWER.
\end{verbatim}

为定义，需“因”与“果”。于3、4句定义中，
“omega TELLING ANY”为因，其意为：是否omega is telling something。
“ANY”为一关键字指代一切可能，以此，omega具体所述之言无关紧要，
确有“说”之行为为要。“果”为关键字“TO”之后之句。因后数句主语均为“chi”，
因此主语可省略之。此后，chi “THINK SELF, PLUS omega”此两事件
意为“omega + chi”，或言之以斐波那契数列之元素“a\_i = a\_i-1 + a\_i”。
当此二句完成，至“果”之最后，chi “SHOUT” 计算之结果以告知他人工作完成。

下一回合中，omega必会得知chi TELLING ANY，则其将会于此“因”行自己之事。
类此之工作将往复发生，直至“I”因chi大于20使之停之。

\begin{verbatim}
9    I REFLECT chi TELLING ANY TO
10        IF chi LARGER-THAN "20" THEN LULL chi.
\end{verbatim}

此reflection中使用了“IF … THEN … ELSE”句式。当chi之值大于20，“I”将“LULL”之。
“LULL”意为使elf眠，则无法对任何事件行reflection。以“WAKE”可将elf唤起。
因chi眠，其无法进行“TELL”之行为，则omega亦停止工作。

余下上述未能提到两句为：

\begin{verbatim}
7    chi ANSWER "1".
8    omega SHOUT "1".
\end{verbatim}

其意为定义chi与omega初值。“ANSWER”与“SHOUT”不同之处将由后述。

\section{代码如何工作？}
我们需要告诉你们的第一件事是：这门语言并不是一门独立工作的语言，从一开始就被
设计为一种延伸语言。

chi语言被设计为一种脚本语言，但是在读取文本文件时并不会进行工作，只有elf和
action以及reflection会被定义。但是要除去第7行和第8行。或者应当这么说：我们希望，
在脚本中进行的是“定义”而不是具体的“行为”。第7和8行只是为了给出初始值。

“某人行某事”是进行一个工作最基本的行为格式，所以，每个工作需要一个主语，一个谓语，
还有可能需要一个宾语。比如“I say hello”，“I”是主语，“say”是谓语，“hello”是宾语。
如果你学过C++或Python或其他面向对象的语言，“I”是类，“say”是类的成员函数，“hello”
是此函数的参数。

所以，即使是“定义”也是一个行为，这个行为必须要有一个执行者，那就是“I”。比如
“I CREATE chi AS ELF”，“I”是主语。在下一个版本里，我准备给每个elf加入权限，这样，
像是“CREATE”和“DEFINE”这样的行为只能由“I”或者其他高阶个体执行。

读完脚本后，我们就得到了两个elf和分别与两个elf捆绑的一个reflection。
在母编程语言（对Little Cat来说，是C语言）中，我们需要调用一个函数或者子例程来
使得chi语言工作一个“回合”。一个回合的意思是chi语言会检查所有elf的所有reflection来
看看需不需要执行相关reflection。

如果一个elf “TELL”了什么或者“SHOUT”了什么，被TELL或者SHOUT的话语会被赋予
这只ELF的“WORDS”。例如，“I TELL "hello"”，“hello”会变成“I”的“WORDS”。一个elf
的ANSWER是另一个东西，例如，chi计算了“2+2”，计算结束后，他告诉其他人“工作完成”。
那么，“4”是chi的ANSWER，而“工作完成”是chi的“WORDS”。同时，ANSWER也是一个elf的值。

WORDS只会存在一个回合，此回合结束后就变成了LAST-WORDS。所以，此回合后，
将不会再有elf对此words起反应。但是answer会一直存在。例如，计算“2+2”后，chi说出
“工作完成”。“工作完成”这句话在说完后声音会消失，它只是一条信息。但是计算的结果不会消失。
如果WRODS一直存在，以其为反映的个体就会一直工作。

一个回合中，elf的words与answer不会改变，即使它确实需要改变，也会在回合结束后再变。
或者说，这些elf是并行的。本回合后，母语应当得知本回合中是否有任何的TELL，如果没有，
下一回合不应当有elf会有所反映，因此母语也没有必要再使得其运行一回合。

\section{shout、tell与answer}
如前所述，一个ELF的与外界交流的输出有两种：words与answer。

如果运行 chi TELL "hello"，则words会置为“hello”，而answer不变。

如果运行 chi ANSWER "hello"，则words不变，而answer会置为“hello”。

如果运行 chi SHOUT "hello"，则words和answer都会置为“hello”。

你可能注意到了，有一个行为叫做“ANSWER”，而有别的事物也叫做“ANSWER”。
在其他的语言中，这是不允许的。但是如果我说：“answer the answer”，
我相信你能明白我是什么意思。所以，在不同的环境中，“ANSWER”被解释为不同意思。

所以，还有很多你必须知道的关于ANSWER与WORDS的事情。

chi ANSWER "hello" 中“ANSWER” 是一个行为。

chi TELL ANSWER 中“ANSWER”是一个事物，或者说是一个全局变量。

chi TELL ANSWER OF chi 中“ANSWER”是chi这个ELF的一个属性变量。

chi TELL WORDS OF chi 中“WORDS”是chi这个ELF的一个属性变量。

“ANSWER”与“ANSWER OF chi”是不同的。如果运行事件“PLUS "3"”，
实际上会运行的是“ANSWER = ANSWER + 3”。ANSWER是一个全局变量。
但是“ANSWER OF chi”是另一回事，如果运行事件“ANSWER "hello"”，
全局变量ANSWER不会改变，变的是chi这个ELF中的一个名为ANSWER的属性变量。
Who run "ANSWER "hello"", whose "ANSWER" will become
"hello", but "ANSWER" won't change.

\section{常量}
常量是每个语言所必须的，例如字符串、整数、浮点数、布尔变量等。在chi语言中，只有
一种常量：字符串。

如果你运行“PLUS "3"”，你必须使用母语实现行为“PLUS”，并且将参数“3”转换成数字3。

因为只使用字符串作为常数，所有的东西都可（必）以（须）表示为字符串。

\section{变量集合}
chi TELL "1"/"2"/"3".

运行这个事件后，chi的WORDS将会变成“1/2/3”，“/”是一个作为分割的关键字。
使用“PART 1 OF WORDS OF chi”可以得到“1”, 而“PART 2 OF WORDS OF chi”可以得到“2”。
“WORDS OF chi”可以得到“1/2/3”.

“chi TELLING ANY.”会使得全局变量ANSWER变为“false”，“chi TELLING ANY/ANY/ANY.”
会使其变成“true”，“chi TELLING "1"/"2"/"3".”使其变成“true”，“chi TELLING ANY/"2"/ANY.”
同样使其变成“true”。

chi ANSWER "a"/"b"/"c".

使用“PART 1 OF chi”可以得到“a”，使用“PART 2 OF chi”可以得到“b”，“chi”可以得到“a/b/c”。

\section{预定义}
\begin{enumerate}
\item \verb-<SUBJECT> CREATE <elf> AS ELF.-

举例说明，“I CREATE chi AS ELF.”，实际上，“AS ELF”可以被忽略。但下个版本里
我想要加入新的种类例如GOD、HUMAN和DEVIL。

\item \verb-<SUBJECT> DEFINE <action> TO <event>, <event>, ... <event>.-

举例说明，“I DEFINE say-hello a TO ANSWER "say", TELL a/"hello".”
此句定义了一个“行为”。

\item \verb-<SUBJECT> REFLECT <event> TO <event>, <event>, ... <event>.-

举例说明，“chi REFLECT omega TELLING "hello" TO TELL "hello".”

\item \verb-<SUBJECT> TELL <OBJECT>.-

\item \verb-<SUBJECT> SHOUT <OBJECT>.-

\item \verb-<SUBJECT> ANSWER <OBJECT>.-

\item \verb-<SUBJECT> IF <event> THEN <event>, ... <event> ELSE <event>, ... <event>.-

如果在事件序列中需要使用“IF THEN ELSE”，使用分号“;”作为其结束而不是句号。
举例说明，“I DEFINE go a TO IF a larger-than "10" THEN a ANSWER "10"; I TELL "done".”

\item \verb-<SUBJECT> TELLING <OBJECT>.-

测试是否<SUBJECT> is telling <OBJECT>。如果此命题为真，将全局变量ANSWER的值变为“true”，
否则为“false”。

\item \verb-<SUBJECT> ASK <SUBJECT 2> TO <EVENT>.-

这个功能将在未来加入，如果“权限”这一说法存在，某些elf将不能进行某些行为，那么，他们必须
请求其他elf完成这些事情。

\item \verb-<ATTRIBUTE> OF <elf>-

属性可以是WORDS或者ANSWER，在以后的版本，可能加入新的属性。

\item \verb-PART <number> OF <elf>-

\item \verb-PART <number> OF <ATTRIBUTE> OF <elf>-

数字只能是整数。

\item \verb-<ans 1>/<ans 2>/.../<ans n>-

\item \verb-<SUBJECT> LULL <elf>.-

\item \verb-<SUBJECT> WAKE <elf>.-
\end{enumerate}

\section{终语}

如果你读到了这里，谢谢你为理解这个诡异的语言付出了这么多的时间。
每个章节都是由我们5人所撰写。因我们5人均不是英语为母语，所以此文的英文版本可能有些错误。

本文并不是 "$\chi$ 语言" 的全部，实际上，我们还没有实现这个语言，但是，
对Eefec和Little Cat来说这门语言十分有趣，因此Helen决定撰写成文以告知他人。
因为我们5人均是工作在身，且十分懒惰，所以实际的实现应该是很久之后的事情。

每个章节都是不同的人写的。顺带一提，Little Cat略微中二，
她写的内容略为难懂且不允许别人代笔，请多见谅。

"例子1" 由 Little Cat 撰写。

"使用哪种语言？" 由 Eefec Adge 撰写。

"发生了什么？" 由 Little Cat 撰写。

"代码如何工作？" 由 Maple Dance 撰写。

"shout、tell与answer" 由 Eefec Adge 撰写。

"常量t" 由 Helen Wong 撰写。

"变量集合" 由 Helen Wong 撰写。

"预定义" 由 Maple Dance 撰写。

"终语" 由 Moon Sky 撰写。

本文的 \TeX{} 文档由我撰写，并翻译为英文。

\end{CJK*}
\end{document}