[ Skill ] Cadence Skill 语言入门

https://www.cnblogs.com/yeungchie/

Cadence Skill

Cadence 提供二次开发的 SKILL 语言，它是一种基于通用人工智能语言 — LISP 的交互式高级编程语言。①

SKILL 语言支持一套类似 C 语言的语法，大大降低了初学者学习的难度，同时高水平的编程者可以选择使用类似 LISP 语言的全部功能。所以 SKILL 语言既可以用作最简单的工具语言，也可以作为开发任何应用的、强大的编程语言。

SKILL 可以与底层系统交互，也提供了访问 Cadence 各个工具的丰富接口，用户可以通过 Skill 语言来访问，并且可以开发自己的基于 Cadence 平台的工具。

我的环境是 Virtuoso IC618 平台 ( SKILL37.00 ) ，可能存在某些特性不适用于旧版本。

① LISP 即 List Processing，是最早和最重要的符号处理编程语言之一，它于 1958 年由美国的 J. McCarthy 提出，LISP 在人工智能方面获得广泛应用。

如何查看官方资料

下面 $CDSHOME 指 Virtuoso 安装路径

cdsFinder

模糊查找 Skill 函数，查看简单介绍。

sh> $CDSHOME/tools/bin/cdsFinder &

cdnshelp

查看更加详细的内容，软件的使用手册。

sh> $CDSHOME/tools/bin/cdnshelp &

Skill Version

查看 Skill 版本

sh> $CDSHOME/bin/skill -V
# @(#)$CDS: skill version 37.18 06/26/2020 19:54 (sjfhw830) $

也可以启动 Virtuoso 在 CIW 中执行

getSkillVersion()
; "SKILL37.00"

基础语法

Hello World

举例一种 Hello World 的写法。

println( "Hello World" )
; "Hello World"

一般习惯使用 println 来直接打印内容做简单的查看，同时也便于查看数据类型，这个后面讲数据类型部分会提到。

注释 `(comment)`

单行注释

; 这是单行注释

多行注释

/*
  这是
  多行注释
*/

代码风格

语法风格

由于 Skill 语言是基于 LISP ，因此它除了支持 Skill-Syntax 同时也支持 Lisp-Syntax 来编写代码。

Skill-Syntax 类似 C

$f_{(x)}$
```
func( arg1 arg2 )
```
Lisp-Syntax 类似 Tcl

$(f \ x)$
```
( func arg1 arg2 )
```
One-Line 类似 Shell

$f \ x$
```
func arg1 arg2
```

初学的话，我推荐统一使用 Skill-Syntax，并需要注意函数名和括号之间不能有空格。

以上的三种表示法可以同时存在，因此在编写代码时候最好注意格式的统一。

错误写法 : func ( arg1 arg2 )

func 后面多了一个空格，这会使用 One-Line 句法，将 arg1 作为函数名接受参数 arg2，并将返回值作为参数输入给 func 函数。

命名风格

其次函数和变量的命名风格，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" )
)
; "True"
; => nil

判断 10

when( 10
  println( "True" )
)
; "True"
; => nil

判断 "YEUNGCHIE"

when( "YEUNGCHIE"
  println( "True" )
)
; "True"
; => nil

判断 nil

when( nil
  println( "True" )
)
; => nil

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
```
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 )
; => "YEUNGCHIE"
```
- strlen 字符串长度
  
  下面的 c 沿用上面的变量 c，为了演示不写得过于繁杂、重复。
```
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 )
```

符号 `(symbol)`

symbol 的写法是用一个单引号开头，例如：'a、'b、'c，这个类型比较抽象，刚接触知道有这么个东西就行，重点是需要用到的时候知道如何去使用。

symbol 实际上是一种指针，每个 symbol 都存在以下几个组成部分（slot）：

Print name ( name )
Value
Function binding
Property list

只有 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 )
自增 (+1)	++	a++	postincrement	postincrement( a )
自减	-=	a -= 1
自减 (-1)	--	--a	sub1	sub1( a )
自减 (-1)	--	a--	postdecrement	postdecrement( a )

Tips 🍉:

假设 a = 1
++a 会将 a 加一后的值返回，返回值是 2
a++ 会先返回 a 的值后加一，返回值是 1
add1( 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

真/假情况运行的都是单一的语句

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
    )
)
```
例如下面想实现：
- 当 a > b 成立时，打印 "Yes"；
- 否则当 a > c 成立时，打印 "Yes"；
- 都不成立时，打印时 "No"。
```
if( a > b
  println( "Yes" )
  if( a > c
    println( "Yes" )
    println( "No"  )
  )
)
```
第二个 if 虽然不是 单一语句，但可以将整个 if( a > c ... ) 看做一个整体，所以也可以忽略 then/else。

这还有一个问题，当需要判断多个条件的时候 if 的写法就太不好看了，这时就可以使用 case 或者 cond ，等会讲。

when / unless

when / unless 就非常简单了，只当给定的条件为真/假的时候才运行给定的语句

条件为真才运行。

when( a > b
  println( "Yes" )
)

条件为假才运行。

unless( a > b
  println( "No" )
)

case / cond

前面说了 case/cond 可以用来优化多条件下的 if ，因此逻辑是一样的。

case

当所有的条件都是对一个变量做是否相等的判断的时候，可以使用 case。

例如，现在有一个变量 arg：
- 当 arg 等于 "a" 时，打印 "It is a"；
- 否则当 arg 等于 "b" 或 "c" 时，打印 "It is b or c"；
- 否则当 arg 等于 "d" 时，打印 "It is d"；
- 全都不成立时，打印 "Unmatch"。
```
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 做几个判断：
- 当 a > b 时，打印 "Bigger than b"；
- 否则当 a > c 时，打印 "Bigger than c"；
- 都不成立时，打印 "Smallest"。
```
cond(
    ( a > b
        println( "Bigger than b" )
    )
    ( a > c
        println( "Bigger than c" )
    )
    ( t
        println( "Smallest" )
    )
)
```

循环控制

for

指定一个起始整数（initial）和终止整数（final），依次遍历从 initial 到 final 组成的 list 的每一个元素，间隔为 1。

下面用 for 打印从 0 到 2：

for( x 0 2
    println( x )
)
; 0
; 1
; 2

foreach

指定一个 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 循环。

下面用 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

局部变量

let

let 用来定义局部变量，定义变量的改动不会影响到代码块外的同名变量。
也是代码块中以最后一段语句的运算结果作为返回值。

用法：

a = 5
let(( a )
  a = 7
  println( a )
)
println( a )

返回的结果是：

7
5

如果想给 let 中的变量赋值一个默认值，出了在开头写一个赋值语句，上面的 let 还可以这样简化：

let(( a( 7 ) )
  println( a )
)

prog

prog 相对于 let 增加了 return 和 go 函数的支持。
prog 的默认返回值是 nil

return

由于 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

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 同时使用会存在矛盾。

@rest

还是用上面的子程序 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 参与子程序内部运行，接着遍历所有元素加起来就行了。

@optional

场景：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

@key

场景：上面 @optional 的要求是输入的参数必须按顺序，即先 args 后 opt，我不想固定这个顺序怎么办？这时候就需要用到 @key

使用格式：

定义
```
procedure( function( @key key1 key2 )
  ...
)
```
不指定默认值的时候，默认值就是 nil

运行：

function(  ?key1 arg1  ?key2 arg2  ...  )

在上面 myCalc 的基础上改一下：

procedure( myCalc( @key args opt("+") )
  ; prog ... 过程完全一致，这里就不写了
); myCalc

运行一下：

这里没有指定参数名称( keyword )，会报错

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
)

funcall

上面已经定义了一个匿名函数，并将 lambda 对象赋值给了 sum 变量。接下来就可以用 funcall 函数来使用它：

funcall( sum 1 2 )
; 3

funcall 的第一个参数接收一个函数对象 sum，后面的参数依次作为输入。

apply

如果待输入的变量保存在一个 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

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 )

文件读写

看这篇：[ Skill ] 文件读写 & IO 句柄 - YEUNGCHIE - 博客园

posted @ 2021-09-14 23:17 YEUNGCHIE 阅读(47271) 评论(42) 编辑收藏举报

刷新页面返回顶部

YEUNGCHIE

[ Skill ] Cadence Skill 语言入门

Cadence Skill

如何查看官方资料

cdsFinder

cdnshelp

Skill Version

基础语法

Hello World

注释 (comment)

代码风格

语法风格

命名风格

真 / 假 (boolean)

数据类型

字符串 (string)

数字 (number)

链表 (list)

符号 (symbol)

对照表 / 哈希 (table)

数组 / 向量

数组 (array) (不常用)

向量 (vector) (不常用)

数据运算

算数运算

赋值运算

比较运算

逻辑运算

条件判断

if

when / unless

case / cond

循环控制

for

foreach

while

子程序

定义子程序 (函数)

局部变量

let

prog

return

go

输入类型限制

常见数据类型

可选的输入参数

@rest

@optional

@key

匿名函数 (lambda)

funcall

apply

mapcar

文件读写

公告

注释 `(comment)`

真 / 假 `(boolean)`

字符串 `(string)`

数字 `(number)`

链表 `(list)`

符号 `(symbol)`

对照表 / 哈希 `(table)`

数组 `(array)` `(不常用)`

向量 `(vector)` `(不常用)`

定义子程序 `(函数)`

匿名函数 `(lambda)`