4.10 定義 ¶

Special Form: define variable expression ¶

Special Form: define (variable . formals) body … ¶

Special Form: define variable ¶

[R7RS+ base] この形式はトップレベル (ローカルな束縛が無い状態) とローカルスコープがある状態とで 別の意味を持ちます。

トップレベルでは、この形式は変数variableに対するグローバルな束縛を定義します。 最初の形式では、expressionが評価され、その結果が変数variableの値となります。

(define x (+ 1 2))
x ⇒ 3
(define y (lambda (a) (* a 2)))
(y 8) ⇒ 16

variableが同じモジュールの中で既に束縛されていた場合、 二度目以降の定義は代入と同じです。

(define x 3)
(define (value-of-x) x)

(value-of-x) ⇒ 3

(define x 4)

(value-of-x) ⇒ 4

variableが現在のモジュールでは束縛されていないけれど、 他のモジュールからインポートされた束縛があった場合、話はちょっとややこしく (おもしろく)なります。詳しくは Scheme多世界へようこそで論じます。

2番目の形式は手続きを定義するための構文的な修飾で、以下の形式と同じです。

(define (name . args) body ...)
  ≡ (define name (lambda args body ...))

3番目の形式は(define variable (undefined))の略記です。 これはR6RSで導入されました(ただし、R7RSには入っていません)。 初期値が重要でないことを示したい場合に使えます。

このフォームがローカルスコープの中に現われた場合、ローカル変数の束縛となります。 (内部define)。

内部defineはlambdaやその他のローカル束縛を作る構文の、本体部分の先頭に置けます。 これらは、下に示すようにletrec*フォームと等価です。

(lambda (a b)
  (define (cube x) (* x x x))
  (define (square x) (* x x))
  (+ (cube a) (square b)))

 ≡

(lambda (a b)
  (letrec* ([cube (lambda (x) (* x x x))]
            [square (lambda (x) (* x x))])
    (+ (cube a) (square b))))

内部defineは実質的にletrec*フォームなので、 相互再帰する内部関数を書けますし、また同じスコープで先に導入された定義を 使って定義される値を計算することもできます。しかし、 内部defineフォームの後に定義される値を使うことはできません。 そういったプログラムを書いてもGaucheは直ちにエラーを報告しませんが、 あとでおかしな結果が出ることがあります。

(lambda (a)
  (define x (* a 2))
  (define y (+ x 1))  ; yの値を計算するのにxを使ってよい
  (* a y))

(lambda (a)
  ;; odd?の中からeven?を参照するのはok。odd?が定義される時点ではeven?
  ;; の値は使われず、odd?が呼ばれた時に初めて使われるから。
  (define (odd? x) (or (= x 1) (not (even? (- x 1)))))
  (define (even? x) (or (= x 0) (not (odd? (- x 1)))))
  (odd? a))

(lambda (a)
  ;; これはダメ。yを定義する時点でxの値を使わないとならないので。
  ;; ただし、すぐにはエラーとならないかもしれない。
  (define y (+ x 1))
  (define x (* a 2))
  (* a y))

束縛を作るフォームのボディー内で、内部defineは同じレベルにあるすべての式より前に 現れなければなりません。例えば次のコードは、defineフォームの 前に式(print a)があるので不正です。

(lambda (a)
  (print a)
  (define (cube x) (* x x x))  ; error!
  (cube a))

束縛を作るフォームのボディー中に、式を置かず内部defineだけを書いておくのも不正ですが、 Gaucheは特にエラーを出しません。

beginは新しいスコープを作らないことに注意してください(式をまとめる参照)。 beginの中に現われるdefineは、あたかもbeginとそれを囲む 括弧が無いかのように振舞います。すなわち、以下の2つの形式は等価です。

(let ((x 0))
  (begin
    (define (foo y) (+ x y)))
  (foo 3))
 ≡
(let ((x 0))
  (define (foo y) (+ x y))
  (foo 3))

Macro: define-values (var …) expr ¶

Macro: define-values (var var1 … . var2) expr ¶

Macro: define-values var expr ¶

[R7RS base][SRFI-244] まずexprが評価され、続いて各値がvarに順に束縛されます。 最初の形式では、exprがvarと同じ数だけの値を生成しなければ エラーとなります。

(define-values (lo hi) (min&max 3 -1 15 2))

lo ⇒ -1
hi ⇒ 15

二番目の形式では、exprはvar var1 …に対応する数か それ以上の値を生成しなければなりません。余った値はリストになってvar2に 束縛されます。

(define-values (a b . c) (values 1 2 3 4))

a ⇒ 1
b ⇒ 2
c ⇒ (3 4)

最後の形式では、exprの生成する全ての値がリストにまとめられ、varに 束縛されます。

(define-values qr (quotient&remainder 23 5))

qr ⇒ (4 3)

define-valuesはdefineが許されるところならどこでも使えます。 つまり、内部defineにdefine-valuesを混ぜて使えるということです。

(define (foo . args)
  (define-values (lo hi) (apply min&max args))
  (define len (length args))
  (list len lo hi))

(foo 1 4 9 3 0 7)
 ⇒ (6 0 9)

Special Form: define-constant variable expression ¶

Special Form: define-constant (variable . formals) body … ¶

このフォームはトップレベルでしか使えません。

トップレベルのdefineと同様に、トップレベルでvariableを expressionの値に束縛しますが、さらに次の情報をコンパイラに伝えます： (1)その束縛は変わらない (2)expressionの値はコンパイル時に計算したものと変わらない。 コンパイラはvariableが参照されている箇所を コンパイル時に計算したexpressionの値で置き換えて構わないと考えて最適化を行います。

variableの値をset!で変更しようとするとエラーとなります。 variableを再定義することは許されますが、警告が表示されます。

下のdefine-inlineとの違いは、expressionの値がコンパイル時に 計算され、リテラルとして扱われることです。 例えばxを次のとおり定義したとします:

(define-constant x (vector 1 2 3))

すると、コード(list x)は(list '#(1 2 3))と同じコードにコンパイルされます。

この違いは特にAOT (ahead of time)コンパイルをする場合に重要です。

“内部define-constant” にあたるものはありません。宣言が無くても コンパイラはどのローカル束縛が変更されないかを検出して最適化できるからです。

Special Form: define-inline variable expression ¶

Special Form: define-inline (variable . formals) body … ¶

2番目の形式は(define-inline variable (lambda formals body …))の略記です。

このフォームが内部defineの位置に現れた場合は、内部defineと全く同じです。

このフォームがトップレベルに現れた場合、それはインライン可能な束縛をつくります。 インライン可能な束縛とは、コンパイラに対してその束縛が変化しないことを約束するものです。 ただしdefine-constantで導入される定数束縛と違って、expressionの値が コンパイル時に計算可能とは限りません。 従って、コンパイラはdefine-constantで定義される束縛でやっている、 variableの参照を無条件でexpressionのコンパイル時値に置き換えることは できません。

しかし、コンパイラがexpressionの値が手続きになることを決定できれば、 その手続きが呼び出される箇所に手続きの中身をインライン展開することができます。

下の例では、dot3の本体がdot3を呼び出している箇所にインライン展開されています。 さらに、dot3の呼び出しの第2引数が定数ベクタのため、それに対するvector-refが コンパイル時に計算されていることがわかります (CONST -1.0など)。

gosh> (define-inline (dot3 a b)
        (+ (* (vector-ref a 0) (vector-ref b 0))
           (* (vector-ref a 1) (vector-ref b 1))
           (* (vector-ref a 2) (vector-ref b 2))))
dot3
gosh> (disasm (^[] (dot3 x '#(-1.0 -2.0 -3.0))))
CLOSURE #<closure (#f)>
=== main_code (name=#f, code=0x28524e0, size=26, const=4 stack=6):
signatureInfo: ((#f))
     0 GREF-PUSH #<identifier user#x.20d38e0>; x
     2 LOCAL-ENV(1)             ; (dot3 x (quote #(-1.0 -2.0 -3.0)))
     3 LREF0                    ; a
     4 VEC-REFI(0)              ; (vector-ref a 0)
     5 PUSH
     6 CONST -1.0
     8 NUMMUL2                  ; (* (vector-ref a 0) (vector-ref b 0))
     9 PUSH
    10 LREF0                    ; a
    11 VEC-REFI(1)              ; (vector-ref a 1)
    12 PUSH
    13 CONST -2.0
    15 NUMMUL2                  ; (* (vector-ref a 1) (vector-ref b 1))
    16 NUMADD2                  ; (+ (* (vector-ref a 0) (vector-ref b 0))
    17 PUSH
    18 LREF0                    ; a
    19 VEC-REFI(2)              ; (vector-ref a 2)
    20 PUSH
    21 CONST -3.0
    23 NUMMUL2                  ; (* (vector-ref a 2) (vector-ref b 2))
    24 NUMADD2                  ; (+ (* (vector-ref a 0) (vector-ref b 0))
    25 RET

最も極端なケースとして、両方の引数がコンパイル時定数であれば、 dot3の呼び出し自体がコンパイル時に計算されます。

gosh> (disasm (^[] (dot3 '#(1 2 3) '#(4 5 6))))
CLOSURE #<closure (#f)>
=== main_code (name=#f, code=0x2a2b8e0, size=2, const=0 stack=0):
signatureInfo: ((#f))
     0 CONSTI(32)
     1 RET

インライン展開と同様の効果はdot3をマクロにすることでも得られますが、 define-inlineを使っておくとdot3を通常の手続きとしても使うことができます。

(map dot3 list-of-vectors1 list-of-vectors2)

dot3がマクロだと、上のように関数引数としてmapに渡すことはできないでしょう。

インライン展開パスはソースの上から下へと進みます。インライン展開されるためには、 呼び出される前にそれが定義されていなければなりません。

インライン可能な束縛が再定義されるとGaucheは警告を出します。 その再定義は既にインライン展開された呼び出し箇所には影響を及ぼさないからです。 なのでこれは注意して使わなければなりません。モジュール内だけで使うか、 あるいは将来に渡って変わらなさそうな手続きに使うか。 インライン展開は性能に重大な影響を与える場所では効果的ですが、 滅多に使われない手続きをインライン可能に定義する意味はありません。

Special Form: define-type variable type-expression ¶

This form can be used to name a constructed type. variable must be an identifier, and type-expression is an expression that yields a type. See 型の式と型コンストラクタ, for the details of type expressions.

(define-type <int-list> (<List> <int>))

In Gauche, types are first class values that can be constructed at runtime. In order to take advantage of type information, however, it is critical that they are available at compile time. This form marks the binding of variable “inlinable”, telling the compiler that it can assume the binding won’t change.

The distinction is important when you try to use variable as an argument for other type expressions. Type expressions are computed at compile time, so mutable bindings can’t be used in it.

gosh> (define <int-list> (<List> <int>))
<int-list>
gosh> (<List> <int-list>)
*** ERROR: Can't use non-inlinable global variable `#<identifier user#<int-list>.266ebc20>'
in type constructor expression: (<List> <int-list>)

Using define-type avoid this error.

Special Form: define-in-module module variable expression ¶

Special Form: define-in-module module (variable . formals) body … ¶

この形式はトップレベルでしか使えません。 variableのグローバルな束縛をmodule中に作成します。 moduleはモジュール名を表すシンボルか、モジュールオブジェクトで なければなりません。moduleがシンボルの場合、その名前を持つ モジュールが既に存在している必要があります。

expressionは現在のモジュール中で評価されます。

2番目の形式は次の形式の構文的修飾です。

(define-in-module module variable (lambda formals body ...))

註: シンボルが現在のモジュール中で定義されているか(グローバルな束縛を持つか) を調べるには、module-binds?が使えます (モジュールイントロスペクション参照)。

(define (odd? n)  (if (zero? x) #f (even? (- n 1))))
(define (even? n) (if (zero? x) #t (odd? (- n 1))))

(let ((even? error))
  (define (odd? n)  (if (zero? x) #f (even? (- n 1))))
  (define (even? n) (if (zero? x) #t (odd? (- n 1))))
  ...)

;; Invalid in RnRS, n >= 6
(import (scheme base) (scheme write))
(define orig-error error)
(define (error . args)
  (write args) (newline)
  (apply orig-error args))

(import (except (scheme base) error)
        (rename (scheme base) (error r7rs:error))
        (scheme write))
(define (error . args)
  (write args) (newline)
  (apply r7rs:error args))

*** ERROR: uninitialized variable: error