https://www.cnblogs.com/yeungchie/
Cadence 提供二次开发的 SKILL 语言,它是一种基于通用人工智能语言 — LISP 的交互式高级编程语言。①
SKILL 语言支持一套类似 C 语言的语法,大大降低了初学者学习的难度,同时高水平的编程者可以选择使用类似 LISP 语言的全部功能。所以 SKILL 语言既可以用作最简单的工具语言,也可以作为开发任何应用的、强大的编程语言。
SKILL 可以与底层系统交互,也提供了访问 Cadence 各个工具的丰富接口,用户可以通过 Skill 语言来访问,并且可以开发自己的基于 Cadence 平台的工具。
我的环境是 Virtuoso IC618 平台 ( SKILL37.00 ) ,可能存在某些特性不适用于旧版本。
① LISP 即 List Processing,是最早和最重要的符号处理编程语言之一,它于 1958 年由美国的 J. McCarthy 提出,LISP 在人工智能方面获得广泛应用。
下面 $CDSHOME 指 Virtuoso 安装路径
sh> $CDSHOME/tools/bin/cdsFinder &
sh> $CDSHOME/tools/bin/cdnshelp &
sh> $CDSHOME/bin/skill -V
# @(#)$CDS: skill version 37.18 06/26/2020 19:54 (sjfhw830) $
getSkillVersion()
; "SKILL37.00"
举例一种 Hello World 的写法。
println( "Hello World" )
; "Hello World"
一般习惯使用 println 来直接打印内容做简单的查看,同时也便于查看数据类型,这个后面讲数据类型部分会提到。
(comment)
; 这是单行注释
/*
这是
多行注释
*/
由于 Skill 语言是基于 LISP ,因此它除了支持 函数表示法
同时也支持 前缀表示法
来编写代码。
函数表示法 类似 C
func( arg1 arg2 )
前缀表示法 类似 Tcl
( func arg1 arg2 )
这里推荐统一使用 函数表示法
,并需要注意函数名和括号之间不能有空格。
以上的两种表示法可以同时存在,因此在编写代码时候最好注意格式的统一。
错误写法 :
func ( arg1 arg2 )
func
后面多了一个空格,这会将arg1
作为函数名
其次函数和变量的命名风格,Skill 中一般是使用 驼峰命名法 ( Camel-Case ),命名以小写开头,之后的每一个逻辑断点(单词)首字母大写,一般代表类别、作者,像我写的函数和全局变量一般都习惯用 yc
开头。
驼峰命名法也是官方使用的命名方式,现在一些主流的编程语言也比较流行使用这种命名方式。
当然如何选择取决于你自己,下面是一个对比:
驼峰命名法
geGetEditCellView()
dbOpenCellViewByType(libName cellName viewName nil mode)
蛇形命名法(下划线)
ge_get_edit_cell_view()
db_open_cell_view_by_type(lib_name cell_name view_name nil mode)
无论使用哪种命名方式,都要注意风格的统一,所以更推荐与官方函数一样,使用驼峰命名法。
最后再注意命名不能过于简化,例如 a
,b
,c
。命名的目标是至少让人能一眼看出来这个变量是做什么用的(一眼不行看两眼),例如上面的 libName
,cellName
,viewName
。
下面的内容中我可能会使用的一些非常简化变量命名,考虑到只是用于演示,一些变量也没有什么实际的含义,命名就随意些了。
代码块标注使用 LISP 语言只是为了能够正确识别单行注释,毕竟 Skill 还是比较冷门的,很多平台都不支持它的语法高亮。
(boolean)
Skill 中 真用 t
来表示,假用 nil
来表示。
其实参与判断中的值,除了 nil
和空链表以外都可以认为是真,例如:
判断 t
when( t
println( "True" )
)
; t 为真,打印 "True"
判断 10
when( 10
println( "True" )
)
; 10 为真,打印 "True"
判断 "YEUNGCHIE"
when( "YEUNGCHIE"
println( "True" )
)
; "YEUNGCHIE" 为真,打印 "True"
判断 nil
when( nil
println( "True" )
)
; nil 为假,不运行 println 语句
when 语句中第一个参数为判断条件,条件为真才会运行。
可以用函数 type
查看一个数据的类型标识。
type( 'YEUNGCHIE ) ; symbol
type( "YEUNGCHIE" ) ; string
type( list( "YEUNGCHIE" )) ; list
用 println
打印一个数据的内容,同时也能够从打印结果观察到数据类型。
println( 'YEUNGCHIE ) ; YEUNGCHIE
println( "YEUNGCHIE" ) ; "YEUNGCHIE"
println( list( "YEUNGCHIE" )) ; ( YEUNGCHIE )
(string)
字符串用双引号括起来。
myName = "YEUNGCHIE"
; "YEUNGCHIE"
打印字符串
print( myName )
; "YEUNGCHIE"
println
println( myName )
; "YEUNGCHIE"
上面两个 print 的结果看似一样,实际上是有区别的。
Skill 提供了多种 print 函数,可以应对各种使用场景,具体的详解可以看这篇随笔:[ Skill ] print println printf fprintf sprintf lsprintf
相关函数
strcat 字符串连接
a = "YEUNG"
b = "CHIE"
c = strcat( a b )
println( c )
; "YEUNGCHIE"
strlen 字符串长度
下面的 c 沿用上面的变量 c,为了演示不写得过于繁杂、重复。
println(strlen( c ))
; 9
(number)
数字分为 整数 和 浮点数。
整数
18
也可以直接编写成 二进制 ( 0b
前缀 )、八进制 ( 0
前缀 )、十六进制 ( 0x
前缀 ),但默认会输出成 十进制
0b10010 ; 18
024 ; 20
0xFE ; 254
浮点数
3.14
浮点数也可以使用 科学计数法 和 单位后缀 来表示
1e-06 ; 0.000001
1u ; 0.000001
相关函数
整数判断 fixp
fixp( 1 ) ; t
fixp( 1.0 ) ; nil
浮点数判断 floatp
floatp( 1.2 ) ; t
floatp( 2 ) ; nil
奇数判断 oddp
oddp( 1 ) ; t
oddp( 2 ) ; nil
偶数判断 evenp
evenp( 2 ) ; t
evenp( 3 ) ; nil
取整
舍位取整 fix / fix2
fix( 3.2 ) ; 3
;-----------------------------------
flonum = 1.2/(0.1+0.3) ; 3.0
fix( flonum ) ; 2 warning!
Tips 🍉: 第三行经过一番浮点运算后得出 3.0
赋值给 flonum
,舍位取整后结果却是 2 。
这是由于浮点运算误差造成的,实际运算结果会比 3.0
小一点点,有兴趣了解的话可以看下知乎上的一篇回答:
为什么浮点运算有误差?
为了解决这个问题 Skill 在后面的版本中提供了另一个函数来解决。
fix2( flonum ) ; 3
进位取整 ceiling
ceiling( 3.0 ) ; 3
ceiling( 3.2 ) ; 4
四舍五入 round / round2
这函数也有两个版本,与 fix2
同理,不多赘述,反正有 2
用 2
准没错。
round2( 3.2 ) ; 3
round2( 3.5 ) ; 4
;-----------------------------------
round( flonum - 0.5 ) ; 2 warning!
round2( flonum - 0.5 ) ; 3
(list)
链表其实不是一种数据类型,而是一种数据的存储结构。
定义方式
list
list( arg1 arg2 list( arg3 arg4 ) ... )
listA = list( 1 2 )
; ( 1 2 )
'
'( "value1" sym1 (1 2) ... )
这种表达方式需要注意,它不适用于变量元素,例如上面
sym1
并不会带入变量值,而是 symbol 类型'sym1
listB = '( 3 4 )
; ( 3 4 )
:
arg1 : arg2
仅在只有两个元素时使用,通常用来表达一个坐标点
point = 1 : 2
; ( 1 2 )
相关函数
连接两个 list append
listC = append( listA listB )
println( listC )
; ( 1 2 3 4 )
往末尾追加元素 append1
listD = append1( listC 5 )
println( listD )
; ( 1 2 3 4 5 )
往开头追加 cons
listE = cons( 0 listD )
println( listE )
; ( 0 1 2 3 4 5 )
翻转一个 list reverse
listF = reverse( listE )
println( listF )
; ( 5 4 3 2 1 0 )
获取一个 list 元素个数 length
length( listF )
; 6
提取第一个元素 car
car( listF )
; 5
提取除了第一个元素之后的 list cdr
cdr( listF )
; ( 4 3 2 1 0 )
简化 car / cdr
的组合函数
cadr( listF )
其实就是car(cdr( listF ))
的简写
cadr( listF ) ; 4
caddr( listF ) ; 3
根据索引提取 nth
nth( 0 listF ) ; 5
nth( 1 listF ) ; 4
nth( length(listF)-1 listF ) ; 0
元素去重 removeListDuplicates
listG = list( 1 1 2 3 3 1 4 5 5 3 5 ) ; ( 1 1 2 3 3 1 4 5 5 3 5 )
removeListDuplicates( listG ) ; ( 1 2 3 4 5 )
list
是 Skill 语言中非常重要的结构,还有很多相关函数,后面再单独写一篇随笔介绍。
(symbol)
symbol 的写法是用一个单引号开头,例如:'a
、'b
、'c
,这个类型比较抽象,刚接触知道有这么个东西就行,重点是需要用到的时候知道如何去使用。
symbol 实际上是一种指针,每个 symbol 都存在以下几个组成部分(slot):
只有 name 是必要的,其他的部分都可以为空,当一个 文本引用 产生时,会创建一个 symbol ,且 Value 会默认为 'unbound
。
这段话不知道怎么讲更好,贴一下原文:
The system creates a symbol whenever it encounters a text reference to the symbol for the first time. When the system creates a new symbol, the value of the symbol is set to unbound.
当我们创建一个变量会自动生成与之对应的一个 symbol ,默认值为 'unbound
,这个过程是非显式的。
这样,如果需要将一个变量设置为 未定义/未绑定 的状态,则可以将它赋值为 'unbound
。
举个例子 ( 重点是这里 ):
给 arg 赋值为 12,然后打印出来。
arg = 12
println( arg )
; 终端会打印 12
给 arg 再赋值为 'unbound
,然后尝试 print 一下。
arg = 'unbound
println( arg )
; 终端会提示 *Error* eval: unbound variable - arg
当一个变量没有被定义过的时候,引用它但是不赋值时运行会报 Error ,但如果只是想判断某个变量是否被定义了,可以使用函数 boundp
去检测目标变量的 symbol name。
例如,检测一下变量 arg 是否被定义:
arg 已经被赋值为 'unbound
现在是未定义的状态。
boundp( 'arg )
; 结果是 nil
再给它赋值一个值。
arg = 1
boundp( 'arg )
; 结果是 t
判断一个函数是否存在的时候也需要利用到 symbol。
例如,判断一下函数 dbCreateRect
是否存在:
dbCreateRect 是 Virtuoso 自带函数。
fboundp( 'dbCreateRect )
; 结果是 lambda:dbCreateRect
判断一下,函数 QWE123
是否存在:
fboundp( 'QWE123 )
; 不存在,结果是 nil
(table)
Table 是 key / value 对的集合。类似于 Python 中的字典,但又更加强大,Python 字典的 key 只能是不可变数据类型,无法将列表、字典、对象等作为 key。
而在 Skill 中,Table 的 key 和 value 都可以是任意的数据类型:string、symbol、number、list、table、id 等都可以。
定义 makeTable
HASH = makeTable( "Skill HASH" )
赋值
HASH[ 1 ] = "ONE"
HASH[ "2" ] = 2
HASH[ cvId ] = "cellName"
HASH[ 'myName ] = "YEUNGCHIE"
访问
通过 key 查看
HASH[ 1 ] ; "ONE"
HASH[ "2" ] ; 2
如果 key 是 symbol
这时你还可以使用箭头符号 ~>
来访问,非常舒服。
HASH~>myName ; "YEUNGCHIE"
也可以使用函数 get
,不过这个一般不用。
get( HASH "myName" ) ; "YEUNGCHIE"
查看一个哈希的所有 key / value
HASH~>?
; ( myName "2" 1 db:0x21cfda1a )
HASH~>??
; ( myName "YEUNGCHIE" "2" 2 1 "ONE" db:0x21cfda1a "cellName" )
遍历一个哈希所有元素
foreach( key HASH
printf( "key: %A , value: %A\n" key HASH[ key ] )
)
; key: db:0x21cfda1a , value: "cellName"
; key: 1 , value: "ONE"
; key: "2" , value: 2
数组 和 向量 不常用,简单了解一下就行。
(array)
(不常用)
定义
declare
declare( ARRAY[10] )
赋值
ARRAY[2] = 4
ARRAY[3] = 5
访问
println( ARRAY[2] * ARRAY[3] )
; 20
println( ARRAY[0] )
; unbound
println( ARRAY[10] )
; *Error* arrayref: array index out of bounds - ARRAY[10]
(vector)
(不常用)
定义
makeVector
VECTOR = makeVector( 10 )
赋值
VECTOR[2] = 4
VECTOR[3] = 5
访问
println( VECTOR[2] * VECTOR[3] )
; 20
println( VECTOR[0] )
; unbound
println( VECTOR[10] )
; *Error* arrayref: array index out of bounds - VECTOR[10]
操作符 | 函数 | 备注 | |||
加 | + | a + b | plus | plus(a b) | |
减 | - | a - b | difference | difference(a b) | |
乘 | * | a * b | times | times(a b) | |
除 | / | a / b | quotient | quotient(a b) | |
余 | remainder | remainder(a b) | 用于整数 | ||
modf | modf(a b) | 用于浮点数 | |||
乘方 | ** | a ** b | expt | expt(a b) | |
开方 | sqrt | sqrt(a b) |
操作符 | 函数 | |||
直接赋值 | = | a = 1 | setq | setq( a 1 ) |
自增 | += | a += 1 | ||
自增 (+1) | ++ | ++a | add1 | add1( a ) |
a++ | postincrement | postincrement( a ) | ||
自减 | -= | a -= 1 | ||
自减 (-1) | -- | --a | sub1 | sub1( a ) |
a-- | postdecrement | postdecrement( a ) |
Tips 🍉:
++a
会将 a 加一后的值返回,返回值是 2a++
会先返回 a 的值后加一,返回值是 1add1( a )
会返回 2,但不改变 a 的值postincrement( a )
会返回 1,a 的值会加一变成 2操作符 | 函数 | |||
相等 | == | a == b | equal | equal( a b ) |
不相等 | != | a == b | nequal | nequal( a b ) |
小于 | < | a < b | lessp | lessp( a b ) |
小于等于 | <= | a <= b | leqp | leqp( a b ) |
大于 | > | a > b | greaterp | greaterp( a b ) |
大于等于 | >= | a >= b | geqp | geqp( a b ) |
几乎相等 | nearlyEqual | nearlyEqual( a b ) |
操作符 | 函数 | |||
与 | && | a && b | and | and( a b ) |
或 | || | a || b | or | or( a b ) |
非 | ! | ! a | not | not( a ) |
真/假 情况运行的都是单一的语句
if( 条件
当条件成立时运行
当条件不成立时运行
)
例如:当 a > b 成立时,打印 "Yes";不成立时,打印时 "No"。
if( a > b
println( "Yes" )
println( "No" )
)
真/假 情况需要运行多条语句
if( 条件
then
当条件成立时运行 1
当条件成立时运行 2
else
当条件不成立时运行 3
当条件不成立时运行 4
)
例如:当 a > b 成立时,c 赋值 1 然后打印 "Yes";不成立时,c 赋值为 0 然后打印时 "No"。
if( a > b
then
c = 1
println( "Yes" )
else
c = 0
println( "No" )
)
多层嵌套
Skill 不能用 if-elsif-else
这种简化的写法,但是逻辑是一样的,后级的 if
需要在上一级的 else
中。
if( 条件 A
当条件 A 成立时运行
if( 条件 B
否则 当条件 B 成立时运行
以上条件都不成立时运行
)
)
if( 条件 A
then
当条件 A 成立时运行 1
当条件 A 成立时运行 2
else
if( 条件 B
then
否则 当条件 B 成立时运行 3
否则 当条件 B 成立时运行 4
else
以上条件都不成立时运行 5
以上条件都不成立时运行 6
)
)
例如下面想实现:
if( a > b
println( "Yes" )
if( a > c
println( "Yes" )
println( "No" )
)
)
第二个 if
虽然不是 单一语句,但可以将整个 if( a > c ... )
看做一个整体,所以也可以忽略 then
/else
。
这还有一个问题,当需要判断多个条件的时候 if
的写法就太不好看了,这时就可以使用 case
或者 cond
,等会讲。
when / unless 就非常简单了,只当给定的条件为 真/假 的时候才运行给定的语句
条件为真才运行。
when( a > b
println( "Yes" )
)
条件为假才运行。
unless( a > b
println( "No" )
)
前面说了 case
/cond
可以用来优化多条件下的 if
,因此逻辑是一样的。
case
当所有的条件都是对一个变量做是否相等的判断的时候,可以使用 case
。
例如,现在有一个变量 arg:
case( arg
( "a"
println( "It is a" )
)
(( "b" "c" )
println( "It is b or c" )
)
( "d"
println( "It is d" )
)
( t
println( "Unmatch" )
)
)
上面的语句换成 if
需要这样写:
if( arg == "a"
println( "It is a" )
if( arg == "b" || arg == "c"
println( "It is b or c" )
if( arg == "d"
println( "It is d" )
println( "Unmatch" )
)
)
)
很明显 case
的写法更加清晰,观感上也更加舒服。
cond
case
的使用情景比较单一,当条件多且判断的对象或者逻辑不唯一的时候可以 cond
。
例如,现在需要对变量 a 做几个判断:
cond(
( a > b
println( "Bigger than b" )
)
( a > c
println( "Bigger than c" )
)
( t
println( "Smallest" )
)
)
指定一个起始整数(initial)和终止整数(final),依次遍历从 initial 到 final 组成的 list 的每一个元素,间隔为 1。
下面用 for
打印从 0 到 2:
for( x 0 2
println( x )
)
; 0
; 1
; 2
指定一个 list ,依此遍历每一个元素。
下面用 foreach
打印从 0 到 2:
foreach( x list( 0 1 2 )
println( x )
)
; 0
; 1
; 2
也可以同时遍历多个 list
foreach(( x y z ) list( 0 1 2 ) list( 3 4 5 ) list( 6 7 8 )
printf( "%d %d %d\n" x y z )
)
; 0 3 6
; 1 4 7
; 2 5 8
foreach 的返回值是第一个 list,( 0 1 2 )
指定一个条件,当条件为真时才会运行,当条件为假时跳出 while 循环。
下面用 while
打印从 0 到 2:
a = 0
while( a < 3
println( a )
a++
)
; 0
; 1
; 2
(函数)
procedure
函数来声明。下面举个例子:
procedure( myAdd( a b )
a + b
); myAdd
这个子程序用来实现输入变量 a
和 b
,返回 a + b
的值。
myAdd
就是子程序的名称。a
和 b
是定义需要两个参数,这两个参数会作为子程序的局部变量,局部变量等会再细讲。a + b
是代码块部分,仅有一行也作为最后一行,因此会返回两个变量相加之后的值。下面看下如何调用这个 myAdd
:
myAdd( 1 2 )
; 返回 3
参数不是必须的,也可以提供一个空列表(括号里空着不写)作为参数的定义,意味着这个子程序不需要参数。
procedure( myAddOneAndTwo()
3
); 这个子程序直接返回 3
myAddOneAndTwo()
; 3
p
let
用来定义局部变量,定义变量的改动不会影响到代码块外的同名变量。用法:
a = 5
let(( a )
a = 7
println( a )
)
println( a )
返回的结果是:
7
5
如果想给 let
中的变量赋值一个默认值,出了在开头写一个赋值语句,上面的 let
还可以这样简化:
let(( a( 7 ) )
println( a )
)
prog
相对于 let
增加了 return
和 go
函数的支持。prog
的默认返回值是 nil
由于 prog
默认的返回值是 nil
,因此需要一个方法能够指定返回值是什么。而 return
就能够实现在一个 prog
中的任意位置跳出,并指定返回值。
示范一下:
prog(( a )
a = 1
when( a < 5
return( t )
)
return() ; 当 return 不指定的返回值的时候等同于 return( nil )
)
上面的程序由于 a
为 1 ,小于 5,因此执行 when 中的语句,跳出 prog 并返回 t 。
运用 prog + return
可以更加灵活的控制 while
、 foreach
等循环结构。
例如下面两段相似的代码中,prog
的位置不同对程序运行的影响:
满足条件提前跳出循环
a = 0
prog(( )
while( a <= 3
a++
when( a == 2 return())
print( a )
); while
); prog
当前 a == 2 时,跳出 prog
,由于 prog
在 while
循环外部,因此整个循环会结束。
结果打印 1
。
满足条件直接运行下一个循环
a = 0
while( a <= 3
prog(( )
a++
when( a == 2 return())
print( a )
); prog
); while
当前 a == 2 时,跳出 prog
,由于 prog
在 while
循环内部,因此当前循环结束,不执行 print
直接进入下一次循环。
结果打印 134
。
go
用来实现在一个 prog
内部,跳转到指定的 标签
。
prog(( a )
a = 0
LABEL ; 打个标签
print( a++ )
when( a <= 3
go( LABEL ) ; 跳转到标签的位置
)
); prog
上面的例子实现一个循环,判断 ++a
的值小于等于 3 时回到 LABEL
标记的位置重复运行,结果打印 0123
。
go
的使用存在一些限制,不能在多个 prog
之间跳转,不能往循环内跳转:
prog
)上面我们已经定义了一个 myAdd
函数,由于执行的过程是做加法,因此它有一个隐含的要求是:输入的两个变量都必须是数字,否则运行会报错
can't handle
我们可以在子程序的定义中加入这个变量类型的判断:
procedure( myAdd( a b )
unless( numberp( a ) && numberp( b )
error("myAdd: Argument should be number.")
)
a + b
); myAdd
运行上面的函数试试:
myAdd( "1" "2" )
; *Error* myAdd: Argument should be number.
不过我们不需要这么麻烦去直接写每个参数的判断,Skill 已经提供了更简单的方法:
procedure( myAdd( a b "nn")
a + b
); myAdd
再运行上面的函数试试:
myAdd( "1" "2" )
; *Error* myAdd: argument #1 should be a number (type template = "nn") - "1"
可以看到仅仅是在参数定义之后追加了 "n"
就可以起到效果,第一个 n 声明第一个参数需要为数字(number 缩写成 n),第二个 n 同理声明第二个参数。
不过这个写法还能简化:... ( a b "n") ...
,像这样只写一个 n
就代表所有的参数都必须为数字类型。
下面举例一些常见的用于声明数据类型的缩写:
缩写 | 内部命名 | 数据类型 |
---|---|---|
d | dbobject | id , Cadence 数据对象 |
x | integer | 整数 |
f | flonum | 浮点数 |
n | number | 整数 或者 浮点数 |
g | general | 通用的 , 任何数据类型 |
l | list | 链表 |
p | port | I / O 句柄 |
t | string | 字符串 |
s | symbol | symbol(符号) |
S | stringSymbol | symbol 或者 字符串 |
u | function | 函数对象 , 函数名 或者 lambda 对象 |
... | ... | ... |
定义输入参数时候,可以使用一些 修饰 符号来做到类似 Getopt 的效果,常用的如下:
@rest
定义 不限数量 的输入
@optional
定义 可有可无 的输入,需要按顺序
@key
定义 可有可无 的输入,需要指定参数名
注意 🍉:语法上 @optional 和 @key 不能同时使用,功能上 @rest 和 @optional 同时使用会存在矛盾。
还是用上面的子程序 myAdd
来举例。
场景:现在这个程序,只能接受两个参数做加法,如果输入是 3 个或者更多怎么办? 我不知道有多少个参数需要一次性输入。这时候就需要用到 @rest
优化一下 myAdd
:
procedure( myAdd( @rest args ) ; 修饰符号写在被修饰参数的前面
prog(( result )
result = 0
foreach( num args
printf( "myAdd: %n + %n\n" result num )
result += num
)
return( result )
)
); myAdd
运行一下:
myAdd( 1 2 3 )
; myAdd: 0 + 1
; myAdd: 1 + 2
; myAdd: 3 + 3
; => 6
例子中只定义了一个输入参数,被声明 @rest
后,args
会变成一个 list 参与子程序内部运行,接着遍历所有元素加起来就行了。
场景:
myAdd
现在只能做加法,如果我想自定义运算类型,且要求不指定运算类型的时候默认做加法怎么办?这时候就需要用到 @optional
下面的例子为了避免矛盾,就不使用 @rest
了,将 args
用一个 list 来输入。
procedure( myCalc( args @optional opt("+") ) ; 参数后面的括号内写上默认值,也可以写成 ( opt "+" )
prog(( result )
result = car( args )
args = cdr( args )
foreach( num args
printf( "myCalc: %n %s %n ; " result opt num )
case(opt
("+" result += num )
("-" result -= num )
("*" result *= num )
("/" result /= num )
); 按照不同的 opt 执行不同的操作
)
return( result )
)
); myCalc
运行一下:
myCalc( list( 1 2 3 ))
; myCalc: 1 + 2 ; myCalc: 3 + 3 ;
; => 6
myCalc( list( 1 2 3 ) "-")
; myCalc: 1 - 2 ; myCalc: -1 - 3 ;
; => -4
myCalc( list( 1 2 3 ) "*")
; myCalc: 1 * 2 ; myCalc: 2 * 3 ;
; => 6
myCalc( list( 1.0 2 3 ) "/")
; myCalc: 1.000000 / 2 ; myCalc: 0.500000 / 3 ;
; => 0.1666667
场景:上面 @optional 的要求是输入的参数必须按顺序,即 先
args
后opt
,我不想固定这个顺序怎么办?这时候就需要用到 @key
使用格式:
定义
procedure( function( @key key1 key2 )
...
)
不指定默认值的时候,默认值就是 nil
运行:
function( ?key1 arg1 ?key2 arg2 ... )
在上面 myCalc
的基础上改一下:
procedure( myCalc( @key args opt("+") )
; prog ... 过程完全一致,这里就不写了
); myCalc
运行一下:
myCalc( list( 1 2 3 ) "+")
*Error* myCalc: extra arguments or keyword missing - ((1 2 3) "+")
myCalc( ?args list( 1 2 3 ) ?opt "+")
; myCalc: 1 + 2 ; myCalc: 3 + 3 ;
; => 6
myCalc( ?opt "+" ?args list( 1 2 3 ))
; myCalc: 1 + 2 ; myCalc: 3 + 3 ;
; => 6
(lambda)
匿名函数,顾名思义没有名字的函数,不同于 procedure
需要指定一个函数名,lambda
不需要指定一个函数名,它会返回一个 lambda 对象。
sum = lambda(( a b )
a + b
)
上面已经定义了一个匿名函数,并将 lambda 对象赋值给了 sum
变量。 接下来就可以用 funcall
函数来使用它:
funcall( sum 1 2 )
; 3
funcall
的第一个参数接收一个函数对象 sum
,后面的参数依次作为输入。
如果待输入的变量保存在一个 list 中,也可以用 apply
函数来使用它:
apply( sum list( 1 2 ))
; 3
可以看到,apply
的第一个参数接收一个函数对象 sum
,第二个参数是一个 list ,list 中的元素依次对应 sum
需要接收的参数。
这里需要注意的是,并不是
sum
需要接收一个 list,而是apply
接收一个 list,再把其中的元素依次作为sum
的输入进行传参。sum
接收到的依然是两个参数。
此外 funcall
、apply
不光可以接收 lambda,也可以接收一个 symbol 变量,前面讲到 symbol 存在一个 slot 是 Function binding ,因此也可以调用非匿名的子程序。
apply( 'plus list( 1 2 ))
; 3
这里的
'plus
就作为plus
函数的引用。
mapcar
的效果其实也是循环,之所以放到 《子程序》 章节来讲,是因为使用这个函数需要先了解子程序是什么。
假设现在有一个 list:
numbers1 = list( 1 3 2 4 5 7 )
现在要将这个 list 中的每个元素都 +1
,用 foreach
可以这样做:
numbers2 = nil
foreach( x numbers1
numbers2 = append1( numbers2 ++x )
)
println( numbers2 )
; ( 2 4 3 5 6 8 )
可以看到还是比较啰嗦的,换做 mapcar
就很方便了:
numbers3 = mapcar( 'add1 numbers1 )
; ( 2 4 3 5 6 8 )
也可以接受一个 lambda
匿名函数:
numbers4 = mapcar( lambda(( a ) a++ ) numbers1 )
; ( 2 4 3 5 6 8 )
另外前面讲到 foreach
的返回值是第一个 list,配合 mapcar
后可以将每次循环的结果作为返回值。
numbers5 = foreach( mapcar x numbers1
x++
)
; ( 2 4 3 5 6 8 )
联系客服