もっとマクロのこと

可変長引数のリスト走査

(require "common.scm")
;; 複数のlistの各要素を組にしたlistを返す、いわゆるzip関数

;; 2つのリストのそれぞれの要素をtuple化したlistを返す
(list-map-n
	(fun (v1 v2) (tuple v1 v2))
	'(1 2 3) '(4 5 6)
	)

;; 3つのリストのそれぞれの要素をtuple化したlistを返す
(list-map-n
	(fun (v1 v2 v3) (tuple v1 v2 v3))
	'(1 2 3) '(4 5 6) '(7 8 9)
	)

anaphoricマクロ

(require "common.scm")

(anaphoric-args anaph-iter List.iter2)

(anaph-iter
	(
		(print_string "sum: ")
		(print_int (+ _1 _2))
		(print_newline)
		)
	'(1 2 3)
	'(4 5 6)
	)

(require "common.scm")
(anaphoric-args anaph-map list-map-n)
(define ls
	(anaph-map
		(
			(+ _1 _2 _3)
			)
		'(1 2 3)
		'(4 5 6)
		'(7 8 9)
		))

可変長引数の関数定義

;; 2つ以上の引数を受け取ります(2つは必須)
;; 3つ目以降の引数はlistとして受け取り、
;; 以下の例では変数optで参照可能です。
(defun-varargs vfunc1 (v1 v2 . opt)
	(print_int v1)
	(print_newline)
	(print_int v2)
	(print_newline)
	(List.iter
		(fun (x)
			(print_stringa "opt: ")
			(print_int x)
			(print_newline)
			)
		opt)
	)

(vfunc1 1 2 3 4 5)

;; 任意の数の引数をlistとして受け取ります。
;; 以下の例では変数argsで参照可能です。
(defun-varargs vfunc2 args
	(List.iter
		(fun (x)
			(print_stringa "args: ")
			(print_int x)
			(print_newline)
			)
		args)
	)

(vfunc2 1 2 3 4 5)

リストの内包表記(組み込みリスト用)

• (for 変数名 開始 終了)
  一時変数を1ずつ増加させながら、以降の式を繰り返します
  例: (for x 1 20)
• (for 変数名 開始 終了 増加数)
  一時変数を任意の増加数ずつ増加させながら、以降の式を繰り返します
  例: (for x 1 20 2)
• (map 変数名 list)
  listの要素を先頭から順に取りだしながら、以降の式を繰り返します
  例: (map x '(1 2 3))
• (if 条件)
  条件が真だった場合のみ、以降の式を実行します
  例: (if (= (mod x 2) 0))
• (let 変数名 式)
  局所変数を定義し、以降の式から参照可能になります
  例: (let y (* x x))

(require "common.scm")
;; 1から20までの整数うち、2の倍数を2乗した数値によるリストを生成する
(define ls (list-ec (for x 1 20) (if (= (mod x 2) 0)) (* x x)))

(List.iter
	(fun (x)
		(print_int x)
		(print_newline)
		)
	ls
	)

;; 既存のリストから各要素を2倍した新たなリストを生成する
(define ls2 (list-ec (map x ls) (* x 2)))

(List.iter
	(fun (x)
		(print_int x)
		(print_newline)
		)
	ls2
	)

関数の合成

(require "common.scm")

(define incl (fun (x) (+ x 1)))
(define decl (fun (x) (- x 1)))
(define pow (fun (x) (* x x)))
(print_int ((compose decl pow incl pow) 3))

契約プログラミング

(require "common.scm")

(define cont_f
	(contract-fun (x y)
			(
				(in (< x 4))
				(out result (< result 10))
				)
			(+ x y)
		))

(try
	(match
			(Contract_assert_failure (Contract_in_assert expr)
				(print_string (^ "arguments error\n")))
			(Contract_assert_failure (Contract_out_assert expr)
				(print_string (^ "return value error\n")))
			(_ ()
				(print_string "unknown error\n"))
			)

	(print_int (cont_f 3 8))
	(print_newline)
	)

Haskell風の関数定義

(require "common.scm")

(defun-matched-clauses
	(fact (1) 1)
	(fact (x) (* x (fact (- x 1))))
	
	(sum ('()) 0)
	(sum ((:: hd tl)) (+ hd (sum tl)))
	
	(foldr (f v '()) v)
	(foldr (f v (:: x xs)) (f x (foldr f v xs)))

	)


(print_int (fact 10))
(print_newline)

(print_int (sum '(1 2 3 4 5)))
(print_newline)

(print_int (foldr (fun (x y) (+ x y)) 0 '(1 2 3 4 5)))
(print_newline)

遅延リスト

gosh s_exp_ocaml.scm lazy_list_sample.scm > result.ml
ocamlc lazyList.ml result.ml

より実験的なマクロ機構

準備中

準備中

;; syntax-rulesの例
(define-syntax swap-sr
   (syntax-rules ()
      ((_ a b)
         (let ((tmp (! a)))
            (:= a (! b))
            (:= b tmp)
            )
         ))
   )

;; syntax-caseの例
(define-syntax swap-sc
   (lambda (form)
      (syntax-case form ()
         ((_ a b)
            (syntax
               (let ((tmp (! a)))
                  (:= a (! b))
                  (:= b tmp)
                  ))
            ))
         )
   )

;; define-macroの例
(define-macro swap-dm (lambda (a b)
      (let (
         (tmp (gensym))
         )
         `(let (
            (,tmp (! ,a))
            )
            (:= ,a (! ,b))
            (:= ,b ,tmp)
            )
         )))

;; Explicit Renamingの例
(define-syntax swap-er (er-macro-transformer
   (lambda (form rename compare)
      (let (
         (a (cadr form))
         (b (caddr form)))
         `(let (
            (,(rename 'tmp) (! ,a))
            )
            (:= ,a (! ,b))
            (:= ,b ,(rename 'tmp))
            )
         ))))

(let
	((x (ref 5)) (y (ref 3)))
	(swap-sr x y)
	;; (swap-sc x y)
	;; (swap-dm x y)
	;; (swap-er x y)
	)