12.90.1 Stream primitives

Function: stream? obj ¶

[R7RS stream] {util.stream} objがutil.streamの手続きによって作成されたストリームであ る場合にかぎり#tを返します。

Variable: stream-null ¶

[R7RS stream] {util.stream} NULLストリームのシングルトンインスタンス。

Macro: stream-cons object stream ¶

[R7RS stream] {util.stream} ストリームの基本構成子。objectをstreamの先頭に追加し、新し いストリームを返します。

Function: stream-null? obj ¶

[R7RS stream] {util.stream} objがNULLストリームの場合にのみ#tを返します。

Function: stream-pair? obj ¶

[R7RS stream] {util.stream} objがNULLストリームではないストリームのときにのみ#tを返します。

Function: stream-car s ¶

[R7RS stream] {util.stream} ストリームsの最初の要素を返します。

Function: stream-cdr s ¶

[R7RS stream] {util.stream} ストリームsの最初の要素を除いた残りの要素をストリームとして 返します。

Macro: stream-delay expr ¶

[SRFI-40]{util.stream} exprの遅延形式であるストリームを返します。

原則として、ストリームを生成する関数はすべからく結果を stream-delayでラップすべきです。 (以下に述べるstream-lambda, stream-let, stream-defineを 使う手もあります)。

Macro: stream-lambda formals body body2 … ¶

[R7RS stream] {util.stream} ストリームを返す関数を作る簡易マクロです。 (stream-lambda formals body body2 …)は (lambda formals (stream-delay body body2 …))と同じです。

---

12.90.2 Stream constructors

Function: stream obj … ¶

[SRFI-40]{util.stream} 要素がobj …であるような新しいストリームを返します。

註：これはSRFI-41 (scheme.stream)のstreamとは異なります。 SRFI-41の方はマクロで、引数の評価が遅延されます。SRFI-41版はこのモジュールでは stream+と言う名前で提供されます。

(stream 1 2 3))     ⇒ a stream that contains (1 2 3)
(stream 1 (/ 1 0))) ⇒ error

Macro: stream+ expr … ¶

{util.stream} 要素がexpr …の結果であるような新たなストリームを作って返します。

これはSRFI-41(scheme.stream)のstreamと同じです。 各exprはアクセスされるまで評価されません。

(define s (stream+ 1 (/ 1 0)))  ;; doesn't yield an error

(stream-car s)  ⇒ 1

(stream-cadr s) ⇒ error

Function: stream-unfold f p g seed ¶

[R7RS stream] {util.stream} 次の手順で生成される要素をもつ新たなストリームを作成して返します。

• 「続行」述語pが現在のシード値を引数として呼ばれます。 もし#fが返されたら、ストリームはそこで終了です。
• そうでなければ、sを現在のシード値として、(f s)をストリームの 現在の要素とし、(g s)を次のシード値とします。 seedはシード値の初期値を与えます。

註：残念なことに、この手続きは他の *-unfold 系手続きと異なる順序で 引数を取ります。他の手続きはp f g (述語、値生成、シード生成) の順です。 さらに、他の手続きでは述語は停止する時に真を返します。

(stream->list
 (stream-unfold integer->char (cut < <> 58) (cut + 1 <>) 48))
 ⇒ (#\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9)

Function: stream-unfoldn f seed n ¶

[SRFI-40]{util.stream} 互いに関連する n 本のストリームを生成します。それぞれの内容は fおよびseedを使って生成します。

fは現在のシード値とともに呼ばれ、n+1個の値 を返します。

(f seed)
  => seed result_0 result_1 … result_n-1

最初の値は次のシード値になります。Result_kは以下の形式のどれかで なければなりません。

(val)

valはk-番目のストリームの次のcar部になります。

#f

k-番目のストリームの新しい情報はありません。

()

k-番目のストリームの最後に到達しました。

以下の例では2つのストリームが作られます。最初のものは奇数の無限ストリー ムで、2つめのものは偶数の無限ストリームです。

gosh> (define-values (s0 s1)
        (stream-unfoldn (lambda (i)
                          (values (+ i 2)          ;; next seed
                                  (list i)         ;; for the first stream
                                  (list (+ i 1)))) ;; for the second stream
                        0 2))
#<undef>
gosh> (stream->list (stream-take s0 10))
(0 2 4 6 8 10 12 14 16 18)
gosh> (stream->list (stream-take s1 10))
(1 3 5 7 9 11 13 15 17 19)

Function: stream-unfolds f seed ¶

[R7RS stream] {util.stream} stream-unfoldnと似ていますが、結果のストリームの数は fの戻り値の数により決定されます。詳しくは 上のstream-unfoldnの説明を参照してください。

Function: stream-constant obj … ¶

[R7RS stream] {util.stream} obj …を繰り返す無限ストリームを返します。

(stream->list 10 (stream-constant 1 2))
  ⇒ (1 2 1 2 1 2 1 2 1 2)

Function: make-stream n :optional init ¶

{util.stream} n個のinitを要素とする新しいストリームを生成します。 initが省略された場合#fが使われます。nを負の値にする と無限ストリームが生成されます。

Function: stream-tabulate n init-proc ¶

{util.stream} n個の要素をもつ新しいストリームを生成します。k-番目の要素 は init-proc を k に適用して得られます。nを負の値にする と無限ストリームが生成されます。

Function: stream-iota :optional count start step ¶

{util.stream} startからはじまり、stepずつ要素が増加する数値のストリーム を生成します。ストリームの長さは非負の実数countを越えない最大の整数値です。 count, start, stepのデフォルト値はそれぞれ +inf.0, 0 および 1です。

startとstepが正確数で、countが正確数か無限大の場合、 正確数のストリームが作られます。そうでなければ非正確数のストリームになります。

Function: stream-range start :optional end step ¶

[R7RS stream] {util.stream} startから始まりstepおきにendの手前まで続く実数のストリームを 作って返します。endが省略された場合は正の無限大が使われます。 stepが省略された場合、startがendより小さければ1が、 大きければ-1が使われます。

startとstepが正確数で、endが正確数か無限大の場合は、 正確数のシーケンスが、そうでない場合は非正確数のシーケンスが生成されます。

R7RSのscheme.streamでは、end引数は必須です。

(stream->list (stream-range 0 10))
 ⇒ (0 1 2 3 4 5 6 7 8 9)

Function: stream-from start :optional step ¶

[R7RS stream] {util.stream} もうひとつの数値シーケンス生成手続きです。i番目の項が (+ start (* i step))であるような無限シーケンスを返します。 stepが省略されたら1が使われます。 startとstepが正確数なら、正確数のシーケンスが、 そうでなければ非正確数のシーケンスが返されます。

Function: stream-iterate f seed ¶

[R7RS stream] {util.stream} seedを初期値とし、ひとつ前の要素sから次の要素を(f s)で 計算するような無限長のストリームを返します。

(stream->list 5 (stream-iterate (cut cons 'x <>) '()))
  ⇒ (() (x) (x x) (x x x) (x x x x))

gauche.lazyのliterateも参照 (gauche.lazy - 遅延シーケンスユーティリティ).

Function: stream-xcons a b ¶

{util.stream} (stream-cons b a)のこと。利便性のためだけにある。

Function: stream-cons* elt … stream ¶

{util.stream} streamの前にelt …を連結した新しいストリームを生成し ます。

Function: list->stream list ¶

[R7RS stream] {util.stream} listの要素を要素とする新たなストリームを作って返します。

Function: string->stream string :optional tail-stream ¶

{util.stream} 文字列を文字のストリームに変換します。tail-streamが与えられた場合は、 文字ストリームの後にそれが付け加えられます。

(stream->list (string->stream "abc" (list->stream ’(1 2 3)))) ⇒ (#\a #\b #\c 1 2 3)

Function: stream-format fmt arg … ¶

{util.stream} string->streamを(format fmt arg …)に適用した結果の ストリームを返します。

Function: port->stream :optional iport reader closer ¶

[R7RS stream] {util.stream} iportからreaderを使って読み出されるデータを要素とする新たなストリームを 作って返します。iportのデフォルトは現在の入力ポート、 readerのデフォルトはread-charです。

readerがEOFを返したらストリームの終端となります (EOF自体は ストリームには含まれません)。 EOFに達してもポートはクローズされません。

もしcloser引数が与えられたら、それがiportを引数として EOFが読まれた直後に呼ばれます。そこでポートをクローズするこはできます。

readerとcloser引数はR7RSのscheme.streamでは 定義されない、Gaucheの拡張です。

Function: generator->stream gen ¶

{util.stream} ジェネレータgenが生成する値の列からなる遅延ストリームを作って返します。 ジェネレータは引数を取らない手続きで、呼ばれる度に値を返し、EOFを返すことで 終端を示すものです(EOFはストリームには含まれません)。 詳しくはgauche.generator - ジェネレータを参照してください。

似た手続きに、ジェネレータから遅延シーケンスを得るgenerator->lseqも あります(遅延シーケンス参照)。

Function: iterator->stream iter ¶

{util.stream} イテレータiterから遅延シーケンスを作る手続きです。

iterは二つの引数nextとendを取る手続きです。 nextは一つの引数を取る手続き、endは引数を取らない手続きです。 iter手続きは、その中で何らかの値の集合に対して順にnext手続きを呼び、 最後にend手続きを呼びます。次はわざとらしい例です:

(stream->list
 (iterator->stream
  (lambda (next end) (for-each next '(1 2 3 4 5)) (end))))
 ⇒ (1 2 3 4 5)

内部的に、iterator->streamはいわゆる「イテレータの反転」テクニックを 使っていて、iterは必要なだけしかイテレーションを行いません。なので iterは無限の要素を扱うこともできます。 例えば次の例では、iterは増加する整数に対してnextを無限に呼び出す ようになっていますが、stream-takeによって最初の10要素しか計算されません。

(stream->list
 (stream-take
  (iterator->stream
   (lambda (next end)
     (let loop ((n 0)) (next n) (loop (+ n 1)))))
  10))
 ⇒ (0 1 2 3 4 5 6 7 8 9)

Macro: stream-of elt-expr clause … ¶

[R7RS stream] {util.stream} ストリーム内包表記。各要素がelt-exprで計算されるストリームを返します。 clauseはelt-exprのスコープを作り、繰り返しを制御します。 各clauseは以下の形のいずれかです：

(x in stream-expr)

stream-exprが返すストリームの各要素を、xに束縛して繰り返します。 変数xのスコープは後続のclauseおよびelt-exprです。

(x is expr)

変数xに値exprの結果を束縛します。xのスコープは 後続のclauseおよびelt-exprです。

expr

exprが#fに評価されたらこの回は値を生成せずに打ちきられ、 次の繰り返しに進みます。

次の内包表記はピタゴラス数の無限シーケンスを生成します：

(define pythagorean-triples
  (stream-of (list a b c)
    (c in (stream-from 3))
    (b in (stream-range 2 c))
    (a in (stream-range 1 b))
    (= (square c) (+ (square b) (square a)))))

(stream->list 5 pythagorean-triples)
  ⇒ ((3 4 5) (6 8 10) (5 12 13) (9 12 15) (8 15 17))

---

12.90.3 Stream binding

Macro: define-stream (name . formals) body body2 … ¶

[R7RS stream] {util.stream} ストリームを作って返す関数を手軽に定義するマクロです。 次のフォームと同じです:

(define (name . formals)
  (stream-delay
    (let () body body2 …)))

Macro: stream-let loop-var ((var init) …) body body2 … ¶

[R7RS stream] {util.stream} lazyなnamed-letによるループを書くときに便利なマクロです。次のフォームと同じです:

(let loop-var ((var init) …)
  (stream-delay
    (let () body body2 …)))

Macro: stream-match stream-expr clause … ¶

[R7RS stream] {util.stream} このマクロは簡単なパターンマッチングを使ってストリームの要素にアクセスします。 stream-exprはストリームを返す式でなければなりません。 各clauseは(pattern expr)か (pattern fender expr)という形です。

入力ストリームは各patternに順マッチするかどうかテストされます。 patternには以下の形のいずれかです:

()

空のストリームとマッチします。

(p0 p1 …)

パターン内の要素の数と入力ストリームの要素数が一致した時にマッチします。

(p0 p1 … . pRest)

入力ストリームの要素数が、pRestを除いたパターン内の要素の数以上であれば マッチします。pRestにはストリームの残りがマッチします。

pRest

入力ストリーム全体とマッチします。

パターンの各要素は識別子かリテラルのアンダースコア_です。 アンダースコア以外の識別子の場合は、それらが対応する入力ストリームの要素に 束縛された環境でfenderとexprが評価されます。

もしfenderがあれば、まずそれが評価され、#fであったらそのclauseの マッチは失敗となり、次のclauseが試されます。

そうでなければexprが評価され、その結果がstream-matchの結果となります。

入力ストリームの要素はマッチに必要なだけ取り出されます。

次の例は、ストリーム中の真の値の数を数えています:

(define (num-trues strm)
  (stream-match strm
    (() 0)
    ((head . tail) head (+ 1 (num-trues tail)))
    ((_ . tail) (num-trues tail))))

(num-trues (stream #f #f #t #f #t #f #t #t))
  ⇒ 4

---

12.90.4 Stream consumers

これらの手続きはストリームを取り、その要素を消費し尽します。

Function: stream-for-each func . streams ¶

[R7RS stream] {util.stream} funcをstreamsの各要素に適用します。 streamsが終端に達したところで停止します。

Function: stream-fold f seed stream ¶

[R7RS stream] {util.stream} fを現在のシード値とstreamの要素に適用し、その結果を次のシード値として streamが終端に達するまで繰り返します。最初のシード値はseed引数で与えられます。 最後のシード値が返されます。

註: fの引数順は、他の*-fold系関数のそれと異なることに注意してください。 例えばfold (リストをたどる手続き参照) では最初に要素、次にシード値が 渡されます。

(stream-fold - 0 (stream 1 2 3 4 5))
  ⇒ -15

---

12.90.5 Stream operations

Function: stream-append stream … ¶

[R7RS stream] {util.stream} 与えられたstreamを全部つないだ新たなストリームを返します。

Function: stream-concat streams ¶

Function: stream-concatenate streams ¶

[R7RS stream] {util.stream} R7RS scheme.streamはstream-concatを定義しました。 Gaucheにはstream-concatenateがあったので互換性のためにそちらも残しています。 どちらも同じです。

streamsはストリームのストリームです。各ストリームを連結したストリームを作って 返します。stream-appendと違い、streamsは無限個のストリームを生成 することができます。

Function: stream-map func stream stream2 … ¶

[R7RS stream] {util.stream} streamsの各要素にfuncを適用した値を要素とする新しいストリー ムを返します。

Function: stream-scan func seed stream ¶

[R7RS stream] {util.stream} seed、 (func seed e0)、 (func (func seed e0) e1) … で構成されるストリームを返します。ここで e0、e1 …は入力ストリームstreamの要素です。 streamが有限なら、その要素よりひとつ多い要素が出力ストリームには含まれます。

(stream->list
  (stream-scan xcons '() (stream 1 2 3 4 5)))
 ⇒ (() (1) (2 1) (3 2 1) (4 3 2 1) (5 4 3 2 1))

Function: stream-zip stream … ¶

[R7RS stream] {util.stream} 入力ストリームの対応する要素のリストを要素とするストリームを作って返します。 入力ストリームのいずれかが終端に達した時に出力ストリームも終わります。

(stream->list
 (stream-zip (stream 1 2 3) (stream 'a 'b 'c 'd)))
 ⇒ ((1 a) (2 b) (3 c))

Function: stream-filter pred stream ¶

[R7RS stream] {util.stream} predをパスする要素のみからなる新しいストリームを返します。 この手続きは直ちに返ります。streamは無限ストリームであっても構いません。

Function: stream-remove pred stream ¶

{util.stream} 述語predを満たさない要素のみからなる新しいストリームを返します。 (stream-filter (complement pred) stream)と同じです。

Function: stream-partition pred stream ¶

{util.stream} 二つのストリームを返します。最初のストリームはstreamの要素のうち 述語predを満たすもの、次のストリームはpredを満たさないもので構成されます。

Function: stream->list stream ¶

Function: stream->list n stream ¶

[R7RS stream] {util.stream} ストリームをリストに変換します。最初の形式では、streamの全ての要素が 取り出されます (従ってstreamが無限ストリームであればこの関数は永遠に戻りません)。 二番めの形式では最大でn要素までがストリームから取り出されそのリストが返されます。 nは非負の正確な整数でなければなりません。

註:通常のSchemeの慣例では、省略可能なnはstreamの後に来ますが、 この関数はそうでないことに注意。

Function: stream->string stream ¶

{util.stream} ストリームを文字列に変換します。 streamの全ての要素は文字でなければなりません。 そうでない場合はエラーが投げられます。

Function: stream-lines stream ¶

{util.stream} streamを、文字#\nが要素である箇所で分割し、 分割されたストリームのストリームを返します。#\n自体は結果に含まれません。

(stream->list
 (stream-map stream->string
             (stream-lines (string->stream "abc\ndef\nghi"))))
 ⇒ ("abc" "def" "ghi")

Function: stream= elt= stream … ¶

{util.stream} 引数のストリームの全ての対応する要素がそれぞれ、2引数を取るelt=で比較して等しい場合に #tを、そうでなければ#fを返します。 全てのstreamが無限である場合、この手続きは終了しません。

Function: stream-prefix= stream prefix :optional elt= ¶

{util.stream} streamの最初の方の要素をリストprefixと比較します。各要素は elt=で比較されます。prefixと全てマッチしたら#tを、 そうでなければ#fを返します。最大でもprefixの要素分だけstreamから 要素が取り出されます。

Function: stream-caar s ¶

Function: stream-cadr s ¶

…

Function: stream-cdddar s ¶

Function: stream-cddddr s ¶

{util.stream} (stream-caar s) = (stream-car (stream-car s)) etc.

Function: stream-ref stream pos ¶

[R7RS stream] {util.stream} ストリームのpos番目の要素を返します。posは非負の正確な整数でなければなりません。

Function: stream-first s ¶

Function: stream-second s ¶

Function: stream-third s ¶

Function: stream-fourth s ¶

Function: stream-fifth s ¶

Function: stream-sixth s ¶

Function: stream-seventh s ¶

Function: stream-eighth s ¶

Function: stream-ninth s ¶

Function: stream-tenth s ¶

{util.stream} (stream-first s) = (stream-ref s 0) etc.

Function: stream-take stream count ¶

Function: stream-take-safe stream count ¶

{util.stream} 与えられたストリームのうち、最初のcount要素だけを含むストリームを返します。 与えられたストリームがcount要素より少ない要素しか持っていなかった場合、 stream-takeが返すストリームは、元のストリームの終端を越えてアクセスしようとした時に エラーを投げます。一方、stream-take-safeが返すストリームは、 元のストリームがcount要素より少なかった場合に、その要素までを返すストリームを 返します。

(stream->list (stream-take (stream-iota -1) 10))
 ⇒ (0 1 2 3 4 5 6 7 8 9)

(stream-take (stream 1 2) 5)
 ⇒ stream

(stream->list (stream-take (stream 1 2) 5))
 ⇒ error

(stream->list (stream-take-safe (stream 1 2) 5))
 ⇒ (1 2)

註: SRFI-41 (scheme.stream) もstream-takeを提供していますが、 引数の順序が逆になっています。また、SRFI-41のstream-takeは 元のストリームがcount以下の要素しか持っていなかった場合でもエラーとしません。

Function: stream-drop stream count ¶

Function: stream-drop-safe stream count ¶

{util.stream} 与えられたストリームのうち、最初のcount要素を取り除いたストリームを返します。 与えられたストリームがcount要素より少ない要素しか持っていなかった場合、 stream-dropは、アクセスされるとエラーを投げるストリームを返します。 一方、stream-drop-safeは空のストリームを返します。

註: SRFI-41 (scheme.stream) もstream-dropを提供していますが、 引数の順序が逆になっています。また、SRFI-41のstream-dropは 元のストリームがcount以下の要素しか持っていなかった場合にエラーとせず 空のストリームを返します。

Function: stream-intersperse stream element ¶

{util.stream} elementがstreamの連続する2要素の間に挿入されているような新たなストリームを 返します。

(stream->list (stream-intersperse (stream 1 2 3) 0))
 ⇒ (1 0 2 0 3)

Function: stream-split stream pred ¶

{util.stream} streamを、predを満たす要素で分割し、 分割されたストリームのストリームを返します。 分割に使われた要素は結果に含まれません。

(stream->list
 (stream-map stream->list
             (stream-split (stream 1 3 2 5 7 9 6 8 1) even?))))
 ⇒ ((1 3) (5 7 9) () (1))

Function: stream-last stream ¶

{util.stream} streamの最後の要素を返します。streamが空ならエラーが投げられます。 streamが無限ストリームの場合、この手続きは戻ってきません。

Function: stream-last-n stream count ¶

{util.stream} streamの最後のcount要素を含むストリームを返します。 countは非負の正確な整数でなければなりません。 もしstreamがcount要素より短ければ、streamがそのまま返されます。 streamが無限ストリームならこの手続きは戻ってきません。

Function: stream-butlast stream ¶

{util.stream} streamの最後の要素を除く内容を持つストリームを返します。 streamが空の場合は空のストリームが返されます。 streamは無限ストリームであっても構いません。

Function: stream-butlast-n stream count ¶

{util.stream} streamの最後のcount要素を除いた内容を持つストリームを作って返します。 countは非負の正確な整数でなければなりません。 streamの要素数がcountより少なければ、空のストリームが返されます。 streamは無限ストリームであっても構いません。

Function: stream-length stream ¶

[R7RS stream] {util.stream} streamの要素数を返します。 streamが無限ストリームの時は戻ってきません。

Function: stream-length>= stream n ¶

Function: stream-length= stream n ¶

{util.stream} streamの要素数が、それぞれn以上か、nと等しければ#tを、 そうでなければ#fを返します。 これらの手続きはstreamの最初のn要素のみを現実化します。

Function: stream-reverse stream :optional tail-stream ¶

[R7RS stream] {util.stream} streamの要素を逆順にしたストリームを返します。tail-streamが与えられた 場合、逆順にしたストリームの後にそれ付け加えられます。

省略可能なtail-streamはGaucheの拡張です。詳しくは reverseの説明を参照してください (他のリスト手続き)。

Function: stream-count pred stream … ¶

{util.stream} predは、まずstream …それぞれの最初の要素を引数として呼び出され、 次にそれぞれの2番目の要素を引数として呼ばれ、以降いずれかのstreamが尽きるまで 呼ばれます。そして、そのうちpredが真の値を返した数が戻り値となります。 少なくともstreamのうちのひとつは有限でなければなりません。

(stream-count < (stream 1 2 3 4 5) (stream 2 2 2 10 10))
 ⇒ 3

Function: stream-find pred stream ¶

{util.stream} predをstreamの要素に順に適用し、predが真の値を返したら 直ちにその要因となった要素を返します。streamの残りは現実化されません。

streamの要素の中にpredを満たすものが無かった場合は#fが返ります。

Function: stream-find-tail pred stream ¶

{util.stream} predをstreamの要素に順に適用し、predが真の値を返したら その要素およびそれ以降の要素からなるストリームを返します。 streamの残りは現実化されません。

streamの要素の中にpredを満たすものが無かった場合は空のストリームが返ります。

Function: stream-take-while pred stream ¶

Function: stream-drop-while pred stream ¶

[R7RS stream] {util.stream} それぞれ、streamの最初から連続する、predを満たす要素だけからなる ストリームと、それらの要素を除いたストリームを返します。

(stream->list (stream-take-while even? (stream 2 4 6 1 4 2)))
 ⇒ (2 4 6)
(stream->list (stream-drop-while even? (stream 2 4 6 1 4 2)))
 ⇒ (1 4 2)

Function: stream-span pred stream ¶

Function: stream-break pred stream ¶

{util.stream} ふたつのストリームを返します。最初のストリームは、streamの最初から連続する、 predを満たす/満たさない要素からなるストリームで、 二番目のストリームは残りのストリームです。

(map stream->list
     (values->list (stream-span even? (stream 2 4 6 1 4 2))))
 ⇒ ((2 4 6) (1 4 2))
(map stream->list
     (values->list (stream-break even? (stream 1 9 6 1 4 2))))
 ⇒ ((1 9) (6 1 4 2))

Function: stream-any pred stream … ¶

Function: stream-every pred stream … ¶

{util.stream} predは、まずstream …それぞれの最初の要素を引数として、 次にそれぞれの2番目の要素を引数として、と順次呼ばれます。 stream-anyはpredが真の値を返したらただちに評価を打ち切り、 predが返した値をそのまま返します。 stream-everyはpredが#fを返したらただちに 評価を打ち切り、#fを返します。

streamのいずれかが終端に達するまでにpredが一度も真の値を返さなければ、 stream-anyは#fを返します。 streamのいずれかが終端に達するまでにpredが一度も偽の値を返さなければ、 stream-everyは最後のpredの結果を返します。

(stream-any (^[x y] (and (> x y) (list x y)))
            (stream 1 2 3 4 5)
            (stream 3 3 3 3 3))
 ⇒ (4 3)

(stream-every (^[x y] (and (> x y) (list x y)))
              (stream 6 6 6 6 6)
              (stream 1 2 3 4 5))
 ⇒ (6 5)

Function: stream-index pred stream … ¶

{util.stream} predは、まずstream …それぞれの最初の要素を引数として、 次にそれぞれの2番目の要素を引数として、と順次呼ばれます。 predが真の値を返したらstream-indexは評価を打ち切り、 そのインデックスを返します。 streamのいずれかが終端に達するまでにpredが一度も真の値を返さなければ、 #fが返されます。

(stream-index odd? (stream 2 4 6 7 8))
 ⇒ 3

Function: stream-member obj stream :optional elt= ¶

Function: stream-memq obj stream ¶

Function: stream-memv obj stream ¶

{util.stream} member, memq, memvのストリーム版です (他のリスト手続き参照)。 objと等しい要素をstreamから探し、見つかったその要素を含む 残りのストリームを返します。要素がみつからなければ#fを返します。

これらの手続きの違いは等価判定述語です。stream-memberは与えられたelt=か、 省略された場合はequal?を使います。 stream-memqはeq?を、stream-memvはeqv?を使います。

Function: stream-delete obj stream :optional elt= ¶

{util.stream} (stream-remove (cut elt= obj <>) stream)と等価です。 すなわち、入力ストリームからobjと等しい要素を除いた要素を持つ ストリームを返します。

Function: stream-delete-duplicates stream :optional elt= ¶

{util.stream} 入力ストリームのうち、連続する等しい要素があればその最初以外のものを除いた ストリームを返します。 要素はelt=で比較されます。省略時はequal?が使われます。

Function: stream-grep re stream ¶

{util.stream} re引数は正規表現オブジェクトか、その文字列表現でなければなりません (文字列の場合はstring->regexpで正規表現に変換されます)。

入力ストリームの要素のうち、reにマッチするものだけを含むようなストリームを 返します。

Function: write-stream stream :optional oport writer ¶

{util.stream} streamの各要素をwriterを使ってoportに書き出します。 oportが省略された場合は現在の出力ポートが、 writerが省略された場合はwrite-charが使われます。

要素の間には何も出力されません。既定値が示すように、 この手続きは文字の遅延ストリームを表示するのに便利です。