[perl.scm]

[[define]] *_*

 $_ 現在行
 TODO: @_ の扱いをどうするか. *@_* を新たに定義するか, *_* を使うか

[[define]] *.*

 $. 現在行番号

[[define]] *argv*

 $ARGV ファイル名
 TODO: 処理系によっては定義されているかもしれない

[[define]] *chop?*

 一行読んだ後に改行を落とすか?
 TODO: default で #t のほうがよい?

[[define-syntax]] setq!

 (setq! var expr) ==> セットされた var の値

[[define-syntax]] ++

 (++ n &optional (delta 1))

 (++ n)
 (++ n 10)

[[define-syntax]] --

 (-- n &optional (delta 1))

 (-- n)
 (-- n 10)

[[define-syntax]] when

 (when test &body body)

 (when (> i 0) (display i))

[[define-syntax]] unless

 (unless test &body body)

 (unless (> i 0) (display i))

[[define-syntax]] while

 (while test &body body)
 (while (<> line files) &body body)
 (while (<> files) &body body)
 (while (<>) &body body)

 1. (while (< i 10) (print i) (set! i (+ i 1)))
   通常の形式

 2. Perl の while (<>) { ... } に似た形式
 2.1 (while (<> line files) (display line))
   files(list) のファイルを順に開き,一行づつ line にセットして body を評価

 2.2 (while (<> files) (display *_*))
   同上,ただし行は *_* にセットする

 2.3 (while (<>) (display *_*))
   同上,ただしファイルではなく標準入力より読み込む

 補: 現在の行は *_*, 現在の行番号は *.*, 現在のファイル名は *argv*,
     行末を常に chop するには *chop?* を #t にセットする.

 TODO: 最後に評価した式の値を返す

[[define-syntax]] m

 (m re &optional (str *_*))

 (m "a.c" str)
 (m "a.c")

 $str =~ m/$re/;

[[define-syntax]] s

 (s re subst &optional (all? #f) (str *_*))

 (s "a.c" "def" #t str)
 (s "a.c" "def" #t)
 (s "a.c" "def")

 $str =~ s/$re/$subst/;
 $str =~ s/$re/$subst/g; # all? が #t の場合

[[define-syntax]] s!

 (s! re subst &optional (all? #f) (str *_*))

 (s! "a.c" "def" #t str)
 (s! "a.c" "def" #t)
 (s! "a.c" "def")

 $str =~ s/$re/$subst/;
 $str =~ s/$re/$subst/g; # all? が #t の場合

[[define-syntax]] split

 (split re &optional (str *_*))

 (split "," str)
 (split "\\s+")

 split(/$re/, $str);

[[define-syntax]] chop

 (chop &optional (str *_*) (delta 1))

 (chop "abcde" 2)
 (chop "abcde")
 (chop)

 chop("abcde"); # Perl

 TODO: delta の範囲チェック

[[define-syntax]] chop!

 (chop! &optional (str *_*) (delta 1))

 (chop! str 2)
 (chop! str)
 (chop!)

 chop($str); # Perl

[[define]] cl-pop

 (cl-pop lst)

 Lisp 風 pop

[[define-syntax]] cl-pop!

 (cl-pop! lst)

[[define]] cl-push

 (cl-push obj lst)

 Lisp 風 push

[[define-syntax]] cl-push!

 (cl-push! obj lst)

[[define-syntax]] last

 (last lst &optional (n 1))

[[define-syntax]] butlast

 (butlast lst &optional (n 1))

[[define]] (cl-shift lst)

 (cl-shift lst)

 Lisp 風 shift

[[define-syntax]] cl-shift!

 (cl-shift! lst)

[[define]] (cl-unshift obj lst)

 (cl-unshift obj lst)

 Lisp 風 unshift

[[define-syntax]] cl-unshift!

 (cl-unshift! obj lst)

[[define]] pop

cl-pop

[[define]] pop!

cl-pop!

[[define]] push

cl-push

[[define]] push!

cl-push!

[[define]] shift

cl-shift

[[define]] shift!

cl-shift!

[[define]] unshift

cl-unshift

[[define]] unshift!

cl-unshift!

[[define]] (ref sequence k)

 (ref sequence k)

 TODO: 拡張性を考えたら generic function

[[define-syntax]] print

 (print &optional (str *_*))

 (print "foo")
 (print)

 print; # Perl

[[define]] pr

print

[[define-syntax]] for

 (for (init end inc) &body body)

 (for ((i 0) (< i 10) (+ i 1))
   (display i) (newline))
 (for (((i 0) (j 10)) (and (< i 10) (> j 5)) ((+ i 1) (- j 1)))
   (display `(,i ,j)) (newline))

 注意: init フォームと inc フォームの変数の数,順序は同一でなければならない

 TODO: 最後に評価した式の値を返す

[[define-syntax]] string-for-each


[[define-syntax]] vector-for-each


[[define-syntax]] each

 (each var sequence &body body)

 (each x '(a b c) (display x) (newline))
 (each x "abc"    (display x) (newline))
 (each x '#(a b c) (display x) (newline))

[[define]] dot

string-append

[[define]] nl

newline

[[define]] (object->string obj)

 Common-Lisp の princ-to-string 相当

 TODO: オブジェクトの外部表現を string で得る方法がある?
 TODO: 拡張性を考えたら generic function

 http://www.sci.toyama-u.ac.jp/~iwao/Scheme/r5rsj/html/r5rsj.html#SEC21
 を参照

[[define]] (list-join delim lst)


[[define]] (vector-join delim vec)


[[define]] (join delim sequence)

 sequence を delim で join した文字列を返す

 (join ", " '("a" "b" "c"))
   ==> "a, b, c"
 (join #\space '#(a b c))
   ==> "a b c"
 (join #\, '("a" #\b c 4.5 (#\e #\f) #(g h) () (j . k) #t))
   ==> "a,b,c,4.5,(e f),#(g h),(),(j . k),#t"

[[define]] (rm-if-not p lst)

 Perl と関係ないけど...,  Common-Lisp の remove-if-not 相当

 (rm-if-not (lambda (x) (> x 3)) '(3 5 2 4 6 3))
   ==> (5 4 6)

[[define]] (sort p lst)

 quick sort

 注意: Common-Lisp と引数の順番が違う(Perl とは一緒)

 (sort < '(3 5 2 4 6 3))
   ==> (2 3 3 4 5 6)
 (sort char<? (string->list "Scheme"))
   ==> (#\S #\c #\e #\e #\h #\m)