ShoneSharp语言(S#)的设计和使用介绍系列（8）— 最炫“公式”风

ShoneSharp语言(S#)的设计和使用介绍

系列（8）— 最炫“公式”风

作者：Shone

声明：原创文章欢迎转载，但请注明出处，https://www.cnblogs.com/ShoneSharp。

摘要: S#公式是由各种操作数（常量、变量、或子公式）和操作符（算符、函数、属性、方法、或子公式）组合而成，公式和子公式可以形成复杂嵌套结构。S#还在公式级别提供了相当于其他语言语句级别的系统专用公式，使得S#公式表达能力超强，易用性也好，可以说是最为炫酷的公式表达风格。

软件： S#语言编辑解析运行器（ShoneSharp.13.6.exe），运行环境.NET4.0，单EXE直接运行，绿色软件无副作用。网盘链接https://pan.baidu.com/s/1nv1hmJn

公式是编程语言最基础的表达结构,所有语言都支持公式。各种语言的公式语法各不相同,表达能力也差别很大。比如LISP公式语法很简单，就是S表达式，但表达能力却非常强大，负面的影响的易用性不好。有的语言则语法比较好用，而表达能力有限。

S#语言的公式语法符号很多，表达能力非常强，易用性也不错，其综合能力在所有语言中也是领先的，可以说“S#带来了最炫的公式表达风格”。

对于上述主观论断，看好本博文后有不服者可以来辩。另外语言是相通的，其他语言公式的特性基本上S#都支持，因此其他语言爱好者看一眼本文，也可以提升对自己所学语言的领悟。

一、公式概念

公式是由各种操作数（常量、变量、或子公式）和操作符（算符、函数、属性、方法、或子公式）组合而成，可以解析并计算得到数据值。

由于公式的操作数和操作符都可能是另一个公式构成，因此一个公式可以包含非常复杂的嵌套结构，用来表达或计算各种更加复杂的数据。这一点和LISP语言非常相似。

S#公式中可以包含注释，注释分行注释//xxx和块注释/*xxx*/，使用方法与C#相同。

二、常量引用公式

常量是系统预先定义命名的数据值，在任何上下文中都是保持数据值不变。不同数据类型预定义了不同的常量,具体可以在软件的"所有"面板中查阅。

常量引用公式是直接引用常量名称，是最简单的公式之一，其计算结果就是系统预定义的数据值（如true、false、null等）。

三、变量引用公式

变量是用户自定义命名的数据值，必须先定义后引用。在不同上下文中用户可以定义同名变量，因此变量引用是依赖于上下文的。

变量的命名规则基本与C#相同，即字母或_开头的包含一道多个字母或数字或_的名字，并排除与系统预定义常量以及其他关键字重复的名字(包括para, eval, if, case, switch, each, eachx, for, forx, dup, dupx, iter, do, sum, prod, integal, load, parse, call, func, class, foreach, while, var, default, return, break, continue, in, else, true, false, null, local, parent, this, base, host, import, include等)。

变量引用公式是直接引用变量名称，也比较简单，但其计算结果需要在上下文中进行查找。上下文其实指的是变量堆栈链，S#的有些公式（下面会介绍）带有局部变量堆栈，允许定义变量，如果这些公式中又嵌套了其他带有局部变量堆栈的子公式，那么就会形成变量堆栈链。

变量引用默认会先在当前公式最近的局部变量堆栈查找，如果找不到就会到上一级的变量堆栈，一层层找直至找到为止（类似JavaScript）。看一下代码实例就明白了：

{

    a = 10  ,

    b = {

          c = 20 ,

          d = a + c   //d计算结果为30

        }

}

四、运算符号公式

运算符号（简称算符）是系统预定义的一些操作符符号，用于对操作数进行计算求值。其功能类似与函数调用，只不过写法上有指定的格式，如单目、双目、三目以及其他。

通常算符都是针对特定数据类型的，但有些算符可以处理多种类型，为便于理解下面从简单类型到复杂类型分开介绍。

4.1 数值算符  +  -  *  /  %  ^

数值算符用于对操作数进行数值计算，与其他语言不同，S#可以处理多种类型，另外操作数互换结果可能不同。举例如下：

-10, -[10,20], -{10,20,30}             //取负

10+3, [10,20]+3, {10,20,30}+3          //加法

10-3, [10,20]-3, {10,20,30}-3          //减法

10*3, [10,20]*3, {10,20,30}*3          //乘法

10/3, [10,20]/3, {10,20,30}/3          //除法

10%3, [10,20] %3, {10,20,30}%3         //取余

10^3, [10,20]^3, {10,20,30}^3          //乘方

4.2 布尔算符  <  >  <=  >=  ==  !=  !  &&  ||

布尔算符用于对操作数进行计算获得布尔值，基本用法与C#相同。举例如下：

10<20    //判断是否小于

10>20    //判断是否大于

10<=20   //判断是否小于等于

10>=20   //判断是否大于等于

10==20   //判断是否等于

10!=20   //判断是否不等于

!true                //判断条件取反

true && false        //并且判断，即两个条件是否都成立

true || false        //或者判断，即两个条件是否有一个条件成立

4.3 数组算符  [,]  ,  ~  []  .  $  #  &  |  .. .$ .~ .< .>

数组是包含同类型数据的一个集合，S#有专用于对数组进行构造和运算的算符。

[10, 20, 30, 40, 50]     //构造数组的最基本用法

10, 20, 30, 40, 50       //构造数组的简化用法，独立没有冲突时可以省略[]

~[10, 20, 30, 40, 50]    //数组元素反向重排，结果[50,40,30,20,10]

[10, 20, 30, 40, 50][2]  //索引数组元素，索引号从0开始，可以变量，结果30

[10, 20, 30, 40, 50].2   //索引数组元素，索引号从0开始，必须数字，结果30

 [10, 20, 30, 40, 50][2,3,4]  //离散索引多个数组元素，索引号从0开始，可以变量，结果[30,40,50]

[10, 20, 30, 40, 50][2:4]     //连续索引多个数组元素，索引号从0开始，可以变量，结果[30,40,50]

3$10, 2$[20,30]          //整体重复数组元素，结果[10,10,10,20,30,20,30]

3#10, 2#[20,30]          //交错重复数组元素，结果[10,10,10,20,20,30,30]

[10,20,30]&[1,2]         //整体插入数组元素，结果[10,1,2,20,1,2,30]

[10,20,30]|[1,2]         //交错插入数组元素，结果[10,1,20,2,30]

10..15           //构造连续范围数组，结果[10,11,12,13,14,15]

10..15.$2        //构造指定步长的连续范围数组，结果[10,12,14]

10..15.~2        //构造接近步长的等距范围数组，结果[10,11.666666666666666,13.333333333333332,14.999999999999998]

10..15.<2        //构造小于等于步长的等距范围数组，结果[10,11.666666666666666,13.333333333333332,14.999999999999998]

10..15.>2        //构造大于等于步长的等距范围数组，结果[10,12.5，15]

4.4 列表算符  {,}  ~  []  .  $$  ## $$$ ###  &  |  ... .$ .~ .< .>

列表是可以包含不同类型数据的一个集合，与数组类似，S#有专用于对列表进行构造和运算的算符。

列表与数组的使用原则：单层同类型尽量用数组，性能更好；多层次数据结构使用列表，表达能力更强。

{true, 20, 30, 40, 'hjx'}     //构造列表的最基本用法

~{10, 20, 30, 40, 50}         //数组元素反向重排，结果{50,40,30,20,10}

{true, 20, 30, 40, 'hjx'} [2]  //索引列表元素，索引号从0开始，可以变量，结果30

{true, 20, 30, 40, 'hjx'}.2    //索引列表元素，索引号从0开始，必须数字，结果30

{true, 20, 30, 40, 'hjx'} [2,3,4]  //离散索引多个列表元素，索引号从0开始，可以变量，结果{30,40,'hjx'}

{true, 20, 30, 40, 'hjx'} [2:4]    //连续索引多个列表元素，索引号从0开始，可以变量，结果{30,40,'hjx'}

2$${true, 10, 'hjx'} //整体重复列表元素，结果{true,10,'hjx', true,10,'hjx'}

2##{true, 10, 'hjx'} //交错重复列表元素，结果{True,True,10,10,'hjx','hjx'}

2$$${true, 10, 'hjx'}     //整体多重列表元素，结果{{true,10,'hjx'}, {true,10,'hjx'}}

2###{true, 10, 'hjx'}     //交错多重列表元素，结果{{True,True},{10,10},{'hjx','hjx'}}

{true, 10, 'hjx'}&{1,2}   //整体插入列表元素，结果{True,1,2,10,1,2,'hjx'}

{true, 10, 'hjx'}|{1,2}   //交错插入列表元素，结果{True,1,10,2,'hjx'}

10...15              //构造连续范围列表，结果{10,11,12,13,14,15}

10...15.$2           //构造指定步长的连续范围列表，结果{10,12,14}

10...15.~2          //构造接近步长的等距范围列表，结果{10,11.666666666666666,13.333333333333332,14.999999999999998}

10...15.<2          //构造小于等于步长的等距范围列表，结果{10,11.666666666666666,13.333333333333332,14.999999999999998}

10...15.>2          //构造大于等于步长的等距范围列表，结果{10,12.5，15}

4.5 数据表算符

数据表是包含一系列键值数据对的集合，注意与其他语言不同，数据表带有局部变量堆栈，其键就是堆栈中的变量名称，而值就是变量值，而且数据表的基类是数据表，这就意味着数据表也可以通过索引进行访问。

数据表可以很复杂，其中变量的作用范围可以有多种，后面将专题介绍。

{A=5, B=[1,2], C={10,20,30}}      //构造基本数据表

{A=5, B=[1,2], C={10,20,30}}['B'] //通过键值索引数据表元素，结果[1,2]

{A=5, B=[1,2], C={10,20,30}}.B    //通过属性访问数据表元素，结果[1,2]

{A=5, B=[1,2], C={10,20,30}}[1]   //通过列表索引数据表元素，结果[1,2]

{A=5, B=[1,2], C={10,20,30}}.1    //通过列表索引数据表元素，结果[1,2]

4.6 特殊算符  ()  <>  ??  ?  $  &  *

(10+20)              //用于对公式进行隔离计算，可以改变其优先级，结果15

(10, 20)             //构造二维点坐标

(10, 20, 30)         //构造三维点坐标

<10, 20>             //构造二维向量

<10, 20, 30>         //构造三维向量

null??10             //非空值计算符号，左侧值为空则取右侧值，结果10

?’(20+30)/2’     //对字符串解析并求值，结果25

$’c:\hjx.shone’  //打开字符串表示的文件，并对其内容解析并求值

&xxx             //获取右侧公式解析树节点的标记引用，类似C#中指针取地址

*xxx             //获取右侧公式解析树节点的结果值引用，类似C#中指针取值

五、面向对象公式

5.1 属性调用

属性调用是面向对象的表达方式之一，可以方便表达被调用对象直接暴露的相关信息，其基本格式是：对象.属性名称。

[10,20,30,40,50].Count           //获取数组的个数，结果5

注意属性调用优先查找被调用对象的局部变量堆栈，如果没有变量堆栈或找不到，就会去调用该对象类型的系统预定义属性（不同数据类型预定义了不同的方法,具体可以在软件"所有"面板中查阅），如果还没有则报错。例如：

{A=1,B=2}.Count                 //结果2

{A=1,B=2,Count=100}.Count       //结果100，注意优先调用Count变量而不是列表的属性Count。

理论上属性写法可以用函数代替（如count(xxx)），但属性写法更加简洁直观，可以形成很有特色的链式写法，如A.B.C….，一直点下去。

5.2 方法调用

方法也是面向对象的表达方式之一，可以方便表达针对被调用对象的各种操作，其基本格式是：对象.方法名称(参数,…)。

[10,20,30,40,50].Sub(2)          //从数组[10,20,30,40,50]的索引2位置开始提取子数组，结果[30,40,50]

注意方法调用也会优先查找被调用对象的局部变量堆栈，如果没有变量堆栈或找不到，就会去调用该对象类型的系统预定义方法（不同数据类型预定义了不同的方法,具体可以在软件"所有"面板中查阅），如果还没有则报错。例如：

{A=1,B=2}.Sub(1)                      //结果{2}

{A=1,B=2,Sub=x=>10*x}.Sub(1)          //结果10，注意优先调用Sub函数变量而不是列表本身的方法Sub

理论上方法写法也可以用函数代替（如Sub(xxx,2)），但方法比较直观，可以形成很有特色的链式写法，如A.B().C()….，一直点下去。

六、面向函数公式

6.1 函数调用

函数调用是S#公式使用最为广泛的表达方式，其基本格式是：函数名称(参数,…)。其中每个参数又可以是一个子公式，从而可以形成更加复杂的公式嵌套结构。

最常用的函数是数值函数，注意与其他语言不同，S#数值函数大都支持多种数据类型。例如求余弦函数值：

cos( 30 )                           //结果0.86602540378443871

cos( [ 10 , 20 , 30 ] )             //结果[0.984807753012208,0.93969262078590843,0.86602540378443871]

cos( { 10 , [ 20 , 30 ] , 40 } )    //结果{0.984807753012208,[0.93969262078590843,0.86602540378443871],0.766044443118978}

注意函数调用也会优先查找当前最近的局部变量堆栈，如果找不到就会到上一级的变量堆栈，一层层往上找，如果还找不到，就会去调用系统预定义函数（不同数据类型预定义了不同的函数,具体可以在软件"所有"面板中查阅），如果还没有则报错。例如：

{a=1, b=cos(30)}             //结果{a=1,b=0.86602540378443871}

{cos=x=>10*x, b=cos(30)}     //结果{cos=x=>10*x,b=300}，注意优先调用cos函数变量而不是求余弦函数值。

6.2 函数定义

函数式语言强调的“函数是一等公民”，指的是函数自身也可以作为一个变量，即用户可自定义命名的函数变量，也支持先定义后引用，在不同上下文中可以定义同名函数变量。

上面的x=>10*x其实就是一种匿名的函数定义（与C#类似）,由于函数定义有多种形式和高级使用特性，下面一个章节“一等公民函数爱炫巧”会专门讲函数定义。

六、系统专用公式

前面讲的都是其他语言大都有公式表达结构，本节列出的很多是S#特有的表达方式，语法上类似函数调用，但是使用专用关键字和分隔符。这里很多公式其实都等价于其他语言的语句功能了。

6.1 直接求值公式

parse/include/call(参数)

parse('(20+'+'30)/2')        //?算符的增强版，可对变量公式进行字符串解析并求值，结果25

include('c:\hjx. '+'shone')     //$算符的增强版，对变量公式进行字符串解析并打开文件，再对其内容解析并求值

call('c'+'os', 30)           //可以通过字符串变量公式，动态调用变量或函数，结果0.5

6.2 顺序求值公式

eval(局部变量堆栈: 结果公式)

顺序求值公式通过建立局部变量堆栈并对结果公式进行求值和输出。其中局部变量堆栈有一到多个变量赋值构成，用逗号分割。变量赋值写法是：变量名称=变量公式。结果公式可以直接引用局部变量，若输出数组可以采用省略写法。例如：

eval(a=1, b=2: a+b)        //结果3

eval(a=1, b=2: a,3$b,a)    //结果[1,2,2,2,1]

eval(a=1, b=2: {a,3$b,a})    //结果{1,[2,2,2],1}

顺序求值公式的使用非常广泛，能力等价于C#中的顺序求值语句{;;return;}。

6.3 条件求值公式

if(条件公式? 结果公式1 : 结果公式2)

条件求值公式先计算条件公式并进行判断，如果为真则对结果公式1进行求值和输出，否则对结果公式2进行求值和输出。条件公式没有变量堆栈，结果公式若输出数组也可以采用省略写法。例如：

if(10>5? 1: 2)        //结果1

if(10>5? 1,2: 2)      //结果[1,2]

if(10>5? 1;2: 2)      //结果{1,2}

条件求值公式的使用也非常广泛，能力等价于C#中的条件求值公式(?:)或语句(if else)。

6.4 分支求值公式

case(数据公式; 分支公式系列 : 缺省结果公式)

分支求值公式先计算数据公式，然后对分支公式系列的每个分支进行测试，如果等于某个分支公式值，则输出该分支结果公式的计算结果，否则输出缺省结果。每个分支的写法是：分支公式->结果公式，多个分支间用逗号分隔。分支公式没有变量堆栈，结果公式若输出数组也可以采用省略写法。例如：

case(1+2; 1->5, 3->10: 0)       //结果10

分支求值公式能力等价于C#中的分支求值语句(switch)。

6.5 判断求值公式

switch(单个变量赋值; 分支公式系列 : 缺省结果公式)

判断求值公式先计算变量公式并赋值，然后对分支公式系列的每个分支进行测试，如果某个分支公式值为真，则输出该分支结果公式的计算结果，否则输出缺省结果。与case差别是，switch有变量堆栈，分支公式必须是布尔值且最好引用前面赋值的变量，结果公式若输出数组也可以采用省略写法。例如：

switch(x=1+2; x<1->5, x>2->10: 0)          //结果10

判断求值公式能力等价于其他语言的模式匹配求值语句。

6.6循环求值公式

each/eachx(循环变量配对序列 : 结果元素公式)

each单重循环求值公式首先建立循环变量堆栈，并把循环变量配对的数据值（通常是数组或列表）逐个循环赋值给变量并对结果元素公式进行求值，最终合并输出为数组或列表。其中循环变量配对写法是：变量名称@数据公式。有多个循环变量配对时用逗号分割，注意每组循环次数以第一个变量为准。循环求值公式有局部变量堆栈，结果公式可以直接引用循环变量，若输出数组可以采用省略写法。另外each表示输出数组，eachx则输出列表。例如：

each(x@[1,2,3]: 2*x)   //结果[2,4,6]

each(x@1..5: 2*x)      //结果[2,4,6,8,10]

each(x@1..5: x,2*x)    //结果[1,2,2,4,3,6,4,8,5,10]

each(x@1..5, y@5..20: (2*x,y)) //多循环结果[(2,5),(4,6),(6,7),(8,8),(10,9)]

eachx(x@[1,2,3]: 2*x)          //结果{2,4,6}

eachx(x@1..5: 2*x)             //结果{2,4,6,8,10}

eachx(x@1..5: x,2*x)   　//结果{[1,2],[2,4],[3,6],[4,8],[5,10]}

eachx(x@1..5: {x,2*x})   //结果{{1,2},{2,4},{3,6},{4,8},{5,10}}

eachx(x@1..5, y@5..20: (2*x,y))   //多循环结果{(2,5),(4,6),(6,7),(8,8),(10,9)}

each循环求值公式能力等价于C#语言的循环语句(foreach)，甚至更强。

each/eachx(循环变量配对序列; 过滤条件公式 : 结果元素公式)

each单重循环求值公式中如果中间加入过滤条件，那么只输出符合过滤条件结果。例如：

each(k@1..5;k%2==0: k)        //结果[2,4]

each/eachx(索引变量: 循环变量配对序列 : 结果元素公式)

each单重循环求值公式中如果前面加入索引变量，那么在每次循环时会自动为索引变量赋值，从0开始，每个循环自动加1。例如：

each(i: k@1..5: k*10+i)       //结果[10,21,32,43,54]

dup/dupx(循环变量配对序列 : 结果元素公式)

dup多重循环求值公式语法与each类似，区别是多组循环时会输出多重循环的结果，数据量更多。例如：

dup(x@1..5, y@5..20: (2*x,y))       //多重循环结果[(2,5),(2,6),(2,7),(2,8),(2,9),(2,10),(2,11),(2,12),(2,13),(2,14),(2,15),(2,16),(2,17),(2,18),(2,19),(2,20),…]

dupx(x@1..5, y@5..20: (2*x,y))      //多重循环结果{{(2,5),(2,6),(2,7),(2,8),(2,9),(2,10),(2,11),(2,12),(2,13),(2,14),(2,15),(2,16),(2,17),(2,18),(2,19),(2,20)},… }

for/forx(循环变量堆栈; 循环条件公式; 变量赋值序列 : 结果元素公式)

for循环求值公式首先建立循环变量堆栈，并执行循环直到不满足条件公式，每次有效循环先对结果元素公式求值再执行循环赋值序列，最终合并输出为数组或列表。其中变量赋值的写法是：变量名称=赋值公式，有多个变量赋值时用逗号分割。for循环求值公式有局部变量堆栈，结果公式可以直接引用循环变量，若输出数组可以采用省略写法。另外for表示输出数组，forx则输出列表。例如：

for(i=0; i<5; i++: i*2)        //结果[0,2,4,6,8]

for(i=0,j=2; i<5; i++,j+=2: (i*2,j))      //多个变量结果[(0,2),(2,4),(4,6),(6,8),(8,10)]

for(i=0; i<5; i++: for(j=2; j<5; j+=2: (i*2,j))) //多重循环结果[(0,2),(0,4),(2,2),(2,4),(4,2),(4,4),(6,2),(6,4),(8,2),(8,4)]

for循环求值公式能力等价于C#语言的循环语句(for)。

6.7 迭代求值公式

iter (结果变量赋值; 循环变量配对序列 : 结果赋值公式)

iter迭代求值公式首先建立循环变量堆栈，初始化结果变量赋值，并把循环变量配对的数据值（通常是数组或列表）逐个循环赋值给循环变量并对结果赋值公式进行求值，最终输出结果变量的最终值。迭代求值公式有局部变量堆栈，结果赋值公式必须引用结果变量。例如：

iter(s=0; k@1..5: s+=2*k)    //结果30

iter (结果变量赋值; 索引变量: 循环变量配对序列 : 结果赋值公式)

iter迭代求值公式中如果中间加入索引变量，那么在每次循环时会自动为索引变量赋值，从0开始，每个循环自动加1。

iter(s=0; i: k@1..5: s+=i)   //结果10

do(结果变量赋值; 循环变量堆栈; 循环条件公式; 变量赋值序列 : 结果赋值公式)

do迭代求值公式首先建立循环变量堆栈，并执行循环直到不满足条件公式，每次有效循环先对结果赋值公式求值再执行循环赋值序列，最终输出结果变量的最终值。do迭代求值公式有局部变量堆栈，结果赋值公式必须直接引用结果变量。例如：

do(s=0; i=0; i<5; i++: s+=i) //结果10

6.8 区间累计公式

区间累计公式其实可以使用迭代公式替换，只是写法复杂一些。考虑到他们在数值计算中经常使用，因此设置专用公式可以提高表达能力。

sum(自变量=开始公式,结束公式; 求和公式)

sum区间累计求和公式首先建立自变量堆栈，并按区间从开始到结束步长为1，逐个循环赋值给自变量并对求和公式进行求值，最终合并输出累加结果。sum公式有局部变量堆栈，结果元素公式可以引用自变量。例如：

sum(x=1,5: x)        //结果15

prod(自变量=开始公式,结束公式; 求积公式)

prod区间累计求积公式与sum求和类似，区别是对求积公式结果进行乘法累积。例如：

prod(x=1,5: x)        //结果120

integal(自变量=开始公式,结束公式; 积分公式)

prod区间累计积分公式与sum求和类似，区别是结果是针对区间的定积分。注意积分公式不用包含dx。例如：

integal(x=0,5: 1)        //结果5

integal(x=0,5: x)        //结果12.5

integal(x=0,5: x*x)      //结果41.6666716337204

已有计算机专家论证过，编程语言只要具备顺序、条件、循环三大控制语句，其算法表达能力是等价的。S#在公式级别就提供了相当于其他语言语句级别的算法能力，更不用说S#还有语句级别的表达。

看了本文，您是否同意“S#是最炫酷的公式表达”？！

声明：原创文章欢迎转载，但请注明出处，https://www.cnblogs.com/ShoneSharp。

软件： S#语言编辑解析运行器（ShoneSharp.13.6.exe），运行环境.NET4.0，单EXE直接运行，绿色软件无副作用。网盘链接https://pan.baidu.com/s/1nv1hmJn