[ 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)
    

无论使用哪种命名方式,都要注意风格的统一,所以更推荐与官方函数一样,使用驼峰命名法。

最后再注意命名不能过于简化,例如 abc。命名的目标是至少让人能一眼看出来这个变量是做什么用的(一眼不行看两眼),例如上面的 libNamecellNameviewName

下面的内容中我可能会使用的一些非常简化变量命名,考虑到只是用于演示,一些变量也没有什么实际的含义,命名就随意些了。
代码块标注使用 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 。

        img

        这是由于浮点运算误差造成的,实际运算结果会比 3.0 小一点点,有兴趣了解的话可以看下知乎上的一篇回答:
        为什么浮点运算有误差?

        为了解决这个问题 Skill 在后面的版本中提供了另一个函数来解决。

        fix2( flonum )  ; 3
        
      • 进位取整 ceiling

        ceiling( 3.0 )  ; 3
        ceiling( 3.2 )  ; 4
        
      • 四舍五入 round / round2

        这函数也有两个版本,与 fix2 同理,不多赘述,反正有 22 准没错。

        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):

  • 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 )
a++ postincrement postincrement( a )
自减 -= a -= 1
自减 (-1) -- --a sub1 sub1( a )
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

这个子程序用来实现输入变量 ab ,返回 a + b 的值。

  • myAdd 就是子程序的名称。
  • ab 是定义需要两个参数,这两个参数会作为子程序的局部变量,局部变量等会再细讲。
  • a + b 是代码块部分,仅有一行也作为最后一行,因此会返回两个变量相加之后的值。

下面看下如何调用这个 myAdd

myAdd( 1 2 )
; 返回 3

参数不是必须的,也可以提供一个空列表(括号里空着不写)作为参数的定义,意味着这个子程序不需要参数。

procedure( myAddOneAndTwo()
  3
); 这个子程序直接返回 3
myAddOneAndTwo()
; 3

p

局部变量

let

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

用法:

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

返回的结果是:

7
5

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

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

prog

  • prog 相对于 let 增加了 returngo 函数的支持。
  • 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 可以更加灵活的控制 whileforeach 等循环结构。

例如下面两段相似的代码中,prog 的位置不同对程序运行的影响:

  • 满足条件提前跳出循环

    a = 0
    prog(( )
      while( a <= 3
        a++
        when( a == 2 return())
        print( a )
      ); while
    ); prog
    

    当前 a == 2 时,跳出 prog ,由于 progwhile 循环外部,因此整个循环会结束。

    结果打印 1

  • 满足条件直接运行下一个循环

    a = 0
    while( a <= 3
      prog(( )
        a++
        when( a == 2 return())
        print( a )
      ); prog
    ); while
    

    当前 a == 2 时,跳出 prog ,由于 progwhile 循环内部,因此当前循环结束,不执行 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 的要求是输入的参数必须按顺序,即 先 argsopt,我不想固定这个顺序怎么办?这时候就需要用到 @key

使用格式:

  • 定义

    procedure( function( @key key1 key2 )
      ...
    )
    

    不指定默认值的时候,默认值就是 nil

  • 运行:

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

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

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

运行一下:

  1. 这里没有指定参数名称( keyword ),会报错
myCalc( list( 1 2 3 ) "+")

*Error* myCalc: extra arguments or keyword missing - ((1 2 3) "+")

  1. 正确用法
myCalc( ?args list( 1 2 3 ) ?opt "+")
; myCalc: 1 + 2 ; myCalc: 3 + 3 ; 
; => 6
  1. 输入参数不需要按顺序
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 接收到的依然是两个参数。

此外 funcallapply 不光可以接收 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  阅读(41694)  评论(40编辑  收藏  举报