282 lines
393 KiB
HTML
282 lines
393 KiB
HTML
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
||
|
|
<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"/><meta name="viewport" content="width=device-width, initial-scale=0.8"/><title>4.16.1 Sequences</title><link rel="stylesheet" type="text/css" href="../scribble.css" title="default"/><link rel="stylesheet" type="text/css" href="extras.css" title="default"/><link rel="stylesheet" type="text/css" href="icons.css" title="default"/><link rel="stylesheet" type="text/css" href="../racket.css" title="default"/><link rel="stylesheet" type="text/css" href="../manual-style.css" title="default"/><link rel="stylesheet" type="text/css" href="../manual-racket.css" title="default"/><link rel="stylesheet" type="text/css" href="../manual-racket.css" title="default"/><link rel="stylesheet" type="text/css" href="../doc-site.css" title="default"/><script type="text/javascript" src="../scribble-common.js"></script><script type="text/javascript" src="../manual-racket.js"></script><script type="text/javascript" src="../manual-racket.js"></script><script type="text/javascript" src="../doc-site.js"></script><script type="text/javascript" src="../local-redirect/local-redirect.js"></script><script type="text/javascript" src="../local-redirect/local-user-redirect.js"></script><!--[if IE 6]><style type="text/css">.SIEHidden { overflow: hidden; }</style><![endif]--></head><body id="doc-racket-lang-org"><div class="tocset"><div class="tocview"><div class="tocviewlist tocviewlisttopspace"><div class="tocviewtitle"><table cellspacing="0" cellpadding="0"><tr><td style="width: 1em;"><a href="javascript:void(0);" title="Expand/Collapse" class="tocviewtoggle" onclick="TocviewToggle(this,"tocview_0");">►</a></td><td></td><td><a href="index.html" class="tocviewlink" data-pltdoc="x">The Racket Reference</a></td></tr></table></div><div class="tocviewsublisttop" style="display: none;" id="tocview_0"><table cellspacing="0" cellpadding="0"><tr><td align="right">1 </td><td><a href="model.html" class="tocviewlink" data-pltdoc="x">Language Model</a></td></tr><tr><td align="right">2 </td><td><a href="notation.html" class="tocviewlink" data-pltdoc="x">Notation for Documentation</a></td></tr><tr><td align="right">3 </td><td><a href="syntax.html" class="tocviewlink" data-pltdoc="x">Syntactic Forms</a></td></tr><tr><td align="right">4 </td><td><a href="data.html" class="tocviewselflink" data-pltdoc="x">Datatypes</a></td></tr><tr><td align="right">5 </td><td><a href="structures.html" class="tocviewlink" data-pltdoc="x">Structures</a></td></tr><tr><td align="right">6 </td><td><a href="mzlib_class.html" class="tocviewlink" data-pltdoc="x">Classes and Objects</a></td></tr><tr><td align="right">7 </td><td><a href="mzlib_unit.html" class="tocviewlink" data-pltdoc="x">Units</a></td></tr><tr><td align="right">8 </td><td><a href="contracts.html" class="tocviewlink" data-pltdoc="x">Contracts</a></td></tr><tr><td align="right">9 </td><td><a href="match.html" class="tocviewlink" data-pltdoc="x">Pattern Matching</a></td></tr><tr><td align="right">10 </td><td><a href="control.html" class="tocviewlink" data-pltdoc="x">Control Flow</a></td></tr><tr><td align="right">11 </td><td><a href="concurrency.html" class="tocviewlink" data-pltdoc="x">Concurrency and Parallelism</a></td></tr><tr><td align="right">12 </td><td><a href="Macros.html" class="tocviewlink" data-pltdoc="x">Macros</a></td></tr><tr><td align="right">13 </td><td><a href="input-and-output.html" class="tocviewlink" data-pltdoc="x">Input and Output</a></td></tr><tr><td align="right">14 </td><td><a href="security.html" class="tocviewlink" data-pltdoc="x">Reflection and Security</a></td></tr><tr><td align="right">15 </td><td><a href="os.html" class="tocviewlink" data-pltdoc="x">Operating System</a></td></tr><tr><td align="right">16 </td><td><a href="memory.html" class="tocviewlink" data-pltdoc="x">Memory Management</a></td></tr><tr><td align="right">17 </td><td><a href="unsafe.html" class="tocviewlink" data-pltdoc="x">Unsafe Operations</a></td></tr><
|
||
|
|
The elements of a sequence can be extracted with one of the
|
||
|
|
<span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> syntactic forms, with the procedures returned by
|
||
|
|
<span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span>, or by converting the sequence into a
|
||
|
|
<a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p>The sequence datatype overlaps with many other datatypes. Among
|
||
|
|
built-in datatypes, the sequence datatype includes the following:</p><ul><li><p>exact nonnegative integers (see below)</p></li><li><p>strings (see <a href="strings.html" data-pltdoc="x">Strings</a>)</p></li><li><p>byte strings (see <a href="bytestrings.html" data-pltdoc="x">Byte Strings</a>)</p></li><li><p>lists (see <a href="pairs.html" data-pltdoc="x">Pairs and Lists</a>)</p></li><li><p>mutable lists (see <a href="mpairs.html" data-pltdoc="x">Mutable Pairs and Lists</a>)</p></li><li><p>vectors (see <a href="vectors.html" data-pltdoc="x">Vectors</a>)</p></li><li><p>flvectors (see <a href="flonums.html#%28part._flvectors%29" data-pltdoc="x">Flonum Vectors</a>)</p></li><li><p>fxvectors (see <a href="fixnums.html#%28part._fxvectors%29" data-pltdoc="x">Fixnum Vectors</a>)</p></li><li><p>hash tables (see <a href="hashtables.html" data-pltdoc="x">Hash Tables</a>)</p></li><li><p>dictionaries (see <a href="dicts.html" data-pltdoc="x">Dictionaries</a>)</p></li><li><p>sets (see <a href="sets.html" data-pltdoc="x">Sets</a>)</p></li><li><p>input ports (see <a href="ports.html" data-pltdoc="x">Ports</a>)</p></li><li><p>streams (see <a href="streams.html" data-pltdoc="x">Streams</a>)</p></li></ul><p>An <a href="numbers.html#%28tech._exact._number%29" class="techoutside" data-pltdoc="x"><span class="techinside">exact number</span></a> <span class="RktVar">k</span> that is a non-negative
|
||
|
|
<a href="numbers.html#%28tech._integer%29" class="techoutside" data-pltdoc="x"><span class="techinside">integer</span></a> acts as a sequence similar to <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="stt"> </span><span class="RktVar">k</span><span class="RktPn">)</span>,
|
||
|
|
except that <span class="RktVar">k</span> by itself is not a <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p>Custom sequences can be defined using structure type properties. The
|
||
|
|
easiest method to define a custom sequence is to use the
|
||
|
|
<span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._gen~3astream%29%29" class="RktValLink" data-pltdoc="x">gen:stream</a></span> <a href="struct-generics.html#%28tech._generic._interface%29" class="techoutside" data-pltdoc="x"><span class="techinside">generic interface</span></a>. Streams are a suitable
|
||
|
|
abstraction for data structures that are directly iterable. For
|
||
|
|
example, a list is directly iterable with <span class="RktSym"><a href="pairs.html#%28def._%28%28lib._racket%2Flist..rkt%29._first%29%29" class="RktValLink" data-pltdoc="x">first</a></span> and
|
||
|
|
<span class="RktSym"><a href="pairs.html#%28def._%28%28lib._racket%2Flist..rkt%29._rest%29%29" class="RktValLink" data-pltdoc="x">rest</a></span>. On the other hand, vectors are not directly iterable:
|
||
|
|
iteration has to go through an index. For data structures that are not
|
||
|
|
directly iterable, the <a name="(tech._iterator)"></a><span style="font-style: italic">iterator</span> for the data structure can
|
||
|
|
be defined to be a stream (e.g., a structure containing the index of a
|
||
|
|
vector).</p><p>For example, unrolled linked lists (represented as a list of vectors)
|
||
|
|
themselves do not fit the stream abstraction, but have index-based
|
||
|
|
iterators that can be represented as streams:</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define-struct.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29" class="RktStxLink" data-pltdoc="x">struct</a></span><span class="hspace"> </span><span class="RktSym">unrolled-list-iterator</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">idx</span><span class="hspace"> </span><span class="RktSym">lst</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">#:methods</span><span class="hspace"> </span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._gen~3astream%29%29" class="RktValLink" data-pltdoc="x">gen:stream</a></span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-empty~3f%29%29" class="RktValLink" data-pltdoc="x">stream-empty?</a></span><span class="hspace"> </span><span class="RktSym">iter</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">lst</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">unrolled-list-iterator-lst</span><span class="hspace"> </span><span class="RktSym">iter</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29" class="RktStxLink" data-pltdoc="x">or</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._null~3f%29%29" class="RktValLink" data-pltdoc="x">null?</a></span><span class="hspace"> </span><span class="RktSym">lst</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29" class="RktStxLink" data-pltdoc="x">and</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3e~3d%29%29" class="RktValLink" data-pltdoc="x">>=</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">unrolled-list-iterator-idx</span><span class="hspace"> </span><span class="RktSym">iter</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29" class="RktValLink" data-pltdoc="x">vector-length</a></span><span class=
|
||
|
|
specifying iteration, such as when a pre-processing step is needed to
|
||
|
|
prepare the data for iteration. The <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-do-sequence%29%29" class="RktValLink" data-pltdoc="x">make-do-sequence</a></span>
|
||
|
|
function creates a sequence given a thunk that returns procedures to
|
||
|
|
implement a sequence, and the <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._prop~3asequence%29%29" class="RktValLink" data-pltdoc="x">prop:sequence</a></span> property can be
|
||
|
|
associated with a structure type to implement its implicit conversion
|
||
|
|
to a sequence.</p><p>For most sequence types, extracting elements from a sequence has no
|
||
|
|
side-effect on the original sequence value; for example, extracting
|
||
|
|
the sequence of elements from a list does not change the list. For
|
||
|
|
other sequence types, each extraction implies a side effect; for
|
||
|
|
example, extracting the sequence of bytes from a port causes the bytes
|
||
|
|
to be read from the port. <a name="(elem._sequence-state)"></a>A sequence’s state may either span all uses
|
||
|
|
of the sequence, as for a port, or it may be confined to each distinct
|
||
|
|
time that a sequence is <a name="(tech._initiate)"></a><span style="font-style: italic">initiate</span>d by a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> form,
|
||
|
|
<span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-~3estream%29%29" class="RktValLink" data-pltdoc="x">sequence->stream</a></span>, <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span>, or
|
||
|
|
<span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%2A%29%29" class="RktValLink" data-pltdoc="x">sequence-generate*</a></span>. Concretely, the thunk passed to
|
||
|
|
<span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-do-sequence%29%29" class="RktValLink" data-pltdoc="x">make-do-sequence</a></span> is called to <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a> the sequence
|
||
|
|
each time the sequence is used. Accordingly, different sequences behave
|
||
|
|
differently when they are <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d multiple times.</p><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">double-initiate</span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">initiate the sequence twice</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.1</span><span class="hspace"> </span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.2</span><span class="hspace"> </span><span class="RktSym">next.2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">alternate fetching from sequence via the two initiations</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list%29%29" class="RktValLink" data-pltdoc="x">list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.2</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">double-initiate</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="stringport.html#%28def._%28%28quote._~23~25kernel%29._open-input-string%29%29" class="RktValLink" data-pltdoc="x">open-input-string</a></span><span c
|
||
|
|
first result of <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span>, even if the second
|
||
|
|
result is never called.</p><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">double-initiate-and-use-more?</span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">initiate the sequence twice</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.1</span><span class="hspace"> </span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.2</span><span class="hspace"> </span><span class="RktSym">next.2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">s1</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">alternate fetching from sequence via the two initiations</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktCmt">;</span><span class="RktCmt"> </span><span class="RktCmt">but this time call `more?` in between</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list%29%29" class="RktValLink" data-pltdoc="x">list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.2</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">next.1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?.1</span><span class="RktP
|
||
|
|
“takes” the <span class="RktVal">98</span> just by virtue of the invocation of <span class="RktVar">more?.1</span>.</p><p>Individual elements of a sequence typically correspond to single
|
||
|
|
values, but an element may also correspond to multiple values. For
|
||
|
|
example, a hash table generates two values—<wbr></wbr>a key and its value—<wbr></wbr>for
|
||
|
|
each element in the sequence.</p><h5 x-source-module="(lib "scribblings/reference/reference.scrbl")" x-source-pkg="racket-doc" x-part-tag=""Sequence_Predicate_and_Constructors"">4.16.1.1<tt> </tt><a name="(part._.Sequence_.Predicate_and_.Constructors)"></a>Sequence Predicate and Constructors</h5><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._sequence~3f))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence?</a></span></span><span class="hspace"> </span><span class="RktVar">v</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">v</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns <span class="RktVal">#t</span> if <span class="RktVar">v</span> can be used as a <a href="sequences.html#%28tech._sequence%29" class="techoutside" data-pltdoc="x"><span class="techinside">sequence</span></a>,
|
||
|
|
<span class="RktVal">#f</span> otherwise.</div></p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span><span class="hspace"> </span><span class="RktVal">42</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#t</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">a</span><span class="hspace"> </span><span class="RktVal">b</span><span class="hspace"> </span><span class="RktVal">c</span><span class="RktVal">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#t</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span><span class="hspace"> </span><span class="RktVal">"word"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#t</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span><span class="hspace"> </span><span class="RktVal">#\x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#f</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-range))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-range</a></span></span><span class="hspace"> </span><span class="RktVar">end</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream~3f%29%29" class="RktValLink" data-pltdoc="x">stream?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">end</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29" class="RktValLink" data-pltdoc="x">real?</a></span></td></tr><tr><td><span class="RktPn">(</span><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-range</a></span></span><span class="hspace"> </span><span class="RktVar">start</span><span class="hspace"> </span><span class="RktVar">end</span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">step</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream~3f%29%29" class="RktValLink" data-pltdoc="x">st
|
||
|
|
numbers. The single-argument case <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="stt"> </span><span class="RktVar">end</span><span class="RktPn">)</span> is
|
||
|
|
equivalent to <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="stt"> </span><span class="RktVal">0</span><span class="stt"> </span><span class="RktVar">end</span><span class="stt"> </span><span class="RktVal">1</span><span class="RktPn">)</span>. The first number in the
|
||
|
|
sequence is <span class="RktVar">start</span>, and each successive element is generated
|
||
|
|
by adding <span class="RktVar">step</span> to the previous element. The sequence stops
|
||
|
|
before an element that would be greater or equal to <span class="RktVar">end</span> if
|
||
|
|
<span class="RktVar">step</span> is non-negative, or less or equal to <span class="RktVar">end</span> if
|
||
|
|
<span class="RktVar">step</span> is negative. </div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span> application can provide better performance for number iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div></p><p><div class="SIntrapara">Example: gaussian sum</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Fsum%29%29" class="RktStxLink" data-pltdoc="x">for/sum</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">45</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara">Example: sum of even numbers</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Fsum%29%29" class="RktStxLink" data-pltdoc="x">for/sum</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">100</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">2450</span></p></td></tr></table></blockquote></div></p><p>When given zero as <span class="RktVar">step</span>, <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span> returns an infinite
|
||
|
|
sequence. It may also return infinite sequences when <span class="RktVar">step</span> is a very
|
||
|
|
small number, and either <span class="RktVar">step</span> or the sequence elements are
|
||
|
|
floating-point numbers.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-inclusive-range))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-inclusive-range%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-inclusive-range</a></span></span><span class="hspace"> </span><span class="RktVar">start</span><span class="hspace"> </span><span class="RktVar">end</span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">step</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream~3f%29%29" class="RktValLink" data-pltdoc="x">stream?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">start</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29" class="RktValLink" data-pltdoc="x">real?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">end</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29" class="RktValLink" data-pltdoc="x">real?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">step</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29" class="RktValLink" data-pltdoc="x">real?</a></span><span class="hspace"> </span>=<span class="hspace"> </span><span class="RktVal">1</span></td></tr></table></blockquote></div><div class="SIntrapara">Similar to <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span>, but the sequence stopping condition is changed so that
|
||
|
|
the last element is allowed to be equal to <span class="RktVar">end</span>. </div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-inclusive-range%29%29" class="RktValLink" data-pltdoc="x">in-inclusive-range</a></span> application can provide better performance for number iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div></p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-~3elist%29%29" class="RktValLink" data-pltdoc="x">sequence->list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-inclusive-range%29%29" class="RktValLink" data-pltdoc="x">in-inclusive-range</a></span><span class="hspace"> </span><span class="RktVal">7</span><span class="hspace"> </span><span class="RktVal">11</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">'(7 8 9 10 11)</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-~3elist%29%29" class="RktValLink" data-pltdoc="x">sequence->list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-inclusive-range%29%29" class="RktValLink" data-pltdoc="x">in-inclusive-range</a></span><span class="hspace"> </span><span class="RktVal">7</span><span class="hspace"> </span><span class="RktVal">11</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">'(7 9 11)</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-~3elist%29%29" class="RktValLink" data-pltdoc="x">sequence->list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-inclusive-range%29%29" class="RktValLink" data-pltdoc="x">in-inclusive-range</a></span><span class="hspace"> </span><span class="RktVal">7</span><span class="hspace"> </span><span class="RktVal">10</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">'(7 9)</span></p></td></tr></table></blockquote></div></p><p class="SHistory">Added in version 8.0.0.13 of package <span class="stt">base</span>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-naturals))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-naturals%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-naturals</a></span></span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">start</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="s
|
||
|
|
integers starting with <span class="RktVar">start</span>, where each element is one
|
||
|
|
more than the preceding element. </div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-naturals%29%29" class="RktValLink" data-pltdoc="x">in-naturals</a></span> application can provide better performance for integer iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div></p><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">k</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-naturals%29%29" class="RktValLink" data-pltdoc="x">in-naturals</a></span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list%29%29" class="RktValLink" data-pltdoc="x">list</a></span><span class="hspace"> </span><span class="RktSym">k</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'((0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9))</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-list))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-list%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-list</a></span></span><span class="hspace"> </span><span class="RktVar">lst</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream~3f%29%29" class="RktValLink" data-pltdoc="x">stream?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">lst</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list~3f%29%29" class="RktValLink" data-pltdoc="x">list?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence (that is also a <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>) that is equivalent
|
||
|
|
to using <span class="RktVar">lst</span> directly as a sequence.
|
||
|
|
</div><div class="SIntrapara"><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="pairs.html" data-pltdoc="x">Pairs and Lists</a> for information on using lists as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote></div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-list%29%29" class="RktValLink" data-pltdoc="x">in-list</a></span> application can provide better performance for list iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div><div class="SIntrapara">See <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> for information on the reachability of list elements
|
||
|
|
during an iteration.</div></p><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-list%29%29" class="RktValLink" data-pltdoc="x">in-list</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">4</span><span class="RktVal">)</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktVal">`</span><span class="RktVal">(</span><span class="RktRdr">,</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktRdr">,</span><span class="RktPn">(</span><span class="RktSym"><a href="generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._%2A%29%29" class="RktValLink" data-pltdoc="x">*</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="RktVal">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'((3 9) (1 1) (4 16))</span></p></td></tr></table></blockquote></div></p><p class="SHistory">Changed in version 6.7.0.4 of package <span class="stt">base</span>: Improved element-reachability guarantee for lists in <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-mlist))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-mlist</a></span></span><span class="hspace"> </span><span class="RktVar">mlst</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">mlst</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="https://download.racket-lang.org/releases/8.6/doc/local-redirect/index.html?doc=compatibility&rel=mlists.html%23%2528def._%2528%2528lib._compatibility%252Fmlist..rkt%2529._mlist%7E3f%2529%2529&version=8.6" class="RktValLink Sq" data-pltdoc="x">mlist?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to <span class="RktVar">mlst</span>. Although the
|
||
|
|
expectation is that <span class="RktVar">mlst</span> is <a href="mpairs.html#%28tech._mutable._list%29" class="techoutside" data-pltdoc="x"><span class="techinside">mutable list</span></a>, <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29" class="RktValLink" data-pltdoc="x">in-mlist</a></span>
|
||
|
|
initially checks only whether <span class="RktVar">mlst</span> is a <a href="mpairs.html#%28tech._mutable._pair%29" class="techoutside" data-pltdoc="x"><span class="techinside">mutable pair</span></a> or <span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._null%29%29" class="RktValLink" data-pltdoc="x">null</a></span>,
|
||
|
|
since it could change during iteration.
|
||
|
|
</div><div class="SIntrapara"><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="mpairs.html" data-pltdoc="x">Mutable Pairs and Lists</a> for information on using mutable lists as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote></div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29" class="RktValLink" data-pltdoc="x">in-mlist</a></span> application can provide better performance for mutable list iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div></p><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29" class="RktValLink" data-pltdoc="x">in-mlist</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="mpairs.html#%28def._%28%28quote._~23~25kernel%29._mcons%29%29" class="RktValLink" data-pltdoc="x">mcons</a></span><span class="hspace"> </span><span class="RktVal">"RACKET"</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="mpairs.html#%28def._%28%28quote._~23~25kernel%29._mcons%29%29" class="RktValLink" data-pltdoc="x">mcons</a></span><span class="hspace"> </span><span class="RktVal">"LANG"</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="strings.html#%28def._%28%28quote._~23~25kernel%29._string-length%29%29" class="RktValLink" data-pltdoc="x">string-length</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'(6 4)</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-vector))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-vector</a></span></span><span class="hspace"> </span><span class="RktVar">vec</span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">start</span><span class="hspace"> </span><span class="RktVar">stop</span><span class="hspace"> </span><span class="RktVar">step</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">vec</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="vectors.html#%28def._
|
||
|
|
arguments are supplied.</div></p><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="vectors.html" data-pltdoc="x">Vectors</a> for information on using vectors as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote><p>The optional arguments <span class="RktVar">start</span>, <span class="RktVar">stop</span>, and
|
||
|
|
<span class="RktVar">step</span> are analogous to <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span>, except that a
|
||
|
|
<span class="RktVal">#f</span> value for <span class="RktVar">stop</span> is equivalent to
|
||
|
|
<span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29" class="RktValLink" data-pltdoc="x">vector-length</a></span><span class="stt"> </span><span class="RktVar">vec</span><span class="RktPn">)</span>. That is, the first element in the
|
||
|
|
sequence is <span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector-ref%29%29" class="RktValLink" data-pltdoc="x">vector-ref</a></span><span class="stt"> </span><span class="RktVar">vec</span><span class="stt"> </span><span class="RktVar">start</span><span class="RktPn">)</span>, and each successive
|
||
|
|
element is generated by adding <span class="RktVar">step</span> to index of the
|
||
|
|
previous element. The sequence stops before an index that would be
|
||
|
|
greater or equal to <span class="RktSym">end</span> if <span class="RktVar">step</span> is non-negative,
|
||
|
|
or less or equal to <span class="RktSym">end</span> if <span class="RktVar">step</span> is negative.</p><p>If <span class="RktVar">start</span> is not a valid index, then the
|
||
|
|
<span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised, except when <span class="RktVar">start</span>, <span class="RktVar">stop</span>, and
|
||
|
|
<span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29" class="RktValLink" data-pltdoc="x">vector-length</a></span><span class="stt"> </span><span class="RktVar">vec</span><span class="RktPn">)</span> are equal, in which case the result is an
|
||
|
|
empty sequence.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector%29%29" class="RktValLink" data-pltdoc="x">vector</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector%29%29" class="RktValLink" data-pltdoc="x">vector</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktErr">in-vector: starting index is out of range</span></p></td></tr><tr><td><p><span class="RktErr"></span><span class="hspace"> </span><span class="RktErr">starting index: 2</span></p></td></tr><tr><td><p><span class="RktErr"></span><span class="hspace"> </span><span class="RktErr">valid range: [0, 0]</span></p></td></tr><tr><td><p><span class="RktErr"></span><span class="hspace"> </span><span class="RktErr">vector: '#(1)</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="vectors.html#%28def._%28%28quote._~23~25kernel%29._vector%29%29" class="RktValLink" data-pltdoc="x">vector</a></span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">0</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span
|
||
|
|
then the <span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised.</p><p>If <span class="RktVar">start</span> is less than
|
||
|
|
<span class="RktVar">stop</span> and <span class="RktVar">step</span> is negative, then the
|
||
|
|
<span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised. Similarly, if <span class="RktVar">start</span>
|
||
|
|
is more than <span class="RktVar">stop</span> and <span class="RktVar">step</span> is positive, then the
|
||
|
|
<span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised.</p><p>An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span> application can provide better performance for vector iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">histogram</span><span class="hspace"> </span><span class="RktSym">vector-of-words</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">a-hash</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._make-hash%29%29" class="RktValLink" data-pltdoc="x">make-hash</a></span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">word</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span><span class="hspace"> </span><span class="RktSym">vector-of-words</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash-set%21%29%29" class="RktValLink" data-pltdoc="x">hash-set!</a></span><span class="hspace"> </span><span class="RktSym">a-hash</span><span class="hspace"> </span><span class="RktSym">word</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._add1%29%29" class="RktValLink" data-pltdoc="x">add1</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash-ref%29%29" class="RktValLink" data-pltdoc="x">hash-ref</a></span><span class="hspace"> </span><span class="RktSym">a-hash</span><span class="hspace"> </span><span class="RktSym">word</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym">a-hash</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><span class="stt">> <
|
||
|
|
arguments are supplied.</div></p><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="strings.html" data-pltdoc="x">Strings</a> for information on using strings as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote><p>The optional arguments <span class="RktVar">start</span>, <span class="RktVar">stop</span>, and
|
||
|
|
<span class="RktVar">step</span> are as in <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span>.</p><p>An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-string%29%29" class="RktValLink" data-pltdoc="x">in-string</a></span> application can provide better performance for string iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">line-count</span><span class="hspace"> </span><span class="RktVar">str</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Fsum%29%29" class="RktStxLink" data-pltdoc="x">for/sum</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">ch</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-string%29%29" class="RktValLink" data-pltdoc="x">in-string</a></span><span class="hspace"> </span><span class="RktVar">str</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="if.html#%28form._%28%28quote._~23~25kernel%29._if%29%29" class="RktStxLink" data-pltdoc="x">if</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="characters.html#%28def._%28%28quote._~23~25kernel%29._char~3d~3f%29%29" class="RktValLink" data-pltdoc="x">char=?</a></span><span class="hspace"> </span><span class="RktVal">#\newline</span><span class="hspace"> </span><span class="RktSym">ch</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">line-count</span><span class="hspace"> </span><span class="RktVal">"this string\nhas\nthree \nnewlines"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">3</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-bytes))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-bytes%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-bytes</a></span></span><span class="hspace"> </span><span class="RktVar">bstr</span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">start</span><span class="hspace">&nb
|
||
|
|
arguments are supplied.</div></p><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="bytestrings.html" data-pltdoc="x">Byte Strings</a> for information on using byte strings as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote><p>The optional arguments <span class="RktVar">start</span>, <span class="RktVar">stop</span>, and
|
||
|
|
<span class="RktVar">step</span> are as in <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29" class="RktValLink" data-pltdoc="x">in-vector</a></span>.</p><p>An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-bytes%29%29" class="RktValLink" data-pltdoc="x">in-bytes</a></span> application can provide better performance for byte string iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">has-eof?</span><span class="hspace"> </span><span class="RktSym">bs</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2For%29%29" class="RktStxLink" data-pltdoc="x">for/or</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">ch</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-bytes%29%29" class="RktValLink" data-pltdoc="x">in-bytes</a></span><span class="hspace"> </span><span class="RktSym">bs</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3d%29%29" class="RktValLink" data-pltdoc="x">=</a></span><span class="hspace"> </span><span class="RktSym">ch</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">has-eof?</span><span class="hspace"> </span><span class="RktVal">#"this byte string has an \0embedded zero byte"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#t</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">has-eof?</span><span class="hspace"> </span><span class="RktVal">#"this byte string does not"</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#f</span></p></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-port))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-port</a></span></span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">r</span><span class="hspace"> </span><span class="RktVar">in</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class=
|
||
|
|
on <span class="RktVar">in</span> until it produces <span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._eof%29%29" class="RktValLink" data-pltdoc="x">eof</a></span>.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-input-port-bytes))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-input-port-bytes%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-input-port-bytes</a></span></span><span class="hspace"> </span><span class="RktVar">in</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">in</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._input-port~3f%29%29" class="RktValLink" data-pltdoc="x">input-port?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29" class="RktValLink" data-pltdoc="x">in-port</a></span><span class="stt"> </span><span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-byte%29%29" class="RktValLink" data-pltdoc="x">read-byte</a></span><span class="stt"> </span><span class="RktVar">in</span><span class="RktPn">)</span>.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-input-port-chars))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-input-port-chars%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-input-port-chars</a></span></span><span class="hspace"> </span><span class="RktVar">in</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">in</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._input-port~3f%29%29" class="RktValLink" data-pltdoc="x">input-port?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence whose elements are read as characters from
|
||
|
|
<span class="RktVar">in</span> (equivalent to <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29" class="RktValLink" data-pltdoc="x">in-port</a></span><span class="stt"> </span><span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-char%29%29" class="RktValLink" data-pltdoc="x">read-char</a></span><span class="stt"> </span><span class="RktVar">in</span><span class="RktPn">)</span>).</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-lines))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-lines%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-lines</a></span></span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">in</span><span class="hspace"> </span><span class="RktVar">mode</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">in</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._input-port~3f%29%29" class="RktValLink" data-pltdoc="x">input-port?</a></span><span class="hspace"> </span>=<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-input-port%29%29" class="RktValLink" data-pltdoc="x">current-input-port</a></span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="argcontract"><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVar">mode</span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">:</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29" class="RktValLink" data-pltdoc="x">or/c</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">linefeed</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">return</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">return-linefeed</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">any</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">any-one</span><span class="RktPn">)</span></td></tr><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">=</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVal">'</span><span class="RktVal">any</span></td></tr></table></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to
|
||
|
|
<span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29" class="RktValLink" data-pltdoc="x">in-port</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29" class="RktStxLink" data-pltdoc="x">lambda</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">p</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-line%29%29" class="RktValLink" data-pltdoc="x">read-line</a></span><span class="stt"> </span><span class="RktSym">p</span><span class="stt"> </span><span class="RktVar">mode</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVar">in</span><span class="RktPn">)</span>. Note that
|
||
|
|
the default mode is <span class="RktVal">'</span><span class="RktVal">any</span>, whereas the default mode of
|
||
|
|
<span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-line%29%29" class="RktValLink" data-pltdoc="x">read-line</a></span> is <span class="RktVal">'</span><span class="RktVal">linefeed</span>.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-bytes-lines))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-bytes-lines%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-bytes-lines</a></span></span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">in</span><span class="hspace"> </span><span class="RktVar">mode</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">in</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._input-port~3f%29%29" class="RktValLink" data-pltdoc="x">input-port?</a></span><span class="hspace"> </span>=<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-input-port%29%29" class="RktValLink" data-pltdoc="x">current-input-port</a></span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="argcontract"><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVar">mode</span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">:</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29" class="RktValLink" data-pltdoc="x">or/c</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">linefeed</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">return</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">return-linefeed</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">any</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">any-one</span><span class="RktPn">)</span></td></tr><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">=</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVal">'</span><span class="RktVal">any</span></td></tr></table></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to
|
||
|
|
<span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29" class="RktValLink" data-pltdoc="x">in-port</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29" class="RktStxLink" data-pltdoc="x">lambda</a></span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym">p</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-bytes-line%29%29" class="RktValLink" data-pltdoc="x">read-bytes-line</a></span><span class="stt"> </span><span class="RktSym">p</span><span class="stt"> </span><span class="RktVar">mode</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="stt"> </span><span class="RktVar">in</span><span class="RktPn">)</span>. Note
|
||
|
|
that the default mode is <span class="RktVal">'</span><span class="RktVal">any</span>, whereas the default mode of
|
||
|
|
<span class="RktSym"><a href="Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-bytes-line%29%29" class="RktValLink" data-pltdoc="x">read-bytes-line</a></span> is <span class="RktVal">'</span><span class="RktVal">linefeed</span>.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-hash))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" data-pltdoc="x">hash?</a></span></td></tr><tr><td><span class="RktPn">(</span><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVar">bad-index-v</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" data-pltdoc="x">hash?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">bad-index-v</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to <span class="RktVar">hash</span>, except when <span class="RktVar">bad-index-v</span>
|
||
|
|
is supplied.</div></p><p>If <span class="RktVar">bad-index-v</span> is supplied, then <span class="RktVar">bad-index-v</span> is
|
||
|
|
returned as both the key and the value in the case that the
|
||
|
|
<span class="RktVar">hash</span> is modified concurrently so that iteration does not have a
|
||
|
|
<a href="hashtables.html#%28tech._valid._hash._index%29" class="techoutside" data-pltdoc="x"><span class="techinside">valid hash index</span></a>. Providing <span class="RktVar">bad-index-v</span> is particularly
|
||
|
|
useful when iterating through a hash table with weakly held keys, since
|
||
|
|
entries can be removed asynchronously (i.e., after <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span> has
|
||
|
|
committed to another iteration, but before it can access the entry for the
|
||
|
|
next iteration).</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">a</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">b</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym">key</span><span class="hspace"> </span><span class="RktSym">value</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"key: ~a value: ~a\n"</span><span class="hspace"> </span><span class="RktSym">key</span><span class="hspace"> </span><span class="RktSym">value</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktOut">key: b value: 2</span></p></td></tr><tr><td><p><span class="RktOut">key: a value: 1</span></p></td></tr></table></td></tr></table></blockquote></div></p><blockquote class="refpara"><blockquote class="refcolumn"><blockquote class="refcontent"><p>See <a href="hashtables.html" data-pltdoc="x">Hash Tables</a> for information on using hash tables as
|
||
|
|
sequences.</p></blockquote></blockquote></blockquote><p class="SHistory">Changed in version 7.0.0.10 of package <span class="stt">base</span>: Added the optional <span class="RktVar">bad-index-v</span> argument.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-hash-keys))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-keys%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash-keys</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" data-pltdoc="x">hash?</a></span></td></tr><tr><td><span class="RktPn">(</span><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-keys%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash-keys</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVar">bad-index-v</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" data-pltdoc="x">hash?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">bad-index-v</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence whose elements are the keys of <span class="RktVar">hash</span>, using
|
||
|
|
<span class="RktVar">bad-index-v</span> in the same way as <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span>.</div></p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">a</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">b</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">key</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-keys%29%29" class="RktValLink" data-pltdoc="x">in-hash-keys</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"key: ~a\n"</span><span class="hspace"> </span><span class="RktSym">key</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktOut">key: b</span></p></td></tr><tr><td><p><span class="RktOut">key: a</span></p></td></tr></table></td></tr></table></blockquote></div></p><p class="SHistory">Changed in version 7.0.0.10 of package <span class="stt">base</span>: Added the optional <span class="RktVar">bad-index-v</span> argument.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-hash-values))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-values%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash-values</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" data-pltdoc=
|
||
|
|
<span class="RktVar">bad-index-v</span> in the same way as <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span>.</div></p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">a</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">b</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">value</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-values%29%29" class="RktValLink" data-pltdoc="x">in-hash-values</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"value: ~a\n"</span><span class="hspace"> </span><span class="RktSym">value</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktOut">value: 2</span></p></td></tr><tr><td><p><span class="RktOut">value: 1</span></p></td></tr></table></td></tr></table></blockquote></div></p><p class="SHistory">Changed in version 7.0.0.10 of package <span class="stt">base</span>: Added the optional <span class="RktVar">bad-index-v</span> argument.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-hash-pairs))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-pairs%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-hash-pairs</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="hashtables.html#%28def._%28%28quote._~23~25kernel%29._hash~3f%29%29" class="RktValLink" d
|
||
|
|
and its value from <span class="RktVar">hash</span> (as opposed to using <span class="RktVar">hash</span>
|
||
|
|
directly as a sequence to get the key and value as separate values
|
||
|
|
for each element).</div></p><p>The <span class="RktVar">bad-index-v</span> argument, if supplied, is used in the same
|
||
|
|
way as by <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span>. When an invalid index is encountered,
|
||
|
|
the pair in the sequence with have <span class="RktVar">bad-index-v</span> as both its
|
||
|
|
<span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._car%29%29" class="RktValLink" data-pltdoc="x">car</a></span> and <span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._cdr%29%29" class="RktValLink" data-pltdoc="x">cdr</a></span>.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktVar">hash</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">a</span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">b</span><span class="hspace"> </span><span class="RktVal">2</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">key+value</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-pairs%29%29" class="RktValLink" data-pltdoc="x">in-hash-pairs</a></span><span class="hspace"> </span><span class="RktSym">table</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"key and value: ~a\n"</span><span class="hspace"> </span><span class="RktSym">key+value</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktOut">key and value: (b . 2)</span></p></td></tr><tr><td><p><span class="RktOut">key and value: (a . 1)</span></p></td></tr></table></td></tr></table></blockquote></div></p><p class="SHistory">Changed in version 7.0.0.10 of package <span class="stt">base</span>: Added the optional <span class="RktVar">bad-index-v</span> argument.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><table cellspacing="0" cellpadding="0" class="together"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-mutable-hash))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mutable-hash%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-mutable-hash</a></span></span><span class="hspace"> </span><span class="RktVar">hash</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">hash</span><span class="hspace">&n
|
||
|
|
These may perform better than the analogous <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29" class="RktValLink" data-pltdoc="x">in-hash</a></span>
|
||
|
|
forms.</div></p><p class="SHistory">Added in version 6.4.0.6 of package <span class="stt">base</span>.<br/>Changed in version 7.0.0.10: Added the optional <span class="RktVar">bad-index-v</span> argument.<br/>Changed in version 8.0.0.10: Added <span class="RktSym">ephemeron</span> variants.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-directory))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-directory</a></span></span><span class="hspace"> </span><span class="RktOpt">[</span><span class="RktVar">dir</span><span class="hspace"> </span><span class="RktVar">use-dir?</span><span class="RktOpt">]</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">dir</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29" class="RktValLink" data-pltdoc="x">or/c</a></span><span class="hspace"> </span><span class="RktVal">#f</span><span class="hspace"> </span><span class="RktSym"><a href="Manipulating_Paths.html#%28def._%28%28lib._racket%2Fprivate%2Fmisc..rkt%29._path-string~3f%29%29" class="RktValLink" data-pltdoc="x">path-string?</a></span><span class="RktPn">)</span><span class="hspace"> </span>=<span class="hspace"> </span><span class="RktVal">#f</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="argcontract"><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVar">use-dir?</span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">:</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktPn">(</span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._and%2Fc%29%29" class="RktValLink" data-pltdoc="x">and/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="Manipulating_Paths.html#%28def._%28%28quote._~23~25kernel%29._path~3f%29%29" class="RktValLink" data-pltdoc="x">path?</a></span><span class="hspace"> </span><span class="RktSym"><a href="Manipulating_Paths.html#%28def._%28%28quote._~23~25kernel%29._complete-path~3f%29%29" class="RktValLink" data-pltdoc="x">complete-path?</a></span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="RktPn"> .</span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="RktPn">)</span></td></tr><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">=</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktPn">(</span><span class="RktSym"><a href="lambda.html
|
||
|
|
directories, and links within <span class="RktVar">dir</span>, except for the
|
||
|
|
contents of any directory for which <span class="RktVar">use-dir?</span> returns
|
||
|
|
<span class="RktVal">#f</span>. If <span class="RktVar">dir</span> is not
|
||
|
|
<span class="RktVal">#f</span>, then every produced path starts with <span class="RktVar">dir</span> as
|
||
|
|
its prefix. If <span class="RktVar">dir</span> is <span class="RktVal">#f</span>, then paths in and
|
||
|
|
relative to the current directory are produced.</div></p><p>An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29" class="RktValLink" data-pltdoc="x">in-directory</a></span> sequence traverses nested subdirectories
|
||
|
|
recursively (filtered by <span class="RktVar">use-dir?</span>).
|
||
|
|
To generate a sequence that includes only the immediate
|
||
|
|
content of a directory, use the result of <span class="RktSym"><a href="Filesystem.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._directory-list%29%29" class="RktValLink" data-pltdoc="x">directory-list</a></span> as
|
||
|
|
a sequence.</p><p>The immediate content of each directory is reported as sorted by
|
||
|
|
<span class="RktSym"><a href="Manipulating_Paths.html#%28def._%28%28quote._~23~25kernel%29._path~3c~3f%29%29" class="RktValLink" data-pltdoc="x">path<?</a></span>, and the content of a subdirectory is reported
|
||
|
|
before subsequent paths within the directory.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="Filesystem.html#%28def._%28%28quote._~23~25kernel%29._current-directory%29%29" class="RktValLink" data-pltdoc="x">current-directory</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="collects.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._collection-path%29%29" class="RktValLink" data-pltdoc="x">collection-path</a></span><span class="hspace"> </span><span class="RktVal">"info"</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29" class="RktValLink" data-pltdoc="x">in-directory</a></span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym">f</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktRes">'(#<path:compiled></span></p></td></tr><tr><td><p><span class="RktRes"></span><span class="hspace"> </span><span class="RktRes">#<path:compiled/main_rkt.dep></span></p></td></tr><tr><td><p><span class="RktRes"></span><span class="hspace"> </span><span class="RktRes">#<path:compiled/main_rkt.zo></span></p></td></tr><tr><td><p><span class="RktRes"></span><span class="hspace"> </span><span class="RktRes">#<path:main.rkt>)</span></p></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29" class="RktValLink" data-pltdoc="x">in-directory</a></span><span class="hspace"> </span><span class="RktVal">"compiled"</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym">f</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'(#<path:main_rkt.dep> #<path:main_rkt.zo>)</span></p></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">f</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29" class="RktValLink" data-pltdoc="x">in-directory</a></span><span class="hspace
|
||
|
|
<span class="RktVar">producer</span>, which would usually use some state to do its work.</div></p><p>If a <span class="RktVar">stop</span> value is not given, the sequence goes on
|
||
|
|
infinitely, and therefore it is common to use it with a finite sequence
|
||
|
|
or using <span class="RktPn">#:break</span> etc. If a <span class="RktVar">stop</span> value is given, it
|
||
|
|
is used to identify a value that marks the end of the sequence (and
|
||
|
|
the <span class="RktVar">stop</span> value is not included in the sequence);
|
||
|
|
<span class="RktVar">stop</span> can be a predicate that is applied to the results of
|
||
|
|
<span class="RktVar">producer</span>, or it can be a value that is tested against the
|
||
|
|
result of with <span class="RktSym"><a href="Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29" class="RktValLink" data-pltdoc="x">eq?</a></span>. (The <span class="RktVar">stop</span> argument must be a
|
||
|
|
predicate if the stop value is itself a function or if
|
||
|
|
<span class="RktVar">producer</span> returns multiple values.)</p><p>If additional <span class="RktVar">arg</span>s are specified, they are passed to every
|
||
|
|
call to <span class="RktVar">producer</span>.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">counter</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktVal">0</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29" class="RktStxLink" data-pltdoc="x">lambda</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">d</span><span class="hspace"> </span><span class="RktVal">1</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="set_.html#%28form._%28%28quote._~23~25kernel%29._set%21%29%29" class="RktStxLink" data-pltdoc="x">set!</a></span><span class="hspace"> </span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._%2B%29%29" class="RktValLink" data-pltdoc="x">+</a></span><span class="hspace"> </span><span class="RktSym">d</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">n</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-producer%29%29" class="RktValLink" data-pltdoc="x">in-producer</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">counter</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">y</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">4</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">'(1 2 3 4)</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[<
|
||
|
|
such as <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2A%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for*/list</a></span>—<wbr></wbr>but a <span class="RktPn">#:do</span> clause form, added
|
||
|
|
more recently, covers many of the same uses.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-indexed))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-indexed%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-indexed</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence where each element has two values: the value
|
||
|
|
produced by <span class="RktVar">seq</span>, and a non-negative exact integer starting
|
||
|
|
with <span class="RktVal">0</span>. The elements of <span class="RktVar">seq</span> must be
|
||
|
|
single-valued.</div></p><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktPn">(</span><span class="RktSym">ch</span><span class="hspace"> </span><span class="RktSym">i</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-indexed%29%29" class="RktValLink" data-pltdoc="x">in-indexed</a></span><span class="hspace"> </span><span class="RktVal">"hello"</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"The char at position ~a is: ~a\n"</span><span class="hspace"> </span><span class="RktSym">i</span><span class="hspace"> </span><span class="RktSym">ch</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0"><tr><td><p><span class="RktOut">The char at position 0 is: h</span></p></td></tr><tr><td><p><span class="RktOut">The char at position 1 is: e</span></p></td></tr><tr><td><p><span class="RktOut">The char at position 2 is: l</span></p></td></tr><tr><td><p><span class="RktOut">The char at position 3 is: l</span></p></td></tr><tr><td><p><span class="RktOut">The char at position 4 is: o</span></p></td></tr></table></td></tr></table></blockquote></div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-sequences))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-sequences%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-sequences</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span><span class="RktMeta">...</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that is made of all input sequences, one after
|
||
|
|
the other. Each <span class="RktVar">seq</span> is <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d only after the
|
||
|
|
preceding <span class="RktVar">seq</span> is exhausted. If a single <span class="RktVar">seq</span> is
|
||
|
|
provided, then <span class="RktVar">seq</span> is returned; otherwise, the elements of
|
||
|
|
each <span class="RktVar">seq</span> must all have the same number of values.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-cycle))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-cycle%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-cycle</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span><span class="RktMeta">...</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Similar to <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-sequences%29%29" class="RktValLink" data-pltdoc="x">in-sequences</a></span>, but the sequences are repeated in
|
||
|
|
an infinite cycle, where each <span class="RktVar">seq</span> is <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d
|
||
|
|
afresh in each iteration. Beware that if no <span class="RktVar">seq</span>s are
|
||
|
|
provided or if all <span class="RktVar">seq</span>s become empty, then the sequence
|
||
|
|
produced by <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-cycle%29%29" class="RktValLink" data-pltdoc="x">in-cycle</a></span> never returns when an element is
|
||
|
|
demanded—<wbr></wbr>or even when the sequence is <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d, if all
|
||
|
|
<span class="RktVar">seq</span>s are initially empty.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-parallel))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-parallel%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-parallel</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span><span class="RktMeta">...</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence where each element has as many values as the
|
||
|
|
number of supplied <span class="RktVar">seq</span>s; the values, in order, are the
|
||
|
|
values of each <span class="RktVar">seq</span>. The elements of each <span class="RktVar">seq</span> must
|
||
|
|
be single-valued.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-values-sequence))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-values-sequence%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-values-sequence</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that is like <span class="RktVar">seq</span>, but it combines
|
||
|
|
multiple values for each element from <span class="RktVar">seq</span> as a list of
|
||
|
|
elements.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._in-values*-sequence))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-values%2A-sequence%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-values*-sequence</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that is like <span class="RktVar">seq</span>, but when an element of
|
||
|
|
<span class="RktVar">seq</span> has multiple values or a single list value, then the
|
||
|
|
values are combined in a list. In other words,
|
||
|
|
<span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-values%2A-sequence%29%29" class="RktValLink" data-pltdoc="x">in-values*-sequence</a></span> is like <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-values-sequence%29%29" class="RktValLink" data-pltdoc="x">in-values-sequence</a></span>,
|
||
|
|
except that non-list, single-valued elements are not wrapped in a
|
||
|
|
list.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._stop-before))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._stop-before%29%29" class="RktValDef RktValLink" data-pltdoc="x">stop-before</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span><span class="RktVar">pred</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">pred</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="RktPn"> .</span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%29%29" class="RktStxLink" data-pltdoc="x">any</a></span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that contains the elements of <span class="RktVar">seq</span> (which
|
||
|
|
must be single-valued), but only until the last element for which
|
||
|
|
applying <span class="RktVar">pred</span> to the element produces <span class="RktVal">#t</span>, after
|
||
|
|
which the sequence ends.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._stop-after))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._stop-after%29%29" class="RktValDef RktValLink" data-pltdoc="x">stop-after</a></span></span><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span><span class="RktVar">pred</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">pred</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="RktPn"> .</span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%29%29" class="RktStxLink" data-pltdoc="x">any</a></span><span class="RktPn">)</span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that contains the elements of <span class="RktVar">seq</span> (which
|
||
|
|
must be single-valued), but only until the element (inclusive) for
|
||
|
|
which applying <span class="RktVar">pred</span> to the element produces <span class="RktVal">#t</span>,
|
||
|
|
after which the sequence ends.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/private/base..rkt)._make-do-sequence))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-do-sequence%29%29" class="RktValDef RktValLink" data-pltdoc="x">make-do-sequence</a></span></span><span class="hspace"> </span><span class="RktVar">thunk</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="argcontract"><tr><td valign="top"><span class="hspace"> </span></td><td valign="top"><span class="RktVar">thunk</span></td><td valign="top"><span class="hspace"> </span></td><td valign="top">:</td><td valign="top"><span class="hspace"> </span></td><td valign="top"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29" class="RktValLink" data-pltdoc="x">or/c</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="values.html#%28def._%28%28quote._~23~25kernel%29._values%29%29" class="RktValLink" data-pltdoc="x">values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="RktPn"> .</span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%29%29" class="RktStxLink" data-pltdoc="x">any</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="RktPn"> .</span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%
|
||
|
|
and initial value returned by the thunk, which is called to
|
||
|
|
<a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a> the sequence. The initiated sequence is defined in
|
||
|
|
terms of a <span style="font-style: italic">position</span>, which is initialized to the third
|
||
|
|
result of the thunk, and the <span style="font-style: italic">element</span>, which may consist of
|
||
|
|
multiple values.</div></p><p><div class="SIntrapara">The <span class="RktVar">thunk</span> results define the generated elements as follows:
|
||
|
|
</div><div class="SIntrapara"><ul><li><p>The first result is a <span class="RktVar">pos->element</span> procedure that
|
||
|
|
takes the current position and returns the value(s) for the
|
||
|
|
current element.</p></li><li><p>The optional second result is an <span class="RktVar">early-next-pos</span>
|
||
|
|
procedure that is described further below. Alternatively, the
|
||
|
|
optional second result can be <span class="RktVal">#f</span>, which is equivalent
|
||
|
|
to the identity function.</p></li><li><p>The third (or second) result is a <span class="RktVar">next-pos</span> procedure that
|
||
|
|
takes the current position and returns the next position.</p></li><li><p>The fourth (or third) result is the initial position.</p></li><li><p>The fifth (or fourth) result is a <span class="RktVar">continue-with-pos?</span> function
|
||
|
|
that takes the current position and returns a true result if the
|
||
|
|
sequence includes the value(s) for the current position, and
|
||
|
|
false if the sequence should end instead of including the
|
||
|
|
value(s). Alternatively, the fifth (or fourth) result can be <span class="RktVal">#f</span> to
|
||
|
|
indicate that the sequence should always include the current
|
||
|
|
value(s). This function is checked on each position before
|
||
|
|
<span class="RktVar">pos->element</span> is used.</p></li><li><p>The sixth (or fifth) result is a <span class="RktVar">continue-with-val?</span> function
|
||
|
|
that is like the fifth (or fourth) result, but it takes the current element
|
||
|
|
value(s) instead of the current position. Alternatively, the
|
||
|
|
sixth (or fifth) result can be <span class="RktVal">#f</span> to indicate that the sequence
|
||
|
|
should always include the value(s) at the current position.</p></li><li><p>The seventh (or sixth) result is a <span class="RktVar">continue-after-pos+val?</span>
|
||
|
|
procedure that takes both the current position and the current
|
||
|
|
element value(s) and determines whether the sequence ends after
|
||
|
|
the current element is already included in the sequence.
|
||
|
|
Alternatively, the seventh (or sixth) result can be <span class="RktVal">#f</span> to indicate
|
||
|
|
that the sequence can always continue after the current
|
||
|
|
value(s).</p></li></ul></div></p><p>The <span class="RktVar">early-next-pos</span> procedure, which is the optional second
|
||
|
|
result, takes the current position and returns an updated position.
|
||
|
|
This updated position is used for <span class="RktVar">next-pos</span> and
|
||
|
|
<span class="RktVar">continue-after-pos+val?</span>, but not with
|
||
|
|
<span class="RktVar">continue-with-pos?</span> (which uses the original current
|
||
|
|
position). The intent of <span class="RktVar">early-next-pos</span> is to support a
|
||
|
|
sequence where the position must be incremented to avoid keeping a
|
||
|
|
value reachable while a loop processes the sequence value, so
|
||
|
|
<span class="RktVar">early-next-pos</span> is applied just after
|
||
|
|
<span class="RktVar">pos->element</span>.</p><p>Each of the procedures listed above is called only once per
|
||
|
|
position. Among the last three procedures, as soon as one of the
|
||
|
|
procedures returns <span class="RktVal">#f</span>, the sequence ends, and none are
|
||
|
|
called again. Typically, one of the functions determines the end
|
||
|
|
condition, and <span class="RktVal">#f</span> is used in place of the other two
|
||
|
|
functions.</p><p class="SHistory">Changed in version 6.7.0.4 of package <span class="stt">base</span>: Added support for the optional second result.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>value</p></div></div><p class="RForeground"><a name="(def._((lib._racket/private/base..rkt)._prop~3asequence))"></a><span title="Provided from: racket/base, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._prop~3asequence%29%29" class="RktValDef RktValLink" data-pltdoc="x">prop:sequence</a></span></span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="structprops.html#%28def._%28%28quote._~23~25kernel%29._struct-type-property~3f%29%29" class="RktValLink" data-pltdoc="x">struct-type-property?</a></span></p></blockquote></td></tr></table></blockquote></div><div class="SIntrapara">Associates a procedure to a structure type that takes an instance of
|
||
|
|
the structure and returns a sequence. If <span class="RktSym">v</span> is an instance
|
||
|
|
of a structure type with this property, then <span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span><span class="stt"> </span><span class="RktSym">v</span><span class="RktPn">)</span>
|
||
|
|
produces <span class="RktVal">#t</span>.</div></p><p>Using a pre-existing sequence:</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define-struct.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29" class="RktStxLink" data-pltdoc="x">struct</a></span><span class="hspace"> </span><span class="RktSym">my-set</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">table</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">#:property</span><span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._prop~3asequence%29%29" class="RktValLink" data-pltdoc="x">prop:sequence</a></span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29" class="RktStxLink" data-pltdoc="x">lambda</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">s</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-keys%29%29" class="RktValLink" data-pltdoc="x">in-hash-keys</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">my-set-table</span><span class="hspace"> </span><span class="RktSym">s</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">make-set</span><span class="hspace"> </span><span class="RktPn">. </span><span class="RktSym">xs</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">my-set</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Fhash%29%29" class="RktStxLink" data-pltdoc="x">for/hash</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-list%29%29" class="RktValLink" data-pltdoc="x">in-list</a></span><span class="hspace"> </span><span class="RktSym">xs</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="values.html#%28def._%28%28quote._~23~25kernel%29._values%29%29" class="RktValLink" data-pltdoc="x">values</a></span><span class="hspace"> </span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktVal">#t</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><tab
|
||
|
|
<span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span> and <span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-rest%29%29" class="RktValLink" data-pltdoc="x">stream-rest</a></span> operations. Creation
|
||
|
|
of the stream eagerly <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiates</span></a> the sequence, but the stream
|
||
|
|
lazily draws elements from the sequence, caching each element so
|
||
|
|
that <span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span> produces the same result each time is
|
||
|
|
applied to a stream.</div></p><p>If extracting an element from <span class="RktVar">seq</span> involves a side-effect,
|
||
|
|
then the effect is performed each time that either
|
||
|
|
<span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span> or <span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-rest%29%29" class="RktValLink" data-pltdoc="x">stream-rest</a></span> is first used to
|
||
|
|
access or skip an element.</p><p>Note that a <a href="sequences.html#%28elem._sequence-state%29" data-pltdoc="x">sequence itself can have
|
||
|
|
state</a>, so multiple calls to <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-~3estream%29%29" class="RktValLink" data-pltdoc="x">sequence->stream</a></span> on the same
|
||
|
|
<span class="RktVar">seq</span> are not necessarily independent.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="stringport.html#%28def._%28%28quote._~23~25kernel%29._open-input-bytes%29%29" class="RktValLink" data-pltdoc="x">open-input-bytes</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="bytestrings.html#%28def._%28%28quote._~23~25kernel%29._bytes%29%29" class="RktValLink" data-pltdoc="x">bytes</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">4</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">strm</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-~3estream%29%29" class="RktValLink" data-pltdoc="x">sequence->stream</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span><span class="hspace"> </span><span class="RktSym">strm</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">1</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-rest%29%29" class="RktValLink" data-pltdoc="x">stream-rest</a></span><span class="hspace"> </span><span class="RktSym">strm</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">2</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._stream-first%29%29" class="RktValLink" data-pltdoc="x">stream-first</a></span><span class="hspace"> </span><span class="RktSym">strm</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">1</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">strm2</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-~3estream%29%29" class="RktValLink" data-pltdoc="x">sequence->stream</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="RktPn">)
|
||
|
|
elements from the sequence. The first returns <span class="RktVal">#t</span> if more
|
||
|
|
values are available for the sequence. The second returns the next
|
||
|
|
element (which may be multiple values) from the sequence; if no more
|
||
|
|
elements are available, the <span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised.</div></p><p>Note that a <a href="sequences.html#%28elem._sequence-state%29" data-pltdoc="x">sequence itself can have
|
||
|
|
state</a>, so multiple calls to <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span> on the same
|
||
|
|
<span class="RktVar">seq</span> are not necessarily independent.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29" class="RktStxLink" data-pltdoc="x">define</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="stringport.html#%28def._%28%28quote._~23~25kernel%29._open-input-bytes%29%29" class="RktValLink" data-pltdoc="x">open-input-bytes</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="bytestrings.html#%28def._%28%28quote._~23~25kernel%29._bytes%29%29" class="RktValLink" data-pltdoc="x">bytes</a></span><span class="hspace"> </span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktVal">4</span><span class="hspace"> </span><span class="RktVal">5</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more?</span><span class="hspace"> </span><span class="RktSym">get</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">more?</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">#t</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">get</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">1</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym">get</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">2</span></p></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="define.html#%28form._%28%28quote._~23~25kernel%29._define-values%29%29" class="RktStxLink" data-pltdoc="x">define-values</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">more2?</span><span class="hspace"> </span><span class="RktSym">get2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29" class="RktValLink" data-pltdoc="x">sequence-generate</a></span><span class="hspace"> </span><span class="RktSym">inport</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list%29%29" class="RktValLink" data-pltdoc="x">list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">get2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">get2</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">get2</span><span class="RktPn">)
|
||
|
|
inherent in the sequence) by returning a list of values for the
|
||
|
|
sequence’s first element—<wbr></wbr>or <span class="RktVal">#f</span> if the sequence is
|
||
|
|
empty—<wbr></wbr>and a thunk to continue with the sequence; the result of the
|
||
|
|
thunk is the same as the result of <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%2A%29%29" class="RktValLink" data-pltdoc="x">sequence-generate*</a></span>, but
|
||
|
|
for the second element of the sequence, and so on. If the thunk is
|
||
|
|
called when the element result is <span class="RktVal">#f</span> (indicating no further
|
||
|
|
values in the sequence), the <span class="RktSym"><a href="exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29" class="RktValLink" data-pltdoc="x">exn:fail:contract</a></span> exception is raised.</div></p><h5 x-source-module="(lib "scribblings/reference/reference.scrbl")" x-source-pkg="racket-doc" x-part-tag=""more-sequences"">4.16.1.3<tt> </tt><a name="(part._more-sequences)"></a><a name="(mod-path._racket/sequence)"></a>Additional Sequence Operations</h5><p><div class="SIntrapara"><table cellspacing="0" cellpadding="0" class="defmodule"><tr><td align="left"><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29" class="RktStxLink" data-pltdoc="x">require</a></span><span class="stt"> </span><a href="sequences.html#%28mod-path._racket%2Fsequence%29" class="RktModLink" data-pltdoc="x"><span class="RktSym">racket/sequence</span></a><span class="RktPn">)</span></td><td align="right"><span class="RpackageSpec"><span class="Smaller"> package:</span> <a href="https://pkgs.racket-lang.org/package/base" title="Install this package using `raco pkg install base`"><span class="stt">base</span></a></span></td></tr></table></div><div class="SIntrapara">The bindings documented in this section are provided by the <a href="sequences.html#%28mod-path._racket%2Fsequence%29" class="RktModLink" data-pltdoc="x"><span class="RktSym">racket/sequence</span></a> and <a href="index.html" class="RktModLink" data-pltdoc="x"><span class="RktSym">racket</span></a> libraries, but not <a href="index.html" class="RktModLink" data-pltdoc="x"><span class="RktSym">racket/base</span></a>.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>value</p></div></div><p class="RForeground"><a name="(def._((lib._racket/sequence..rkt)._empty-sequence))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._empty-sequence%29%29" class="RktValDef RktValLink" data-pltdoc="x">empty-sequence</a></span></span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr></table></blockquote></div><div class="SIntrapara">A sequence with no elements.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-~3elist))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-~3elist%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence->list</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list~3f%29%29" class="RktValLink" data-pltdoc="x">list?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Retur
|
||
|
|
of which must be a single value. If <span class="RktVar">s</span> is infinite, this
|
||
|
|
function does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-length))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-length%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-length</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29" class="RktValLink" data-pltdoc="x">exact-nonnegative-integer?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns the number of elements of <span class="RktVar">s</span> by extracting and
|
||
|
|
discarding all of them. If <span class="RktVar">s</span> is infinite, this function
|
||
|
|
does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-ref))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-ref%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-ref</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span><span class="RktVar">i</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%29%29" class="RktStxLink" data-pltdoc="x">any</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">i</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29" class="RktValLink" data-pltdoc="x">exact-nonnegative-integer?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns the <span class="RktVar">i</span>th element of <span class="RktVar">s</span> (which may be
|
||
|
|
multiple values).</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-tail))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-tail%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-tail</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span><span class="RktVar">i</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">i</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29" class="RktValLink" data-pltdoc="x">exact-nonnegative-integer?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence equivalent to <span class="RktVar">s</span>, except that the first
|
||
|
|
<span class="RktVar">i</span> elements are omitted.</div></p><p>In case <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiating</span></a> <span class="RktVar">s</span> involves a
|
||
|
|
side effect, the sequence <span class="RktVar">s</span> is not <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d until
|
||
|
|
the resulting sequence is <a href="sequences.html#%28tech._initiate%29" class="techoutside" data-pltdoc="x"><span class="techinside">initiate</span></a>d, at which point the first
|
||
|
|
<span class="RktVar">i</span> elements are extracted from the sequence.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-append))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-append%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-append</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span><span class="RktMeta">...</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that contains all elements of each sequence in
|
||
|
|
the order they appear in the original sequences. The new sequence
|
||
|
|
is constructed lazily.</div></p><p>If all given <span class="RktVar">s</span>s are <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">streams</span></a>, the result is also a
|
||
|
|
<a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-map))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-map%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-map</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="procedures.html#%28def._%28%28quote._~23~25kernel%29._procedure~3f%29%29" class="RktValLink" data-pltdoc="x">procedure?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence that contains <span class="RktVar">f</span> applied to each element
|
||
|
|
of <span class="RktVar">s</span>. The new sequence is constructed lazily.</div></p><p>If <span class="RktVar">s</span> is a <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>, then the result is also a
|
||
|
|
<a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-andmap))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-andmap%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-andmap</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns <span class="RktVal">#t</span> if <span class="RktVar">f</span> returns a true result on every
|
||
|
|
element of <span class="RktVar">s</span>. If <span class="RktVar">s</span> is infinite and <span class="RktVar">f</span>
|
||
|
|
never returns a false result, this function does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-ormap))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-ormap%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-ormap</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns <span class="RktVal">#t</span> if <span class="RktVar">f</span> returns a true result on some
|
||
|
|
element of <span class="RktVar">s</span>. If <span class="RktVar">s</span> is infinite and <span class="RktVar">f</span>
|
||
|
|
never returns a true result, this function does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-for-each))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-for-each%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-for-each</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="void.html#%28def._%28%28quote._~23~25kernel%29._void~3f%29%29" class="RktValLink" data-pltdoc="x">void?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%29%29" class="RktStxLink" data-pltdoc="x">any</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Applies <span class="RktVar">f</span> to each element of <span class="RktVar">s</span>. If <span class="RktVar">s</span> is
|
||
|
|
infinite, this function does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-fold))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-fold%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-fold</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">i</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">i</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Folds <span class="RktVar">f</span> over each element of <span class="RktVar">s</span> with <span class="RktVar">i</span> as
|
||
|
|
the initial accumulator. If <span class="RktVar">s</span> is infinite, this function
|
||
|
|
does not terminate. The <span class="RktVar">f</span> function takes the accumulator as
|
||
|
|
its first argument and the next sequence element as its second.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-count))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-count%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-count</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29" class="RktValLink" data-pltdoc="x">exact-nonnegative-integer?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="procedures.html#%28def._%28%28quote._~23~25kernel%29._procedure~3f%29%29" class="RktValLink" data-pltdoc="x">procedure?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns the number of elements in <span class="RktVar">s</span> for which <span class="RktVar">f</span>
|
||
|
|
returns a true result. If <span class="RktVar">s</span> is infinite, this function
|
||
|
|
does not terminate.</div></p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-filter))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-filter%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-filter</a></span></span><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span><span class="RktVar">s</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">f</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29" class="RktStxLink" data-pltdoc="x">...</a></span><span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence whose elements are the elements of <span class="RktVar">s</span> for
|
||
|
|
which <span class="RktVar">f</span> returns a true result. Although the new sequence
|
||
|
|
is constructed lazily, if <span class="RktVar">s</span> has an infinite number of
|
||
|
|
elements where <span class="RktVar">f</span> returns a false result in between two
|
||
|
|
elements where <span class="RktVar">f</span> returns a true result, then operations on
|
||
|
|
this sequence will not terminate during the infinite sub-sequence.</div></p><p>If <span class="RktVar">s</span> is a <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>, then the result is also a
|
||
|
|
<a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._sequence-add-between))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-add-between%29%29" class="RktValDef RktValLink" data-pltdoc="x">sequence-add-between</a></span></span><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span><span class="RktVar">e</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">s</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">e</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence whose elements are the elements of <span class="RktVar">s</span>,
|
||
|
|
but with <span class="RktVar">e</span> between each pair of elements in <span class="RktVar">s</span>.
|
||
|
|
The new sequence is constructed lazily.</div></p><p>If <span class="RktVar">s</span> is a <a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>, then the result is also a
|
||
|
|
<a href="streams.html#%28tech._stream%29" class="techoutside" data-pltdoc="x"><span class="techinside">stream</span></a>.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="let.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._let%2A%29%29" class="RktStxLink" data-pltdoc="x">let*</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">all-reds</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-cycle%29%29" class="RktValLink" data-pltdoc="x">in-cycle</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">"red"</span><span class="RktVal">)</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">red-and-blues</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-add-between%29%29" class="RktValLink" data-pltdoc="x">sequence-add-between</a></span><span class="hspace"> </span><span class="RktSym">all-reds</span><span class="hspace"> </span><span class="RktVal">"blue"</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">n</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">10</span><span class="RktPn">)</span><span class="RktPn">]</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">[</span><span class="RktSym">elt</span><span class="hspace"> </span><span class="RktSym">red-and-blues</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym">elt</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'("red" "blue" "red" "blue" "red" "blue" "red" "blue" "red" "blue")</span></p></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">text</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence-add-between%29%29" class="RktValLink" data-pltdoc="x">sequence-add-between</a></span><span class="hspace"> </span><span class="RktVal">'</span><span class="RktVal">(</span><span class="RktVal">"veni"</span><span class="hspace"> </span><span class="RktVal">"vidi"</s
|
||
|
|
obligating it to produce elements with as many values as there are <span class="RktVar">elem/c</span> contracts,
|
||
|
|
and obligating each value to satisfy the corresponding <span class="RktVar">elem/c</span>. The
|
||
|
|
result is not guaranteed to be the same kind of sequence as the original value;
|
||
|
|
for instance, a wrapped list is not guaranteed to satisfy <span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list~3f%29%29" class="RktValLink" data-pltdoc="x">list?</a></span>.</div></p><p>If <span class="RktVar">min-count</span> is a number, the stream is required to have at least that many elements in it.</p><p><div class="SIntrapara">Examples:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="attaching-contracts-to-values.html#%28form._%28%28lib._racket%2Fcontract%2Fregion..rkt%29._define%2Fcontract%29%29" class="RktStxLink" data-pltdoc="x">define/contract</a></span><span class="hspace"> </span><span class="RktSym">predicates</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._sequence%2Fc%29%29" class="RktValLink" data-pltdoc="x">sequence/c</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29" class="RktStxLink" data-pltdoc="x"><span class="nobreak">-></span></a></span><span class="hspace"> </span><span class="RktSym"><a href="data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29" class="RktValLink" data-pltdoc="x">any/c</a></span><span class="hspace"> </span><span class="RktSym"><a href="booleans.html#%28def._%28%28quote._~23~25kernel%29._boolean~3f%29%29" class="RktValLink" data-pltdoc="x">boolean?</a></span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-list%29%29" class="RktValLink" data-pltdoc="x">in-list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="pairs.html#%28def._%28%28quote._~23~25kernel%29._list%29%29" class="RktValLink" data-pltdoc="x">list</a></span><span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._integer~3f%29%29" class="RktValLink" data-pltdoc="x">integer?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym"><a href="symbols.html#%28def._%28%28quote._~23~25kernel%29._string-~3esymbol%29%29" class="RktValLink" data-pltdoc="x">string->symbol</a></span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">P</span><span class="hspace"> </span><span class="RktSym">predicates</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="Writing.html#%28def._%28%28quote._~23~25kernel%29._printf%29%29" class="RktValLink" data-pltdoc="x">printf</a></span><span class="hspace"> </span><span class="RktVal">"~s\n"</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym">P</span><span class="hspace"> </span><span class="RktVal">"cat"</s
|
||
|
|
<span class="RktVar">stx</span>.
|
||
|
|
Equivalent to <span class="RktPn">(</span><span class="RktSym"><a href="https://download.racket-lang.org/releases/8.6/doc/local-redirect/index.html?doc=syntax&rel=syntax-helpers.html%23%2528def._%2528%2528lib._syntax%252Fstx..rkt%2529._stx-%7E3elist%2529%2529&version=8.6" class="RktValLink Sq" data-pltdoc="x">stx->list</a></span><span class="stt"> </span><span class="RktSym">lst</span><span class="RktPn">)</span>.
|
||
|
|
</div><div class="SIntrapara">An <span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._in-syntax%29%29" class="RktValLink" data-pltdoc="x">in-syntax</a></span> application can provide better performance for syntax iteration when it appears directly in a <span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29" class="RktStxLink" data-pltdoc="x">for</a></span> clause.</div></p><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">x</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._in-syntax%29%29" class="RktValLink" data-pltdoc="x">in-syntax</a></span><span class="hspace"> </span><span class="RktRdr">#'</span><span class="RktPn">(</span><span class="RktVal">1</span><span class="hspace"> </span><span class="RktVal">2</span><span class="hspace"> </span><span class="RktVal">3</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span></td></tr><tr><td><span class="hspace"> </span><span class="hspace"> </span><span class="RktSym">x</span><span class="RktPn">)</span></td></tr></table></td></tr><tr><td><p><span class="RktRes">'(#<syntax:eval:61:0 1> #<syntax:eval:61:0 2> #<syntax:eval:61:0 3>)</span></p></td></tr></table></blockquote></div></p><p class="SHistory">Added in version 6.3 of package <span class="stt">base</span>.</p><p><div class="SIntrapara"><blockquote class="SVInsetFlow"><table cellspacing="0" cellpadding="0" class="boxed RBoxed"><tr><td><blockquote class="SubFlow"><div class="RBackgroundLabel SIEHidden"><div class="RBackgroundLabelInner"><p>procedure</p></div></div><p class="RForeground"><span class="RktPn">(</span><a name="(def._((lib._racket/sequence..rkt)._in-slice))"></a><span title="Provided from: racket/sequence, racket | Package: base"><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._in-slice%29%29" class="RktValDef RktValLink" data-pltdoc="x">in-slice</a></span></span><span class="hspace"> </span><span class="RktVar">length</span><span class="hspace"> </span><span class="RktVar">seq</span><span class="RktPn">)</span><span class="hspace"> </span>→<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></p></blockquote></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">length</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-positive-integer~3f%29%29" class="RktValLink" data-pltdoc="x">exact-positive-integer?</a></span></td></tr><tr><td><span class="hspace"> </span><span class="RktVar">seq</span><span class="hspace"> </span>:<span class="hspace"> </span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence~3f%29%29" class="RktValLink" data-pltdoc="x">sequence?</a></span></td></tr></table></blockquote></div><div class="SIntrapara">Returns a sequence whose elements are lists with the first <span class="RktVar">length</span>
|
||
|
|
elements of <span class="RktVar">seq</span>, then the next <span class="RktVar">length</span> and so on.</div></p><p><div class="SIntrapara"><p><div class="SIntrapara">Example:</div><div class="SIntrapara"><blockquote class="SCodeFlow"><table cellspacing="0" cellpadding="0" class="RktBlk"><tr><td><span class="stt">> </span><span class="RktPn">(</span><span class="RktSym"><a href="for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Flist%29%29" class="RktStxLink" data-pltdoc="x">for/list</a></span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktPn">[</span><span class="RktSym">e</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fsequence..rkt%29._in-slice%29%29" class="RktValLink" data-pltdoc="x">in-slice</a></span><span class="hspace"> </span><span class="RktVal">3</span><span class="hspace"> </span><span class="RktPn">(</span><span class="RktSym"><a href="sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29" class="RktValLink" data-pltdoc="x">in-range</a></span><span class="hspace"> </span><span class="RktVal">8</span><span class="RktPn">)</span><span class="RktPn">)</span><span class="RktPn">]</span><span class="RktPn">)</span><span class="hspace"> </span><span class="RktSym">e</span><span class="RktPn">)</span></td></tr><tr><td><p><span class="RktRes">'((0 1 2) (3 4 5) (6 7))</span></p></td></tr></table></blockquote></div></p></div><div class="SIntrapara"><p class="SHistory">Added in version 6.3 of package <span class="stt">base</span>.</p></div></p><div class="navsetbottom"><span class="navleft"><form class="searchform"><input class="searchbox" id="searchbox" type="text" tabindex="1" placeholder="...search manuals..." title="Enter a search string to search the manuals" onkeypress="return DoSearchKey(event, this, "8.6", "../");"/></form> <a href="https://docs.racket-lang.org/index.html" title="up to the documentation top" data-pltdoc="x" onclick="return GotoPLTRoot("8.6");">top</a><span class="tocsettoggle"> <a href="javascript:void(0);" title="show/hide table of contents" onclick="TocsetToggle();">contents</a></span></span><span class="navright"> <a href="sequences_streams.html" title="backward to "4.16 Sequences and Streams"" data-pltdoc="x">← prev</a> <a href="sequences_streams.html" title="up to "4.16 Sequences and Streams"" data-pltdoc="x">up</a> <a href="streams.html" title="forward to "4.16.2 Streams"" data-pltdoc="x">next →</a></span> </div></div></div><div id="contextindicator"> </div></body></html>
|