forked from scheme-requests-for-implementation/srfi-common
-
Notifications
You must be signed in to change notification settings - Fork 0
/
index.html
2698 lines (2662 loc) · 313 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Scheme Requests for Implementation</title>
<link rel="preload" href="srfi.js" as="script">
<link href="favicon.png" rel="icon" sizes="192x192" type="image/png">
<link rel="stylesheet" type="text/css" href="admin.css">
<link rel="stylesheet" type="text/css" href="home.css">
<link rel="stylesheet" type="text/css" href="list.css">
<link rel="alternate" type="application/rss+xml" href="/srfi.rss">
<meta name="viewport" content="width=device-width, initial-scale=1">
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}
});
</script>
<script crossorigin="anonymous" integrity=
"sha384-Ra6zh6uYMmH5ydwCqqMoykyf1T/+ZcnOQfFPhDrp2kI4OIxadnhsvvA2vv9A7xYv" src=
"https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script></head>
<body>
<h1><img class="srfi-logo" src="srfi-logo.svg" alt="SRFI surfboard logo" />Scheme Requests for Implementation</h1>
<p class="hide">SRFIs extend the Scheme programming language. You
can help. <a href="about.html">Learn more</a>.</p>
<p>Thanks to Shiro Kawai for his <a href="https://practical-scheme.net/">Practical Scheme</a>,
which includes a <a href="https://practical-scheme.net/wiliki/schemexref.cgi?SRFI">cross-reference</a>
showing which Scheme implementations support which SRFIs. It's
a wiki page, so please help keep it up to date.</p>
<h2>The SRFIs</h2>
<noscript><p>Javascript is not enabled in your browser, so
filtering, searching, and sorting the list of SRFIs is turned
off.</p></noscript>
<div id="srfis">
<div class="invisible" id="parameters">
<div>
<span>Search for</span>
<input class="search" id="search" placeholder="numbers or words" tabindex="1" /></div>
<div>
<span>Filter by </span>
<div class="dropdown" id="keywords">
<button class="controls">keywords<span> ×</span></button>
<div class="options">
<select multiple size="35">
<option selected value="any">any</option>
<option value="algorithm">Algorithm</option>
<option value="assignment">Assignment</option>
<option value="binding">Binding</option>
<option value="comparison">Comparison</option>
<option value="concurrency">Concurrency</option>
<option value="continuations">Continuations</option>
<option value="control-flow">Control Flow</option>
<option value="data-structure">Data Structure</option>
<option value="error-handling">Error Handling</option>
<option value="exceptions">Exceptions</option>
<option value="features">Features</option>
<option value="i/o">I/O</option>
<option value="internationalization">Internationalization</option>
<option value="introspection">Introspection</option>
<option value="lazy-evaluation">Lazy Evaluation</option>
<option value="miscellaneous">Miscellaneous</option>
<option value="modules">Modules</option>
<option value="multiple-value-returns">Multiple-Value Returns</option>
<option value="numbers">Numbers</option>
<option value="operating-system">Operating System</option>
<option value="optimization">Optimization</option>
<option value="parameters">Parameters</option>
<option value="pattern-matching">Pattern Matching</option>
<option value="r6rs-process">R6RS process</option>
<option value="r7rs-large">R7RS Large</option>
<option value="r7rs-large-red">R7RS Large: Red Edition</option>
<option value="r7rs-large-tangerine">R7RS Large: Tangerine Edition</option>
<option value="randomness">Randomness</option>
<option value="reader-syntax">Reader Syntax</option>
<option value="sicp">SICP</option>
<option value="superseded">Superseded</option>
<option value="syntax">Syntax</option>
<option value="testing">Testing</option>
<option value="type-checking">Type Checking</option></select></div>
<span class="chosen"></span></div>
<div class="dropdown" id="statuses">
<button class="controls">status<span> ×</span></button>
<div class="options">
<select multiple size="4">
<option selected value="any">any</option>
<option value="draft">Draft</option>
<option value="final">Final</option>
<option value="withdrawn">Withdrawn</option></select></div>
<span class="chosen"></span></div></div>
<div>
<span>Show</span>
<label class="checkbox-label controls">
<input class="controls" id="abstracts-control" tabindex="7" type="checkbox">
abstracts</label></div>
<div>
<span>Sort by</span>
<button class="controls sort" data-sort="authors" tabindex="2" >authors</button>
<button class="controls sort" data-sort="date" tabindex="3" >date</button>
<button class="controls sort" data-sort="name" tabindex="4" >name</button>
<button class="controls sort" data-sort="number" tabindex="5" >number</button>
<button class="controls sort" data-sort="status" tabindex="6" >status</button></div></div>
<ul class="summary list">
<li class="card final"><a class="card-anchor" href="srfi-232/"></a><a href="srfi-232/"><span class="number">232</span></a>: <span class="name">Flexible curried procedures</span><span class="authors">, by Wolfgang Corcoran-Mathe</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2022-04-06</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-26/">SRFI 26: Notation for Specializing Parameters without Currying</a> and <a href="/srfi-219/">SRFI 219: Define higher-order lambda</a>.</span><div class="abstract"><p>Scheme lacks a flexible way to create and apply curried procedures.
This SRFI describes <code>curried</code>, a variant of
<code>lambda</code> that creates true curried procedures which also
behave just like ordinary Scheme procedures. They can be applied to
their arguments one by one, all at once, or anywhere in between,
without any novel syntax. <code>curried</code> also supports
nullary and variadic procedures, and procedures created with it have
predictable behavior when applied to surplus arguments.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-231/"></a><a href="srfi-231/"><span class="number">231</span></a>: <span class="name">Intervals and Generalized Arrays (Updated^2)</span><span class="authors">, by Bradley J. Lucier</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2022-01-07</span></span><span class="keywords" data-keywords="data-structure,numbers">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a></span><span class="status" data-status="draft"></span><span class="see-also">See also <a href="/srfi-122/">SRFI 122: Nonempty Intervals and Generalized Arrays</a>, <a href="/srfi-164/">SRFI 164: Enhanced multi-dimensional Arrays</a>, and <a href="/srfi-179/">SRFI 179: Nonempty Intervals and Generalized Arrays (Updated)</a>.</span><div class="abstract"> <p>This SRFI specifies an array mechanism for Scheme. Arrays as defined here are quite general; at their most basic, an array is simply a mapping, or function, from multi-indices of exact integers $i_0,\ldots,i_{d-1}$ to Scheme values. The set of multi-indices $i_0,\ldots,i_{d-1}$ that are valid for a given array form the <i>domain</i> of the array. In this SRFI, each array's domain consists of the cross product of nonempty intervals of exact integers $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$ of $\mathbb Z^d$, $d$-tuples of integers. Thus, we introduce a data type called $d$-<i>intervals</i>, or more briefly <i>intervals</i>, that encapsulates this notion. (We borrow this terminology from, e.g., Elias Zakon's <a href="http://www.trillia.com/zakon1.html">Basic Concepts of Mathematics</a>.) Specialized variants of arrays provide portable programs with efficient representations for common use cases.</p>
<p>This is a revised version of <a href="https://srfi.schemers.org/srfi-179/">SRFI 179</a>.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-230/"></a><a href="srfi-230/"><span class="number">230</span></a>: <span class="name">Atomic Operations</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-11-15</span></span><span class="keywords" data-keywords="concurrency">Keywords: <a href="https://srfi.schemers.org/?keywords=concurrency">Concurrency</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-18/">SRFI 18: Multithreading support</a> and <a href="/srfi-226/">SRFI 226: Control Features</a>.</span><div class="abstract"> <p>This SRFI defines atomic operations for the Scheme programming language.
An <dfn>atomic operation</dfn> is an operation that, even in the presence
of multiple threads, is either executed completely or not at all. Atomic
operations can be used to implement mutexes and other synchronization
primitives, and they can be used to make concurrent algorithms lock-free.
For this, this SRFI defines two data types, <dfn>atomic flags</dfn>
and <dfn>atomic (fixnum) boxes</dfn>, whose contents can be queried and
mutated atomically. Moreover, each atomic operation comes with
a <dfn>memory order</dfn> that defines the level of synchronization with
other threads.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-229/"></a><a href="srfi-229/"><span class="number">229</span></a>: <span class="name">Tagged Procedures</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-11-15</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI defines <dfn>tagged procedures</dfn>, which are procedures
that are tagged with a Scheme value when created through the
syntax <code>lambda/tag</code> and <code>case-lambda/tag</code>. The
value of the tag of a procedure can be retrieved
with <code>procedure-tag</code>, and the
predicate <code>procedure/tag?</code> discerns whether a procedure is
tagged.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-228/"></a><a href="srfi-228/"><span class="number">228</span></a>: <span class="name">A further comparator library</span><span class="authors">, by Daphne Preston-Kendal</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2021-08-28</span></span><span class="keywords" data-keywords="comparison">Keywords: <a href="https://srfi.schemers.org/?keywords=comparison">Comparison</a></span><span class="status" data-status="draft"></span><div class="abstract"><p>Further procedures and syntax forms for defining <a href="https://srfi.schemers.org/srfi-128/srfi-128.html">SRFI 128</a> comparators, and for extracting comparison procedures similar to those defined for Scheme’s built-in types using them.
<p>Best enjoyed in combination with <a href="https://srfi.schemers.org/srfi-162/srfi-162.html">SRFI 162</a>.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-227/"></a><a href="srfi-227/"><span class="number">227</span></a>: <span class="name">Optional Arguments</span><span class="authors">, by Marc Nieper-Wißkirchen (spec and R6RS implementation) and Daphne Preston-Kendal (R7RS implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-11-16</span></span><span class="keywords" data-keywords="binding">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-89/">SRFI 89: Optional positional and named parameters</a>.</span><div class="abstract"> <p>This SRFI specifies the <code>opt-lambda</code> syntax, which
generalizes <code>lambda</code>. An <code>opt-lambda</code> expression
evaluates to a procedure that takes a number of required and a number of
optional (positional) arguments whose default values are determined by
evaluating corresponding expressions when the procedure is called.</p>
<p>This SRFI also specifies a variation <code>opt*-lambda</code>, which is
to <code>opt-lambda</code> as <code>let*</code> is to <code>let</code>
and the related binding constructs <code>let-optionals</code>
and <code>let-optionals*</code>.</p>
<p>Finally, for those who prefer less explicit procedure
definitions, a sublibrary provides <code>define-optionals</code>
and <code>define-optionals*</code>.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-226/"></a><a href="srfi-226/"><span class="number">226</span></a>: <span class="name">Control Features</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2021-08-06</span></span><span class="keywords" data-keywords="continuations,control-flow">Keywords: <a href="https://srfi.schemers.org/?keywords=continuations">Continuations</a>, <a href="https://srfi.schemers.org/?keywords=control-flow">Control Flow</a></span><span class="status" data-status="draft"></span><span class="see-also">See also <a href="/srfi-18/">SRFI 18: Multithreading support</a>, <a href="/srfi-34/">SRFI 34: Exception Handling for Programs</a>, <a href="/srfi-39/">SRFI 39: Parameter objects</a>, <a href="/srfi-45/">SRFI 45: Primitives for Expressing Iterative Lazy Algorithms</a>, <a href="/srfi-97/">SRFI 97: SRFI Libraries</a>, <a href="/srfi-154/">SRFI 154: First-class dynamic extents</a>, <a href="/srfi-155/">SRFI 155: Promises</a>, <a href="/srfi-157/">SRFI 157: Continuation marks</a>, and <a href="/srfi-158/">SRFI 158: Generators and Accumulators</a>.</span><div class="abstract"> <p>This SRFI defines a rich set of control operators for the
Scheme programming language, including the
venerable <code>call/cc</code>
(<code>call-with-current-continuation</code>). The set of
operators was highly influenced by the control operators provided
by <a href="https://racket-lang.org/"><cite>Racket</cite></a>.
<p>Continuations can be delimited by continuation prompts, and all
continuations become delimited continuations, at the latest by
the default prompt at the start of each thread. Moreover,
continuations are divided into composable and non-composable
continuations, which can be captured and reinstated.</p>
<p>To investigate continuations, this SRFI supports continuation
marks and offers operators to set and retrieve them.</p>
<p>Moreover, this SRFI defines clear semantics of
exceptions, parameter objects, promises, and threads consistent
with the other concepts defined here.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-225/"></a><a href="srfi-225/"><span class="number">225</span></a>: <span class="name">Dictionaries</span><span class="authors">, by John Cowan (spec) and Arvydas Silanskas (implementation)</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2021-06-26</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="draft"></span><span class="see-also">See also <a href="/srfi-146/">SRFI 146: Mappings</a> and <a href="/srfi-167/">SRFI 167: Ordered Key Value Store</a>.</span><div class="abstract"><p>The procedures of this SRFI allow callers to manipulate an object that maps keys to values
without the caller needing to know exactly what the type of the object is.
However, what procedures can be called on the object is partly determined by whether it is pure.
Such an object is called a <em>dict(ionary)</em> in this SRFI.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-224/"></a><a href="srfi-224/"><span class="number">224</span></a>: <span class="name">Integer Mappings</span><span class="authors">, by Wolfgang Corcoran-Mathe</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-06-30</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-146/">SRFI 146: Mappings</a> and <a href="/srfi-189/">SRFI 189: Maybe and Either: optional container types</a>.</span><div class="abstract"><p>Integer maps, or <em>fxmappings</em>, are finite sets, where each element is
an association between a fixnum (exact integer) key and an arbitrary Scheme
object. They are similar to the general mappings of
<a href="https://srfi.schemers.org/srfi-146/">SRFI
146</a>, but the restricted key-type allows implementations of
fxmappings to benefit from optimized structures and algorithms. This
library provides a rich set of operations on fxmappings, including
analogues of most of the forms provided by SRFI 146. Fxmappings have
no intrinsic order, but may be treated as ordered sets, using the
natural ordering on keys; a substantial sublibrary for working with
fxmappings in this fashion is included.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-223/"></a><a href="srfi-223/"><span class="number">223</span></a>: <span class="name">Generalized binary search procedures</span><span class="authors">, by Daphne Preston-Kendal</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-07-27</span></span><span class="keywords" data-keywords="miscellaneous">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-43/">SRFI 43: Vector library</a> and <a href="/srfi-133/">SRFI 133: Vector Library (R7RS-compatible)</a>.</span><div class="abstract"><p>Generalized procedures for binary search of vector-like data structures are provided which can be applied to any sequence type, including ones defined by the user, together with applications of these procedures for Scheme’s built-in vectors.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-222/"></a><a href="srfi-222/"><span class="number">222</span></a>: <span class="name">Compound Objects</span><span class="authors">, by John Cowan (text) and Arvydas Silanskas (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-07-20</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"><p>Compound objects are analogous to R6RS compound conditions,
and are suitable for use in creating and handling conditions
on non-R6RS systems, among other purposes.
They encapsulate an immutable sequence of subobjects, which can be
any object except another compound object.
It is possible to implement R6RS compound conditions on top of
compound objects, but not vice versa.
Note that this SRFI does not provide any analogue to R6RS
<i>simple</i> conditions, which are just records.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-221/"></a><a href="srfi-221/"><span class="number">221</span></a>: <span class="name">Generator/accumulator sub-library</span><span class="authors">, by John Cowan (text) and Arvydas Silanskas (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-05-28</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-158/">SRFI 158: Generators and Accumulators</a>.</span><div class="abstract"><p>This is a set of convenience routines for generators and accumulators
intended to blend in with
<a href="https://srfi.schemers.org/srfi-158/srfi-158.html">SRFI 158</a>.
The authors recommend that they be added to the
<code>(srfi 158)</code> library provided by
users or implementations.
If they are approved by the R7RS-large process,
they can also be added to <code>(r7rs generator)</code>.</div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-220/"></a><a href="srfi-220/"><span class="number">220</span></a>: <span class="name">Line directives</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2021-04-20</span></span><span class="keywords" data-keywords="reader-syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=reader-syntax">Reader Syntax</a></span><span class="status" data-status="withdrawn"></span><div class="abstract"> <p>Many language-agnostic programming tools rely on specially
formatted source code comments to annotate the code with
metadata. Such "magic comments" are hard for both humans and
computers to parse reliably, as the purpose of a comment is to be
free-form text that is not interpreted by machine.</p>
<p>This SRFI extends the standard Scheme directive syntax
(<code>#!</code>) to support <em>line directives</em>. They look
like magic comments to language-agnostic tools but read as
S-expressions in Scheme, combining the portability of magic
comments with the well-defined syntax and easy parsing of
ordinary Scheme code.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-219/"></a><a href="srfi-219/"><span class="number">219</span></a>: <span class="name">Define higher-order lambda</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-04-04</span></span><span class="keywords" data-keywords="binding,syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-201/">SRFI 201: Syntactic Extensions to the Core Scheme Bindings</a> and <a href="/srfi-232/">SRFI 232: Flexible curried procedures</a>.</span><div class="abstract"><p>This SRFI codifies the following shorthand syntax, which some
Scheme implementations have had for a long time.</p>
<pre>(define ((outer-name outer-args ...) inner-args ...)
inner-body ...)</pre></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-218/"></a><a href="srfi-218/"><span class="number">218</span></a>: <span class="name">Unicode Numerals</span><span class="authors">, by John Cowan (text) and Arvydas Silanskas (implementation)</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2021-01-30</span></span><span class="keywords" data-keywords="internationalization">Keywords: <a href="https://srfi.schemers.org/?keywords=internationalization">Internationalization</a></span><span class="status" data-status="withdrawn"></span><div class="abstract"><p>These procedures allow the creation and interpretation of numerals
using any set of Unicode digits that support positional notation.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-217/"></a><a href="srfi-217/"><span class="number">217</span></a>: <span class="name">Integer Sets</span><span class="authors">, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-02-15</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-113/">SRFI 113: Sets and bags</a>.</span><div class="abstract"><p>Integer sets, or <em>iset</em>s, are unordered collections of
fixnums. (Fixnums are exact integers within certain
implementation-specified bounds.)</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-216/"></a><a href="srfi-216/"><span class="number">216</span></a>: <span class="name">SICP Prerequisites (Portable)</span><span class="authors">, by Vladimir Nikishkin</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-01-21</span></span><span class="keywords" data-keywords="sicp">Keywords: <a href="https://srfi.schemers.org/?keywords=sicp">SICP</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-203/">SRFI 203: A Simple Picture Language in the Style of SICP</a>.</span><div class="abstract"><p>
This SRFI follows
<a href="https://srfi.schemers.org/srfi-203/">
SRFI 203
</a>
in providing "out-of-the-box" support for hosting the exercises suggested by
<a href="https://mitpress.mit.edu/sites/default/files/sicp/index.html">
Structure and Interpretation of Computer Programs
</a>
in portable Scheme.
</p>
<p>
Whereas SRFI 203 focused on the necessarily non-portable aspects of the problem set (the graphics), this SRFI aims to provide support for the rest of the features, which are far more widespread, often already provided, and in reality mostly need just a common vocabulary.
</p>
<p>
This SRFI provides procedures for working with time data, multi-threading, and streams, as well as SICP names for <code>true</code> and <code>false</code>.
</p>
<p>
None of these procedures is fit for production use. They are only designed for pedagogical purposes.
</p>
<p>
Students, however, are expected to be able to just write</p>
<pre>
(include (srfi sicp))</pre>
<p>and have the code from the book run without problems (apart from those intended by the book authors).
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-215/"></a><a href="srfi-215/"><span class="number">215</span></a>: <span class="name">Central Log Exchange</span><span class="authors">, by Göran Weinholt</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-01-11</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>
This SRFI specifies a central log exchange for Scheme that
connects log producers with log consumers. It allows multiple
logging systems to interoperate and co-exist in the same
program. Library code can produce log messages without knowledge
of which log system is actually used. Simple applications can
easily get logs on standard output, while more advanced
applications can send them to a full logging system.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-214/"></a><a href="srfi-214/"><span class="number">214</span></a>: <span class="name">Flexvectors</span><span class="authors">, by Adam Nelson</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-03-18</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-117/">SRFI 117: Queues based on lists</a>, <a href="/srfi-125/">SRFI 125: Intermediate hash tables</a>, <a href="/srfi-133/">SRFI 133: Vector Library (R7RS-compatible)</a>, <a href="/srfi-134/">SRFI 134: Immutable Deques</a>, and <a href="/srfi-158/">SRFI 158: Generators and Accumulators</a>.</span><div class="abstract"><p>A <em>flexvector</em>, also known as a dynamic array or an arraylist, is a mutable vector-like data structure with an adjustable size. Flexvectors allow fast random access and fast insertion/removal at the end. This SRFI defines a suite of operations on flexvectors, modeled after <a href="https://srfi.schemers.org/srfi-133/srfi-133.html">SRFI 133</a>'s vector operations.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-213/"></a><a href="srfi-213/"><span class="number">213</span></a>: <span class="name">Identifier Properties</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-03-21</span></span><span class="keywords" data-keywords="binding,syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"><p>Using the <code>define-property</code> definition described in
this SRFI, expand-time properties can be associated with
identifiers in a referentially transparent and lexically scoped way.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-212/"></a><a href="srfi-212/"><span class="number">212</span></a>: <span class="name">Aliases</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-02-12</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This SRFI introduces <em>alias definitions</em>, a syntactic
extension. An alias definition transfers the binding of one
identifier to another, effectively aliasing the identifier.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-211/"></a><a href="srfi-211/"><span class="number">211</span></a>: <span class="name">Scheme Macro Libraries</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2020-09-12</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="draft"></span><div class="abstract"><p>This SRFI describes common syntactic extensions of the <code>syntax-rules</code> macro facility of R5RS and the base R6RS and R7RS libraries. In particular,
library namespaces are defined where these extensions can be located
and which can be tested against in <code>cond-expand</code> forms.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-210/"></a><a href="srfi-210/"><span class="number">210</span></a>: <span class="name">Procedures and Syntax for Multiple Values</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-02-12</span></span><span class="keywords" data-keywords="binding,multiple-value-returns">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=multiple-value-returns">Multiple-Value Returns</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-8/">SRFI 8: receive: Binding to multiple values</a>, <a href="/srfi-11/">SRFI 11: Syntax for receiving multiple values</a>, and <a href="/srfi-71/">SRFI 71: Extended LET-syntax for multiple values</a>.</span><div class="abstract"><p>
This SRFI extends the Scheme standard with procedures and syntax
dealing with multiple values, including syntax to create lists and
vectors from expressions returning multiple values and procedures
returning the elements of a list or vector as multiple values.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-209/"></a><a href="srfi-209/"><span class="number">209</span></a>: <span class="name">Enums and Enum Sets</span><span class="authors">, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-12-17</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"><p>Enums are objects that serve to form sets of distinct classes
that specify different modes of operation for a procedure.
Their use fosters portable and readable code.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-208/"></a><a href="srfi-208/"><span class="number">208</span></a>: <span class="name">NaN procedures</span><span class="authors">, by Emmanuel Medernach (design), John Cowan (editor), and Wolfgang Corcoran-Mathe (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-02-23</span></span><span class="keywords" data-keywords="data-structure,numbers">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This SRFI provides procedures that dissect NaN (Not a Number) inexact values.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-207/"></a><a href="srfi-207/"><span class="number">207</span></a>: <span class="name">String-notated bytevectors</span><span class="authors">, by Daphne Preston-Kendal (external notation), John Cowan (procedure design), and Wolfgang Corcoran-Mathe (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-10-29</span></span><span class="keywords" data-keywords="reader-syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=reader-syntax">Reader Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"><p>To ease the human reading and writing of Scheme code involving
binary data that for mnemonic reasons corresponds
as a whole or in part to ASCII-coded text, a notation
for bytevectors is defined which allows printable ASCII characters
to be used literally without being converted to their corresponding
integer forms. In addition, this SRFI provides a set of procedures
known as the bytestring library
for constructing a bytevector from a sequence of integers,
characters, strings, and/or bytevectors, and for manipulating
bytevectors as if they were strings as far as possible.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-206/"></a><a href="srfi-206/"><span class="number">206</span></a>: <span class="name">Auxiliary Syntax Keywords</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-12-21</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-139/">SRFI 139: Syntax parameters</a> and <a href="/srfi-213/">SRFI 213: Identifier Properties</a>.</span><div class="abstract">This SRFI defines a mechanism for defining auxiliary syntax
keywords independently in different modules in such a way that
they still have the same binding so that they can be used
interchangeably as literal identifiers in
<code>syntax-rules</code> and <code>syntax-case</code> expressions
and can be both imported under the same name without conflicts.</div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-205/"></a><a href="srfi-205/"><span class="number">205</span></a>: <span class="name">POSIX Terminal Fundamentals</span><span class="authors">, by John Cowan and Harold Ancell</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2022-03-21</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-170/">SRFI 170: POSIX API</a> and <a href="/srfi-198/">SRFI 198: Foreign Interface Status</a>.</span><div class="abstract"><p>
This SRFI describes procedures for command-line and terminal interface
programs to safely change and reset terminal modes, for example from
cooked to raw and back, and for serial-line device manipulation for
interfacing with embedded hardware and the like.
</p>
<p>
It is intended to provide all the
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/termios.h.html">termios structure</a>
functionality a modern Scheme programmer might desire by supplying a
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/utilities/stty.html">stty</a>
procedure, and simple abstractions on top of it.
</p>
</div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-204/"></a><a href="srfi-204/"><span class="number">204</span></a>: <span class="name">Wright-Cartwright-Shinn Pattern Matcher</span><span class="authors">, by Felix Thibault</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2022-02-02</span></span><span class="keywords" data-keywords="pattern-matching">Keywords: <a href="https://srfi.schemers.org/?keywords=pattern-matching">Pattern Matching</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-200/">SRFI 200: Pattern Matching</a> and <a href="/srfi-201/">SRFI 201: Syntactic Extensions to the Core Scheme Bindings</a>.</span><div class="abstract"><p>Pattern matching decomposes a compound data structure
into parts and assigns those parts to variables. This
SRFI describes a pattern-matching library already in use by
several scheme implementations which can match many common
compound data structures.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-203/"></a><a href="srfi-203/"><span class="number">203</span></a>: <span class="name">A Simple Picture Language in the Style of SICP</span><span class="authors">, by Vladimir Nikishkin</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-09-17</span></span><span class="keywords" data-keywords="sicp">Keywords: <a href="https://srfi.schemers.org/?keywords=sicp">SICP</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-216/">SRFI 216: SICP Prerequisites (Portable)</a>.</span><div class="abstract"><p>This SRFI proposes a simple library for programmatic drawing of
pictures compatible with Section 2.2.4 of <cite>Structure and
Interpretation of Computer Programs</cite>.</p>
<p>It aims to close the gap between the Scheme suggested for study in
the book and portable Scheme.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-202/"></a><a href="srfi-202/"><span class="number">202</span></a>: <span class="name">Pattern-matching Variant of the and-let* Form that Supports Multiple Values</span><span class="authors">, by Panicz Maciej Godek</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-11-28</span></span><span class="keywords" data-keywords="binding,control-flow,pattern-matching">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=control-flow">Control Flow</a>, <a href="https://srfi.schemers.org/?keywords=pattern-matching">Pattern Matching</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-2/">SRFI 2: AND-LET*: an AND with local bindings, a guarded LET* special form</a> and <a href="/srfi-200/">SRFI 200: Pattern Matching</a>.</span><div class="abstract"><p>The SRFI-2 library introduced the <code>and-let*</code> form
for short-circuited evaluation in the style of the <code>and</code>
form, with the ability to capture the (non-<code>#f</code>) results
in the style of the <code>let*</code> form. This document extends
the <code>and-let*</code> form with the ability to pattern-match (or
"destructurally bind") the values of evaluated expressions (where
the match failure causes short-circuiting rather than raising an
error) and the ability to handle multiple values (where only the
falsehood of the first value causes short-circuiting).
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-201/"></a><a href="srfi-201/"><span class="number">201</span></a>: <span class="name">Syntactic Extensions to the Core Scheme Bindings</span><span class="authors">, by Panicz Maciej Godek</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2021-01-13</span></span><span class="keywords" data-keywords="binding,pattern-matching,syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=pattern-matching">Pattern Matching</a>, <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-8/">SRFI 8: receive: Binding to multiple values</a>, <a href="/srfi-11/">SRFI 11: Syntax for receiving multiple values</a>, <a href="/srfi-71/">SRFI 71: Extended LET-syntax for multiple values</a>, <a href="/srfi-200/">SRFI 200: Pattern Matching</a>, and <a href="/srfi-219/">SRFI 219: Define higher-order lambda</a>.</span><div class="abstract"><p>This document describes a handful of syntactic extensions
to the core bindings of the Scheme programming language.
In particular, it proposes to extend the binding forms
<code>lambda</code>, <code>let</code>,
<code>let*</code> with pattern matching capabilities, to extend the forms <code>let</code>
and <code>or</code> with the ability
to handle multiple values, and to extend the form <code>define</code> with
the ability of defining "curried" functions.</p></div></li>
<li class="card draft"><a class="card-anchor" href="srfi-200/"></a><a href="srfi-200/"><span class="number">200</span></a>: <span class="name">Pattern Matching</span><span class="authors">, by Panicz Maciej Godek</span><span class="based-on"></span><span class="date-group">Draft: <span class="date">2020-06-25</span></span><span class="keywords" data-keywords="pattern-matching">Keywords: <a href="https://srfi.schemers.org/?keywords=pattern-matching">Pattern Matching</a></span><span class="status" data-status="draft"></span><div class="abstract"><p>This SRFI discusses some of the existing pattern-matching
libraries for the Scheme programming language — namely,
the pattern matcher presented by Andrew K. Wright and Robert
Cartwright in the paper "A Soft Type System for Scheme", the
pattern matcher developed by Dan Friedman, Erik Hilsdale and
Kent Dybvig, the <code>racket/match</code> module
distributed with the Racket programming environment, as well
as the Bigloo and Gerbil pattern matchers distributed with
their respective implementations.
It then extracts a pattern syntax which is compatible with three of
those implementations and provides extrinsic rationale for that
syntax.
It also provides a simple implementation of a pattern matcher
which conforms to the specification of a pattern language provided
in this document.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-199/"></a><a href="srfi-199/"><span class="number">199</span></a>: <span class="name">POSIX errno manipulation</span><span class="authors">, by Harold Ancell</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-07-19</span></span><span class="keywords" data-keywords="error-handling,operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=error-handling">Error Handling</a>, <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-170/">SRFI 170: POSIX API</a> and <a href="/srfi-198/">SRFI 198: Foreign Interface Status</a>.</span><div class="abstract"><p>The majority of P<small>OSIX</small> system and library calls
require accessing <code>errno</code> to discern the specific cause
of an error, and some require setting it to 0 before being called.
This SRFI specifies procedures to both retrieve its value, and to
set it.
</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-198/"></a><a href="srfi-198/"><span class="number">198</span></a>: <span class="name">Foreign Interface Status</span><span class="authors">, by John Cowan (editor and shepherd), Harold Ancell (implementer and editor), and Lassi Kortela (architect)</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-09-12</span></span><span class="keywords" data-keywords="error-handling,operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=error-handling">Error Handling</a>, <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-170/">SRFI 170: POSIX API</a>.</span><div class="abstract"><p>
This SRFI provides means to construct, return or signal, and extract
information from Scheme interfaces with "foreign" systems such as the
P<small>OSIX</small> API, databases, and libraries.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-197/"></a><a href="srfi-197/"><span class="number">197</span></a>: <span class="name">Pipeline Operators</span><span class="authors">, by Adam Nelson</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-09-12</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"><p>Many functional languages provide pipeline operators, like Clojure's <code>-></code> or OCaml's <code>|></code>. Pipelines are a simple, terse, and readable way to write deeply-nested expressions. This SRFI defines a family of <code>chain</code> and <code>nest</code> pipeline operators, which can rewrite nested expressions like <code>(a b (c d (e f g)))</code> as a sequence of operations: <code>(chain g (e f _) (c d _) (a b _))</code>.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-196/"></a><a href="srfi-196/"><span class="number">196</span></a>: <span class="name">Range Objects</span><span class="authors">, by John Cowan (text) and Wolfgang Corcoran-Mathe (sample implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-09-17</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-42/">SRFI 42: Eager Comprehensions</a>.</span><div class="abstract"><p>Ranges are collections somewhat similar to vectors, except that
they are immutable and have algorithmic representations instead of
the uniform per-element data structure of vectors. The storage required is
usually less than the size of the same collection stored in a
vector and the time needed to reference a particular element is
typically less for a range than for the same collection stored in a
list. This SRFI defines a large subset of the sequence operations
defined on lists, vectors, strings, and other collections. If
necessary, a range can be converted to a list, vector, or string of
its elements or a generator that will lazily produce each element in
the range.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-195/"></a><a href="srfi-195/"><span class="number">195</span></a>: <span class="name">Multiple-value boxes</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-08-28</span></span><span class="keywords" data-keywords="data-structure,multiple-value-returns">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=multiple-value-returns">Multiple-Value Returns</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-111/">SRFI 111: Boxes</a> and <a href="/srfi-189/">SRFI 189: Maybe and Either: optional container types</a>.</span><div class="abstract"><p>
This SRFI extends the specification of the boxes
of <a href="https://srfi.schemers.org/srfi-111/srfi-111.html">SRFI
111</a> so that they are multiple-values aware. Whereas a SRFI
111 box is limited in that it can only box a single value,
multiple values can be boxed with this SRFI.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-194/"></a><a href="srfi-194/"><span class="number">194</span></a>: <span class="name">Random data generators</span><span class="authors">, by Shiro Kawai (design), Arvydas Silanskas (implementation), John Cowan (editor and shepherd), and Linas Vepštas (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-08-26</span></span><span class="keywords" data-keywords="randomness">Keywords: <a href="https://srfi.schemers.org/?keywords=randomness">Randomness</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-27/">SRFI 27: Sources of Random Bits</a>.</span><div class="abstract"><p>This SRFI defines a set of
<a href="https://srfi.schemers.org/srfi-158/srfi-158.html">SRFI 158</a>
generators and generator makers that yield random data of specific
ranges and distributions. It is intended to be implemented on top of
<a href="https://srfi.schemers.org/srfi-27/srfi-27.html">SRFI 27</a>,
which provides the underlying source of random integers and floats.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-193/"></a><a href="srfi-193/"><span class="number">193</span></a>: <span class="name">Command line</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-09-10</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-22/">SRFI 22: Running Scheme Scripts on Unix</a>.</span><div class="abstract"><p>R<sup>6</sup>RS and R<sup>7</sup>RS define a
<code>command-line</code> procedure. While a useful baseline, the
specification is not detailed enough to cover all practical
situations. This SRFI clarifies the definition of
<code>command-line</code> and adds a few related procedures.
Scheme scripts, standalone executables, compilation and REPL use
are accounted for. Option parsing is out of scope.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-192/"></a><a href="srfi-192/"><span class="number">192</span></a>: <span class="name">Port Positioning</span><span class="authors">, by John Cowan and Shiro Kawai (implementation; requires a hook)</span><span class="based-on">Based on R6RS.</span><span class="date-group">Final: <span class="date">2020-07-31</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-181/">SRFI 181: Custom ports (including transcoded ports)</a>.</span><div class="abstract"><p>This is an extract from the R6RS that documents its support for
positioning ports. Binary ports can be positioned to read or write
at a specific byte; textual ports at a specific character,
although character positions can't be synthesized portably.
It has been lightly edited to fit R7RS style.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-191/"></a><a href="srfi-191/"><span class="number">191</span></a>: <span class="name">Procedure Arity Inspection</span><span class="authors">, by John Cowan</span><span class="based-on">Based on SRFI 102.</span><span class="date-group">Withdrawn: <span class="date">2020-07-05</span></span><span class="keywords" data-keywords="introspection">Keywords: <a href="https://srfi.schemers.org/?keywords=introspection">Introspection</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-102/">SRFI 102: Procedure Arity Inspection</a> and <a href="/srfi-151/">SRFI 151: Bitwise Operations</a>.</span><div class="abstract"><p>Many Scheme systems provide mechanisms for inspecting the arity of a
procedural value, making it a common feature, however there is no
standard interface. As a result there is no portable way to observe
the arity of a procedure without actually applying it. This
SRFI proposes a simple interface that is consistent with existing
Scheme systems' facilities and prior proposals.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-190/"></a><a href="srfi-190/"><span class="number">190</span></a>: <span class="name">Coroutine Generators</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-06-11</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-121/">SRFI 121: Generators</a>, <a href="/srfi-139/">SRFI 139: Syntax parameters</a>, and <a href="/srfi-158/">SRFI 158: Generators and Accumulators</a>.</span><div class="abstract"><p>This SRFI defines syntax to create
<a href="https://srfi.schemers.org/srfi-121/">SRFI
121</a>/<a href="https://srfi.schemers.org/srfi-158/">158</a>
coroutine generators conveniently and in the flavor of Python
generator functions.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-189/"></a><a href="srfi-189/"><span class="number">189</span></a>: <span class="name">Maybe and Either: optional container types</span><span class="authors">, by John Cowan (text) and Wolfgang Corcoran-Mathe (sample implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-07-14</span></span><span class="keywords" data-keywords="data-structure,multiple-value-returns">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=multiple-value-returns">Multiple-Value Returns</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-195/">SRFI 195: Multiple-value boxes</a>.</span><div class="abstract"><p>This SRFI defines two disjoint immutable container types
known as Maybe and Either,
both of which can contain objects collectively known as their payload.
A Maybe object is either a Just object or the unique object Nothing
(which has no payload); an Either object is either
a Right object or a Left object. Maybe represents the concept of
optional values; Either represents the concept of values which are
either correct (Right) or errors (Left).</p>
<p>Note that the terms Maybe, Just, Nothing, Either, Right, and Left
are capitalized in this SRFI so as not to be confused with their
ordinary use as English words. Thus "returns Nothing" means
"returns the unique Nothing object"; "returns nothing" could be
interpreted as "returns no values"
or "returns an unspecified value".</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-188/"></a><a href="srfi-188/"><span class="number">188</span></a>: <span class="name">Splicing binding constructs for syntactic keywords</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-06-03</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-93/">SRFI 93: R6RS Syntax-Case Macros</a> and <a href="/srfi-148/">SRFI 148: Eager syntax-rules</a>.</span><div class="abstract"><p>Splicing binding constructs for syntactic keywords are versions
of <code>let-syntax</code> and <code>letrec-syntax</code> that can
be used in a definition context in the same way
as <code>begin</code>.
</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-187/"></a><a href="srfi-187/"><span class="number">187</span></a>: <span class="name">ALAMBDA and ADEFINE</span><span class="authors">, by Joo ChurlSoo</span><span class="based-on">Based on SRFI 92.</span><span class="date-group">Withdrawn: <span class="date">2020-03-27</span></span><span class="keywords" data-keywords="miscellaneous,type-checking">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a>, <a href="https://srfi.schemers.org/?keywords=type-checking">Type Checking</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-92/">SRFI 92: ALAMBDA and ALAMBDA*</a> and <a href="/srfi-182/">SRFI 182: ADBMAL, ALET, and ALET*</a>.</span><div class="abstract"><p>This SRFI introduces alambda, which creates a procedure that checks
its actual arguments, takes various types of required and optional
variables.<br> This SRFI is based on
<a href="https://srfi.schemers.org/srfi-92/">SRFI 92</a>
as an extension of the optional arguments of
<a href="https://srfi.schemers.org/srfi-182/">SRFI 182</a>.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-186/"></a><a href="srfi-186/"><span class="number">186</span></a>: <span class="name">Transcoders and transcoded ports</span><span class="authors">, by John Cowan</span><span class="based-on">Based on R6RS.</span><span class="date-group">Withdrawn: <span class="date">2020-09-08</span></span><span class="keywords" data-keywords="i/o,superseded">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a>, <a href="https://srfi.schemers.org/?keywords=superseded">Superseded</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-80/">SRFI 80: Stream I/O</a>, <a href="/srfi-81/">SRFI 81: Port I/O</a>, and <a href="/srfi-181/">SRFI 181: Custom ports (including transcoded ports)</a>.</span><div class="abstract"><p>This is an extract from the R6RS that documents its support for
transcoders and transcoded ports. These provide a hook into the
Scheme port system from below, allowing the creation of textual ports
that provide non-default encoding and decoding from arbitrary binary
ports. It has been lightly edited to fit R7RS style.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-185/"></a><a href="srfi-185/"><span class="number">185</span></a>: <span class="name">Linear adjustable-length strings</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-04-26</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-13/">SRFI 13: String Libraries</a>, <a href="/srfi-118/">SRFI 118: Simple adjustable-size strings</a>, <a href="/srfi-130/">SRFI 130: Cursor-based string library</a>, <a href="/srfi-140/">SRFI 140: Immutable Strings</a>, and <a href="/srfi-152/">SRFI 152: String Library (reduced)</a>.</span><div class="abstract"><p>
Scheme specifies mutable fixed-length strings.
<a href="https://srfi.schemers.org/srfi-118/srfi-118.html">SRFI 118</a>
adds two procedures, <code>string-append!</code> and
<code>string-replace!</code>, which allow the length of the string to change.
This SRFI provides two linear-update versions of these procedures:
that is, the implementation may change the string length or return a
new string instead.
In addition, two convenience macros are provided that make the
procedures somewhat easier to use.</div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-184/"></a><a href="srfi-184/"><span class="number">184</span></a>: <span class="name">define-record-lambda</span><span class="authors">, by Joo ChurlSoo</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-03-27</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-9/">SRFI 9: Defining Record Types</a> and <a href="/srfi-100/">SRFI 100: define-lambda-object</a>.</span><div class="abstract"><p>This SRFI introduces a macro, DEFINE-RECORD-LAMBDA, that defines a
set of procedures, that is, a group of constructors and a predicate.
The constructors also make a group of procedures, namely record
lambdas, that have no explicit field accessors and mutators. They
can have various kinds of fields, such as common fields, required
fields, optional fields, automatic fields, read-only fields,
read-write fields, invisible fields, immutable fields, and virtual
fields.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-183/"></a><a href="srfi-183/"><span class="number">183</span></a>: <span class="name">Another format procedure, Fox</span><span class="authors">, by Joo ChurlSoo</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-03-27</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-54/">SRFI 54: Formatting</a>.</span><div class="abstract"><p>This SRFI introduces the formatting procedure Fox ("format of X"),
which takes one required argument and a variable number of additional
arguments and returns a formatted string.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-182/"></a><a href="srfi-182/"><span class="number">182</span></a>: <span class="name">ADBMAL, ALET, and ALET*</span><span class="authors">, by Joo ChurlSoo</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-03-27</span></span><span class="keywords" data-keywords="data-structure,multiple-value-returns">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=multiple-value-returns">Multiple-Value Returns</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-2/">SRFI 2: AND-LET*: an AND with local bindings, a guarded LET* special form</a>, <a href="/srfi-11/">SRFI 11: Syntax for receiving multiple values</a>, <a href="/srfi-51/">SRFI 51: Handling rest list</a>, <a href="/srfi-54/">SRFI 54: Formatting</a>, <a href="/srfi-71/">SRFI 71: Extended LET-syntax for multiple values</a>, and <a href="/srfi-86/">SRFI 86: MU and NU simulating VALUES & CALL-WITH-VALUES, and their related LET-syntax</a>.</span><div class="abstract"><p>Unlike the VALUES and CALL-WITH-VALUES mechanism of R5RS, this one
uses an explicit representation for multiple return values as a single
value, namely a procedure. Decomposition of multiple values is done
by simple application. The macro, ADBMAL, evaluates to a procedure
that takes one procedure argument. The ADBMAL macro can be compared
with LAMBDA. While a LAMBDA expression that consists of
<formals> and <body> requires some actual arguments later
when the evaluated LAMBDA expression is called, an ADBMAL expression
that consists of <expression>s corresponding to actual arguments
of LAMBDA requires <formals> and <body>, that is, an
evaluated LAMBDA expression, later when the evaluated ADBMAL
expression is called.</p>
<p>This SRFI also introduces the new LET-syntax ALET and ALET*, which
depend on ADBMAL to manipulate multiple values, and which are
compatible with LET and LET* of R5RS in single-value bindings. They
also have a binding form making use of VALUES and CALL-WITH-VALUES to
handle multiple values, and new binding forms for list, cons, and
other multiple values. In addition, they have several new binding
forms for useful functions such as escape, iteration, optional
arguments, etc.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-181/"></a><a href="srfi-181/"><span class="number">181</span></a>: <span class="name">Custom ports (including transcoded ports)</span><span class="authors">, by John Cowan</span><span class="based-on">Based on R6RS.</span><span class="date-group">Final: <span class="date">2020-09-08</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-79/">SRFI 79: Primitive I/O</a>, <a href="/srfi-81/">SRFI 81: Port I/O</a>, <a href="/srfi-82/">SRFI 82: Stream Ports</a>, <a href="/srfi-91/">SRFI 91: Extended ports</a>, <a href="/srfi-186/">SRFI 186: Transcoders and transcoded ports</a>, and <a href="/srfi-192/">SRFI 192: Port Positioning</a>.</span><div class="abstract"><p>This SRFI is derived from parts of
<a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-1.html#node_toc_node_sec_8.2.4">
library section 8.2.4</a>,
<a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-9.html#node_sec_8.2.7">
library section 8.2.7</a>,
<a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-9.html#node_sec_8.2.10">
library section 8.2.10</a>, and
<a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-9.html#node_sec_8.2.13">
library section 8.2.13</a>
of the R6RS.
These sections are themselves based on parts of
<a href="http://srfi.schemers.org/srfi-79/srfi-79.html">SRFI 79</a>,
<a href="http://srfi.schemers.org/srfi-80/srfi-80.html">SRFI 80</a> and
<a href="http://srfi.schemers.org/srfi-81/srfi-81.html">SRFI 81</a>.
These procedures provide a hook into the Scheme port system from below, allowing the
creation of custom ports that behave as much as possible like the standard
file, string, and bytevector ports, but that call a procedure to produce
data to input ports or to consume data from output ports.
Procedures for creating ports that transcode
between bytes and characters are an important special
case and are also documented in this SRFI.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-180/"></a><a href="srfi-180/"><span class="number">180</span></a>: <span class="name">JSON</span><span class="authors">, by Amirouche Boubekki</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-07-01</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This library describes a JavaScript Object Notation (JSON) parser and printer. It supports JSON that may be bigger than memory.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-179/"></a><a href="srfi-179/"><span class="number">179</span></a>: <span class="name">Nonempty Intervals and Generalized Arrays (Updated)</span><span class="authors">, by Bradley J. Lucier</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-06-30</span></span><span class="keywords" data-keywords="data-structure,numbers">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-122/">SRFI 122: Nonempty Intervals and Generalized Arrays</a> and <a href="/srfi-164/">SRFI 164: Enhanced multi-dimensional Arrays</a>.</span><div class="abstract"><p>This SRFI specifies an array mechanism for Scheme. Arrays as defined here are quite general; at their most basic, an array is simply a mapping, or function, from multi-indices of exact integers $i_0,\ldots,i_{d-1}$ to Scheme values. The set of multi-indices $i_0,\ldots,i_{d-1}$ that are valid for a given array form the <i>domain</i> of the array. In this SRFI, each array's domain consists of the cross product of nonempty intervals of exact integers $[l_0,u_0)\times[l_1,u_1)\times\cdots\times[l_{d-1},u_{d-1})$ of $\mathbb Z^d$, $d$-tuples of integers. Thus, we introduce a data type called $d$-<i>intervals</i>, or more briefly <i>intervals</i>, that encapsulates this notion. (We borrow this terminology from, e.g., Elias Zakon's <a href="http://www.trillia.com/zakon1.html">Basic Concepts of Mathematics</a>.) Specialized variants of arrays are specified to provide portable programs with efficient representations for common use cases.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-178/"></a><a href="srfi-178/"><span class="number">178</span></a>: <span class="name">Bitvector library</span><span class="authors">, by John Cowan (text) and Wolfgang Corcoran-Mathe (implementation)</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-08-25</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-151/">SRFI 151: Bitwise Operations</a> and <a href="/srfi-160/">SRFI 160: Homogeneous numeric vector libraries</a>.</span><div class="abstract"><p>This SRFI describes a set of operations on
homogeneous bitvectors.
Operations analogous to those provided on the other homogeneous
vector types described in
<a href="https://srfi.schemers.org/srfi-160/srfi-160.html">SRFI 160</a>
are provided,
along with operations analogous to the bitwise operations of
<a href="https://srfi.schemers.org/srfi-151/srfi-151.html">SRFI 151</a>.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-177/"></a><a href="srfi-177/"><span class="number">177</span></a>: <span class="name">Portable keyword arguments</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-07-31</span></span><span class="keywords" data-keywords="binding">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-88/">SRFI 88: Keyword objects</a> and <a href="/srfi-89/">SRFI 89: Optional positional and named parameters</a>.</span><div class="abstract"><p>Many Scheme implementations have keyword arguments, but they
have not been widely standardized. This SRFI defines the macros
<code>lambda/kw</code> and <code>call/kw</code>. They can be used
identically in every major implementation currently in use,
making it safe to use keyword arguments in portable code. The
macros expand to native keyword arguments in Schemes that have
them, letting programmers mix portable code and
implementation-specific code.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-176/"></a><a href="srfi-176/"><span class="number">176</span></a>: <span class="name">Version flag</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-02-24</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This SRFI defines a standard command-line flag to get version
information from a Scheme implementation. The output is
Line-oriented S-expressions which are easy to parse from Scheme, C,
and shell scripts and can co-exist with non-S-expression output. A
standard vocabulary is defined; extensions are easy to make.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-175/"></a><a href="srfi-175/"><span class="number">175</span></a>: <span class="name">ASCII character library</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-12-20</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="library-name">Library name: ascii</span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI defines ASCII-only equivalents to many of the
character procedures in standard Scheme plus a few extra ones.
Recent Scheme standards are based around Unicode but the
significant syntactic elements in many file formats and network
protocols are all ASCII. Such low-level code can run faster and
its behavior can be easier to understand when it uses ASCII
primitives.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-174/"></a><a href="srfi-174/"><span class="number">174</span></a>: <span class="name">POSIX Timespecs</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-12-21</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-19/">SRFI 19: Time Data Types and Procedures</a> and <a href="/srfi-170/">SRFI 170: POSIX API</a>.</span><div class="abstract"><p>This SRFI defines the trivial type <i>timespec</i>, which is used
to represent the <code>struct timespec</code> defined by the
<a href="https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/time.h.html">
P<small>OSIX</small> <code><time.h></code> header</a>.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-173/"></a><a href="srfi-173/"><span class="number">173</span></a>: <span class="name">Hooks</span><span class="authors">, by Amirouche Boubekki</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-10-24</span></span><span class="keywords" data-keywords="miscellaneous">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This library describes a mechanism known as hooks. Hooks are a
certain kind of extension point in a program that allows
interleaving the execution of arbitrary code with the execution of
the program without introducing any coupling between the two.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-172/"></a><a href="srfi-172/"><span class="number">172</span></a>: <span class="name">Two Safer Subsets of R7RS</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-11-10</span></span><span class="keywords" data-keywords="miscellaneous">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a></span><span class="status" data-status="final"></span><div class="abstract"><p>This SRFI provides two libraries for use with R7RS that provide a
way to sandbox the <code>eval</code> procedure to make it safer to use
in evaluating Scheme expressions of doubtful provenance. The intention
is to call <code>eval</code>, passing it an S-expression representing a
Scheme procedure and the environment defined by one of these libraries.
Since code evaluated by <code>eval</code> runs in a null lexical
environment, the resulting procedure can then be invoked with less
concern about possible side effects.
</p>
<p><b>Use of these libraries does not provide any sort of safety
guarantee. There are still many loopholes uncaught, including
attempts to process circular structure and over-allocation of memory.
The claim is only that the probability of such an attack is reduced,
not that it is eliminated.
However, using these libraries is a simple provision that is easy to
implement and easy to use. For higher safety, it can readily be
combined with other provisions.
</b></p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-171/"></a><a href="srfi-171/"><span class="number">171</span></a>: <span class="name">Transducers</span><span class="authors">, by Linus Björnstam</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-10-26</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"><p>A library implementing transducers — composable algorithmic
transformations. Scheme has many different ways of expressing
transformations over different collection types, but they are all
unique to whatever base type they work on. This SRFI proposes a new
construct, the transducer, that is oblivious to the context in which
it is being used.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-170/"></a><a href="srfi-170/"><span class="number">170</span></a>: <span class="name">POSIX API</span><span class="authors">, by Olin Shivers (original author), John Cowan (editor and shepherd), and Harold Ancell (implementer and editor)</span><span class="based-on">Based on scsh by Olin Shivers.</span><span class="date-group">Final: <span class="date">2020-10-28</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-198/">SRFI 198: Foreign Interface Status</a>.</span><div class="abstract"><p>
The host environment is the set of resources, such as the filesystem,
network and processes, that are managed by the operating system on top of
which a Scheme program is executing. This SRFI specifies some of the ways the host
environment can be accessed from within a Scheme program. It does so by
leveraging widespread support for P<small>OSIX</small>, the Portable
Operating System Interface standardized by the IEEE. Not all of the
functions of this SRFI are available on all operating systems.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-169/"></a><a href="srfi-169/"><span class="number">169</span></a>: <span class="name">Underscores in numbers</span><span class="authors">, by Lassi Kortela</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-07-26</span></span><span class="keywords" data-keywords="numbers,syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a>, <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"><p>Many people find that large numbers are easier to read when the
digits are broken into small groups. For example, the number
<code>1582439</code> might be easier to read if written as <code>1
582 439</code>. This applies to source code as it does to other
writing. We propose an extension of Scheme syntax to allow the
underscore as a digit separator in numerical constants.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-168/"></a><a href="srfi-168/"><span class="number">168</span></a>: <span class="name">Generic Tuple Store Database</span><span class="authors">, by Amirouche Boubekki</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-11-08</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-167/">SRFI 167: Ordered Key Value Store</a> and <a href="/srfi-173/">SRFI 173: Hooks</a>.</span><div class="abstract"><p>This library is a generic approach to the database abstractions
known as triplestore and quadstore. Generic Tuple Store Database
implements n-tuple ordered sets and associated primitives for
working with them in the context of data management.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-167/"></a><a href="srfi-167/"><span class="number">167</span></a>: <span class="name">Ordered Key Value Store</span><span class="authors">, by Amirouche Boubekki</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-11-08</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-168/">SRFI 168: Generic Tuple Store Database</a> and <a href="/srfi-173/">SRFI 173: Hooks</a>.</span><div class="abstract"><p>This library describes an interface for an ordered key-value store
that is suitable for implementing a storage engine for the generic
tuple-store SRFI. It maps cleanly to existing ordered key-value
databases that may or may not provide transactions.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-166/"></a><a href="srfi-166/"><span class="number">166</span></a>: <span class="name">Monadic Formatting</span><span class="authors">, by Alex Shinn</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2020-07-30</span></span><span class="keywords" data-keywords="i/o">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-13/">SRFI 13: String Libraries</a>, <a href="/srfi-159/">SRFI 159: Combinator Formatting</a>, and <a href="/srfi-165/">SRFI 165: The Environment Monad</a>.</span><div class="abstract"><p>
A library of procedures for formatting Scheme objects to text in
various ways, and for easily concatenating, composing and extending
these formatters efficiently without resorting to capturing and
manipulating intermediate strings.</p>
<p>
This SRFI is an updated version of SRFI 159, primarily with the
difference that state variables are hygienic.</p>
<p>
Summary of differences from SRFI 159:
<ul>
<li>State variables are first class and hygienic</li>
<li>Added <code>written-shared</code>, <code>pretty-shared</code></li>
<li>Added <code>as-italic</code>, <code>as-color</code>, <code>as-true-color</code>, <code>on-<i>color</i></code> background variants, and <code>pretty-with-color</code></li>
<li>Added <code>ambiguous-is-wide?</code> state variable and <code>string-terminal-width/wide</code> utility</li>
<li>Added <code>substring/width</code> state var for width-aware substring operations, with <code>substring-terminal-width(/wide)</code> utilities</li>
<li>Added <code>substring/preserve</code> state var used in trimming, with <code>substring-terminal-preserve</code> utility</li>
<li>Added <code>pretty-environment</code> state variable</li>
<li>Renamed <code>as-unicode</code> to <code>terminal-aware</code></li>
<li>Restored non-uniform comma rules as needed in India</li>
<li>Restored <code>upcased</code> and <code>downcased</code></li>
<li>Several clarifications and more examples</li>
</ul></div></li>
<li class="card final"><a class="card-anchor" href="srfi-165/"></a><a href="srfi-165/"><span class="number">165</span></a>: <span class="name">The Environment Monad</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-09-05</span></span><span class="keywords" data-keywords="miscellaneous">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-159/">SRFI 159: Combinator Formatting</a> and <a href="/srfi-166/">SRFI 166: Monadic Formatting</a>.</span><div class="abstract">Monads model computations. The environment monad models
computations that depend on values from a shared environment.
These computations can read values from the environment, pass
values to subsequent computations, execute sub-computations in an
extended environment, and modify the environment for future
computations.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-164/"></a><a href="srfi-164/"><span class="number">164</span></a>: <span class="name">Enhanced multi-dimensional Arrays</span><span class="authors">, by Per Bothner</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-08-08</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-4/">SRFI 4: Homogeneous numeric vector datatypes</a>, <a href="/srfi-25/">SRFI 25: Multi-dimensional Array Primitives</a>, <a href="/srfi-122/">SRFI 122: Nonempty Intervals and Generalized Arrays</a>, and <a href="/srfi-163/">SRFI 163: Enhanced array literals</a>.</span><div class="abstract"><p>This SRFI describes the array data type (a generalization of
vectors to multiple indexes or dimensions), along with a set of
procedures for working on them.</p>
<p>This specification is an extension of <a href="http://srfi.schemers.org/srfi-25/srfi-25.html">SRFI 25</a>,
with additions from Racket’s
<a href="https://docs.racket-lang.org/math/array.html">math.array</a> package
and other sources. It has been implemented in the <a href="https://www.gnu.org/software/kawa/Arrays.html">Kawa dialect of Scheme</a>.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-163/"></a><a href="srfi-163/"><span class="number">163</span></a>: <span class="name">Enhanced array literals</span><span class="authors">, by Per Bothner</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-01-18</span></span><span class="keywords" data-keywords="reader-syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=reader-syntax">Reader Syntax</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-4/">SRFI 4: Homogeneous numeric vector datatypes</a>, <a href="/srfi-25/">SRFI 25: Multi-dimensional Array Primitives</a>, <a href="/srfi-48/">SRFI 48: Intermediate Format Strings</a>, <a href="/srfi-58/">SRFI 58: Array Notation</a>, <a href="/srfi-58/">SRFI 58: Array Notation</a>, <a href="/srfi-122/">SRFI 122: Nonempty Intervals and Generalized Arrays</a>, <a href="/srfi-160/">SRFI 160: Homogeneous numeric vector libraries</a>, and <a href="/srfi-164/">SRFI 164: Enhanced multi-dimensional Arrays</a>.</span><div class="abstract"><p>This is a specification of a reader form (literals)
for multi-dimensional arrays.
It is an extension of the Common Lisp array reader syntax to handle
non-zero lower bounds, optional explicit bounds,
and optional uniform element types (compatible with <a href="https://srfi.schemers.org/srfi-4">SRFI 4</a>).
It can be used in conjunction with <a href="https://srfi.schemers.org/srfi-25">SRFI 25</a>, <a href="https://srfi.schemers.org/srfi-122">SRFI 122</a>,
or <a href="https://srfi.schemers.org/srfi-164">SRFI 164</a>.
These extensions were implemented in Guile (except the handling of rank-0 arrays),
and later in Kawa.
<p>There are recommendations for output formatting
and a suggested <code>format-array</code> procedure.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-162/"></a><a href="srfi-162/"><span class="number">162</span></a>: <span class="name">Comparators sublibrary</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-08-27</span></span><span class="keywords" data-keywords="comparison">Keywords: <a href="https://srfi.schemers.org/?keywords=comparison">Comparison</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-114/">SRFI 114: Comparators</a> and <a href="/srfi-128/">SRFI 128: Comparators (reduced)</a>.</span><div class="abstract"><p>
This SRFI provides a few extra procedures and comparators to go
with SRFI 128, Comparators. Implementers are urged to add them to
their SRFI 128 libraries, for which reason they are not packaged
as a separate library.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-161/"></a><a href="srfi-161/"><span class="number">161</span></a>: <span class="name">Unifiable Boxes</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2019-02-08</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-111/">SRFI 111: Boxes</a>.</span><div class="abstract"><p>
Unifiable boxes are, like the boxes
of <a href="https://srfi.schemers.org/srfi-111/srfi-111.html">SRFI
111</a>, objects with a single mutable state. A constructor,
predicate, accessor, and mutator are provided.
</p>
<p>
In addition to this, an equality predicate and union operations (link,
union, unify) are provided. Applying a union operation to two
unifiable boxes makes the two boxes equal (in the sense of the
equality predicate). As a consequence, their state will also become
identical. In the case of link and union, it will be the state of one
of the two unioned boxes. In the case of unify, the state is
determined by a supplied unification procedure.
</p>
<p>
Unifiable boxes are
also known under the names <i>disjoint-set data
structure</i>, <i>union–find data structure</i> or <i>merge–find
set</i>.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-160/"></a><a href="srfi-160/"><span class="number">160</span></a>: <span class="name">Homogeneous numeric vector libraries</span><span class="authors">, by John Cowan and Shiro Kawai (contributed a major patch)</span><span class="based-on">Based on SRFI 4 by Marc Feeley.</span><span class="date-group">Final: <span class="date">2019-08-27</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-4/">SRFI 4: Homogeneous numeric vector datatypes</a>, <a href="/srfi-74/">SRFI 74: Octet-Addressed Binary Blocks</a>, <a href="/srfi-133/">SRFI 133: Vector Library (R7RS-compatible)</a>, and <a href="/srfi-152/">SRFI 152: String Library (reduced)</a>.</span><div class="abstract"><p>This SRFI describes a set of operations on SRFI 4 homogeneous vector
types (plus a few additional types) that are closely analogous
to the vector operations library,
<a href="http://srfi.schemers.org/srfi-133/srfi-133.html">
SRFI 133</a>.
An external representation is specified which may be supported by the
<code>read</code> and <code>write</code> procedures and by the program
parser so that programs can contain references to literal homogeneous
vectors.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-159/"></a><a href="srfi-159/"><span class="number">159</span></a>: <span class="name">Combinator Formatting</span><span class="authors">, by Alex Shinn</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2020-07-31</span></span><span class="keywords" data-keywords="i/o,r7rs-large,r7rs-large-tangerine,superseded">Keywords: <a href="https://srfi.schemers.org/?keywords=i/o">I/O</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a>, <a href="https://srfi.schemers.org/?keywords=superseded">Superseded</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-28/">SRFI 28: Basic Format Strings</a>, <a href="/srfi-48/">SRFI 48: Intermediate Format Strings</a>, and <a href="/srfi-166/">SRFI 166: Monadic Formatting</a>.</span><div class="abstract"><p>A library of procedures for formatting Scheme objects to text in
various ways, and for easily concatenating, composing and extending
these formatters efficiently without resorting to capturing and
manipulating intermediate strings.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-158/"></a><a href="srfi-158/"><span class="number">158</span></a>: <span class="name">Generators and Accumulators</span><span class="authors">, by Shiro Kawai, John Cowan, and Thomas Gilray</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-10-27</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="library-name">Library name: generators-and-accumulators</span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-121/">SRFI 121: Generators</a>.</span><div class="abstract"><p>This SRFI defines utility procedures that create, transform, and consume generators.
A generator is simply a procedure with no arguments that works
as a source of values. Every time it is called,
it yields a value. Generators may be finite or infinite; a finite
generator returns an end-of-file object to indicate that it is exhausted.
For example, <code>read-char</code>, <code>read-line</code>,
and <code>read</code> are generators that
generate characters, lines, and objects from the current input port.
Generators provide lightweight laziness.
</p>
<p>This SRFI also defines procedures that return accumulators.
An accumulator is the inverse of a generator: it is a procedure of one argument
that works as a sink of values.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-157/"></a><a href="srfi-157/"><span class="number">157</span></a>: <span class="name">Continuation marks</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2018-01-29</span></span><span class="keywords" data-keywords="continuations">Keywords: <a href="https://srfi.schemers.org/?keywords=continuations">Continuations</a></span><span class="status" data-status="final"></span><div class="abstract"><p>
Continuation marks are a programming language feature that allows
one to attach information to and retrieve information from
continuations, generalizing stack inspection. Conceptually, a
continuation consists of a number of frames where each frame stands
for an active procedure call that is not a tail call. A
continuation mark is then a key-value pair associated with a frame,
with keys compared using <code>eq?</code>.
At most one mark for a given key can be attached to a single frame.
</p>
<p>
Besides stack inspection, continuation marks can be used to
implement dynamic scope, delimited continuations, or delayed
evaluation that is able to handle iterative lazy algorithms.
</p>
<p>
This SRFI proposes to add continuation marks to the Scheme
programming language. The interface defined here is modelled after
Racket's continuation marks. It does not include all forms and
procedures provided by Racket but provides a compatible subset.
</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-156/"></a><a href="srfi-156/"><span class="number">156</span></a>: <span class="name">Syntactic combiners for binary predicates</span><span class="authors">, by Panicz Maciej Godek</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-12-18</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="library-name">Library name: predicate-combiners</span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-26/">SRFI 26: Notation for Specializing Parameters without Currying</a>.</span><div class="abstract"><p>Recognizing binary predicates as a specific area
in which the use of prefix operators is an impediment,
we propose a thin layer of "syntactic stevia" for in-fixing
such predicates. It can be implemented using regular Scheme
macros. We suggest that the code <code>(is x < y)</code> should
be transformed to <code>(< x y)</code>, and <code>(is x < y <= z)</code>
-- to <code>(let ((y* y)) (and (< x y*) (<= y* z)))</code>.
In addition, we suggest special meaning to the <code>_</code> symbol:
<code>(is _ < y)</code> and <code>(is x < _)</code>
should be transformed to <code>(lambda (_) (< _ y))</code>
and <code>(lambda (_) (< x _))</code>, respectively.
This SRFI document also describes some other uses of the
<code>is</code> macro and its limitations.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-155/"></a><a href="srfi-155/"><span class="number">155</span></a>: <span class="name">Promises</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2018-09-15</span></span><span class="keywords" data-keywords="data-structure,lazy-evaluation">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=lazy-evaluation">Lazy Evaluation</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-45/">SRFI 45: Primitives for Expressing Iterative Lazy Algorithms</a>.</span><div class="abstract"> <p>
Scheme, like ML, is a programming language with strict evaluation
while others, like Haskell, use lazy evaluation. Scheme, however,
possesses the primitives <code>delay</code> and <code>force</code>
that make it possible to express lazy algorithms.
<p>
Lazy evaluation does not go well in conjunction with imperative,
non-functional, side-effecting code. It should, however, be
applicable in a purely functional setting. This is the case for the
delayed evaluation model as described in the R7RS as long as no
dynamically bound variables, also known as parameter objects, are
present. It is the purpose of this SRFI to rework the specification
in the R7RS so that lazy evaluation works with purely functional code
that makes use of dynamic environments or, more generally, the dynamic
extent. This is done by remembering the dynamic extent in effect when
the <code>delay</code> expression is evaluated.
<p>
Another perceived misfeature of the R7RS model of delayed evaluation
is the apparent need of the <code>delay-force</code> special form to
express iterative lazy algorithms. It is shown that
the <code>delay-force</code> special form is unneeded and that the
implementation can (and should) handle iterative lazy algorithms
without space leaks.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-154/"></a><a href="srfi-154/"><span class="number">154</span></a>: <span class="name">First-class dynamic extents</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2018-09-15</span></span><span class="keywords" data-keywords="miscellaneous">Keywords: <a href="https://srfi.schemers.org/?keywords=miscellaneous">Miscellaneous</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-157/">SRFI 157: Continuation marks</a>.</span><div class="abstract"><p>Scheme has the notion of the <em>dynamic extent</em> of a
procedure call. A number of standard Scheme procedures and
syntaxes
like <code>dynamic-wind</code>, <code>call-with-current-continuation</code>,
and <code>parameterize</code>
deal with the dynamic extent indirectly. The same holds true
for the procedures and syntaxes dealing with continuation
marks as defined by <a href="https://srfi.schemers.org/srfi-157/srfi-157.html">SRFI
157</a>.</p>
<p>This SRFI reifies the dynamic extent into a first-class value
together with a well-defined procedural interface and a syntax to
create procedures that remember not only their environment at
creation time but also their dynamic extent, which includes their
dynamic environment.</p></div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-153/"></a><a href="srfi-153/"><span class="number">153</span></a>: <span class="name">Ordered Sets</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2018-07-08</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="withdrawn"></span><div class="abstract"><p><em>Osets</em> are immutable collections that can contain any Scheme
object. Osets enforce the constraint that no two elements can be the same
in the sense of the oset's associated <em>equality predicate</em>
The elements in an oset appear in a fixed order determined by the
comparator used to create it.</p></div></li>
<li class="card final"><a class="card-anchor" href="srfi-152/"></a><a href="srfi-152/"><span class="number">152</span></a>: <span class="name">String Library (reduced)</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-10-04</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="library-name">Library name: strings</span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-130/">SRFI 130: Cursor-based string library</a> and <a href="/srfi-135/">SRFI 135: Immutable Texts</a>.</span><div class="abstract"> <p>Scheme has an impoverished set of
string-processing utilities, which is a problem for authors of portable
code. This SRFI proposes a coherent and comprehensive set of
string-processing procedures. It is a reduced version of SRFI 13 that has
been aligned with SRFI 135, Immutable Texts. Unlike SRFI 13, it has been
made consistent with the R5RS, R6RS, and R7RS-small string
procedures.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-151/"></a><a href="srfi-151/"><span class="number">151</span></a>: <span class="name">Bitwise Operations</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-07-10</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-tangerine,numbers">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a>, <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a></span><span class="library-name">Library name: bitwise-operations</span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-142/">SRFI 142: Bitwise Operations</a>.</span><div class="abstract"> <p>This SRFI proposes a coherent and comprehensive
set of procedures for performing bitwise logical operations on integers;
it is accompanied by a reference implementation of the spec in terms of a
set of seven core operators. The sample implementation is portable, as
efficient as practical with pure Scheme arithmetic (it is much more
efficient to replace the core operators with C or assembly language if
possible), and open source.
<p>The precise semantics of these operators is
almost never an issue. A consistent, portable set of <em>names</em> and
<em>parameter conventions</em>, however, is. Hence this SRFI, which is
based mainly on <a href="https://srfi.schemers.org/srfi-33/">SRFI 33</a>, with some changes and
additions from <a href="http://srfi.schemers.org/srfi-33/mail-archive/msg00023.html">Olin's late
revisions to SRFI 33</a> (which were never consummated). <a href="https://srfi.schemers.org/srfi-60/">SRFI 60</a> (based on SLIB) is smaller but has a few
procedures of its own; some of its procedures have both native (often
Common Lisp) and SRFI 33 names. They have been incorporated into this
SRFI. <a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-12.html#node_sec_11.4">
R6RS</a> is a subset of SRFI 60, except that all procedure names begin
with a <code>bitwise-</code> prefix. A few procedures have been added from
the general vector <a href="https://srfi.schemers.org/srfi-133/">SRFI 133</a>.
<p>Among the applications of bitwise operations
are: hashing, Galois-field calculations of error-detecting and
error-correcting codes, cryptography and ciphers, pseudo-random number
generation, register-transfer-level modeling of digital logic designs,
Fast-Fourier transforms, packing and unpacking numbers in persistent data
structures, space-filling curves with applications to dimension reduction
and sparse multi-dimensional database indexes, and generating approximate
seed values for root-finders and transcendental function
algorithms.
<p>This SRFI differs from SRFI 142 in only two
ways:
<ol>
<li>
<p>The <code>bitwise-if</code> function has the
argument ordering of SLIB, SRFI 60, and R6RS rather than the ordering
of SRFI 33.
<li>
<p>The order in which bits are processed by
the procedures listed in the "Bits conversion" section has been
clarified and some of the procedures' names have been changed. See
"Bit processing order" for details.
</ol></div></li>
<li class="card final"><a class="card-anchor" href="srfi-150/"></a><a href="srfi-150/"><span class="number">150</span></a>: <span class="name">Hygienic ERR5RS Record Syntax (reduced)</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2018-01-16</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-9/">SRFI 9: Defining Record Types</a>, <a href="/srfi-99/">SRFI 99: ERR5RS Records</a>, and <a href="/srfi-131/">SRFI 131: ERR5RS Record Syntax (reduced)</a>.</span><div class="abstract"> <p>
This SRFI provides a specification and portable implementation of an
extension of the ERR5RS record syntax
of <a href="https://srfi.schemers.org/srfi-131/srfi-131.html">SRFI
131</a>, where field names inserted by macro transformers are
effectively renamed as if the macro transformer inserted a binding.
This makes this SRFI compatible with the semantics of the record-type
definitions of
the <a href="https://bitbucket.org/cowan/r7rs/src/draft-10/rnrs/r7rs.pdf">R7RS</a>
as intended by
its <a href="https://groups.google.com/d/msg/scheme-reports-wg2/oKuhgwaM45w/KXgPrh8oAwAJ">authors</a>.
In addition, field names may also be other types of Scheme datums,
like numbers and strings, or
<a href="https://srfi.schemers.org/srfi-88/srfi-88.html">SRFI 88</a> keyword objects.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-149/"></a><a href="srfi-149/"><span class="number">149</span></a>: <span class="name">Basic Syntax-rules Template Extensions</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-07-08</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>The rules for valid
<code><template></code>s of <code><syntax rules></code> are
slightly softened to allow for more than one consecutive
<code><ellipsis></code> in subtemplates, and to allow pattern
variables in subtemplates to be followed by more instances of the
identifier <code><ellipsis></code> than they are followed in the
subpattern in which they occur.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-148/"></a><a href="srfi-148/"><span class="number">148</span></a>: <span class="name">Eager syntax-rules</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-08-08</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>Writing powerful <code>syntax-rules</code>
macros is hard because they do not compose well: The arguments of a macro
expansion are not expanded. This SRFI defines an easy to comprehend
high-level system for writing powerful, composable (or <em>eager</em>)
macros, two of whose defining features are that its macro arguments are
(in general) eagerly expanded and that it can be portably implemented in
any Scheme implementation conforming to the R7RS.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-147/"></a><a href="srfi-147/"><span class="number">147</span></a>: <span class="name">Custom macro transformers</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-03-07</span></span><span class="keywords" data-keywords="syntax">Keywords: <a href="https://srfi.schemers.org/?keywords=syntax">Syntax</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>Each syntax definition assigns a macro
transformer to a keyword. The macro transformer is specified by a
transformer spec, which is either an instance of
<code>syntax-rules</code>, an existing syntactic keyword (including macro
keywords and the syntactic keywords that introduce the core forms, like
<code>lambda</code>, <code>if</code>, or <code>define</code>), or a use
of a macro that eventually expands into an instance of
<code>syntax-rules</code>. In the latter case, the keyword of macro use
is called a <em>custom macro transformer</em>.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-146/"></a><a href="srfi-146/"><span class="number">146</span></a>: <span class="name">Mappings</span><span class="authors">, by Arthur A. Gleckler and Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2018-05-24</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-224/">SRFI 224: Integer Mappings</a>.</span><div class="abstract"> <p><em>Mappings</em> are finite sets of
associations, where each association is a pair consisting of a key and an
arbitrary Scheme value. The keys are elements of a suitable domain. Each
mapping holds no more than one association with the same key. The
fundamental mapping operation is retrieving the value of an association
stored in the mapping when the key is given.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-145/"></a><a href="srfi-145/"><span class="number">145</span></a>: <span class="name">Assumptions</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-03-31</span></span><span class="keywords" data-keywords="optimization">Keywords: <a href="https://srfi.schemers.org/?keywords=optimization">Optimization</a></span><span class="library-name">Library name: assume</span><span class="status" data-status="final"></span><div class="abstract"> <p>A means to denote the invalidity of certain
code paths in a Scheme program is proposed. It allows Scheme code to turn
the evaluation into a user-defined error that need not be signalled by
the implementation. Optimizing compilers may use these denotations to
produce better code and to issue better warnings about dead code.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-144/"></a><a href="srfi-144/"><span class="number">144</span></a>: <span class="name">Flonums</span><span class="authors">, by John Cowan and Will Clinger</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-07-17</span></span><span class="keywords" data-keywords="numbers,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI describes numeric procedures
applicable to <em>flonums</em>, a subset of the inexact real numbers
provided by a Scheme implementation. In most Schemes, the flonums and the
inexact reals are the same. These procedures are semantically equivalent
to the corresponding generic procedures, but allow more efficient
implementations.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-143/"></a><a href="srfi-143/"><span class="number">143</span></a>: <span class="name">Fixnums</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-05-27</span></span><span class="keywords" data-keywords="numbers,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="library-name">Library name: fixnums</span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI describes arithmetic procedures
applicable to a limited range of exact integers only. These procedures
are semantically similar to the corresponding generic-arithmetic
procedures, but allow more efficient implementations.</div></li>
<li class="card withdrawn"><a class="card-anchor" href="srfi-142/"></a><a href="srfi-142/"><span class="number">142</span></a>: <span class="name">Bitwise Operations</span><span class="authors">, by John Cowan</span><span class="based-on"></span><span class="date-group">Withdrawn: <span class="date">2017-08-10</span></span><span class="keywords" data-keywords="data-structure,superseded">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=superseded">Superseded</a></span><span class="status" data-status="withdrawn"></span><span class="see-also">See also <a href="/srfi-151/">SRFI 151: Bitwise Operations</a>.</span><div class="abstract"> <p>This SRFI proposes a coherent and comprehensive
set of procedures for performing bitwise logical operations on integers;
it is accompanied by a reference implementation of the spec in terms of a
set of seven core operators. The sample implementation is portable, as
efficient as practical with pure Scheme arithmetic (it is worthwhile
replacing the core operators with C or assembly language if possible),
and open source.
<p>The precise semantics of these operators is
almost never an issue. A consistent, portable set of <em>names</em> and
<em>parameter conventions</em>, however, is. Hence this SRFI, which is
based mainly on <a href="https://srfi.schemers.org/srfi-33/">SRFI 33</a>, with some changes and
additions from <a href="http://srfi.schemers.org/srfi-33/mail-archive/msg00023.html">Olin's late
revisions to SRFI 33</a> (which were never consummated). <a href="https://srfi.schemers.org/srfi-60/">SRFI 60</a> (based on SLIB) is smaller but has a few
procedures of its own; some of its procedures have both native (often
Common Lisp) and SRFI 33 names. They have been incorporated into this
SRFI. <a href="http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-12.html#node_sec_11.4">
R6RS</a> is a subset of SRFI 60, except that all procedure names begin
with a <code>bitwise-</code> prefix. A few procedures have been added from
the general vector <a href="https://srfi.schemers.org/srfi-133/">SRFI 133</a>.
<p>Among the applications of bitwise operations
are: hashing, Galois-field calculations of error-detecting and
error-correcting codes, cryptography and ciphers, pseudo-random number
generation, register-transfer-level modeling of digital logic designs,
Fast-Fourier transforms, packing and unpacking numbers in persistent data
structures, space-filling curves with applications to dimension reduction
and sparse multi-dimensional database indexes, and generating approximate
seed values for root-finders and transcendental function
algorithms.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-141/"></a><a href="srfi-141/"><span class="number">141</span></a>: <span class="name">Integer division</span><span class="authors">, by Taylor Campbell and John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-12-14</span></span><span class="keywords" data-keywords="numbers,r7rs-large,r7rs-large-tangerine">Keywords: <a href="https://srfi.schemers.org/?keywords=numbers">Numbers</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-tangerine">R7RS Large: Tangerine Edition</a></span><span class="library-name">Library name: integer-division</span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI provides a fairly complete set of
integral division and remainder operators.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-140/"></a><a href="srfi-140/"><span class="number">140</span></a>: <span class="name">Immutable Strings</span><span class="authors">, by Per Bothner</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2017-05-24</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-118/">SRFI 118: Simple adjustable-size strings</a> and <a href="/srfi-135/">SRFI 135: Immutable Texts</a>.</span><div class="abstract"> <p>This attempts to solve the same issues with
R7RS strings raised by <a href="https://srfi.schemers.org/srfi-135/">SRFI-135</a>, but with better
integration with the Scheme language.
<p>We propose to retain the name <dfn>string</dfn>
as the type of sequences of Unicode characters (scalar values). There are
two standard subtypes of string:
<ul>
<li>Immutable strings, also called
<dfn>istrings</dfn>, cannot be modified after they have been created.
Calling <code>string-set!</code> on an istring throws an error. On the
other hand, the core operations <code>string-ref</code> and
<code>string-length</code> are guaranteed to be O(1).
<li>Mutable strings can be modified
<q>in-place</q> using <code>string-set!</code> and other operations.
However, <code>string-ref</code>, <code>string-set!</code>, or
<code>string-length</code> have no performance guarantees. On many
implementation they may take time proportional to the length of the
string.
</ul>
<p>An implementation may support other kinds of
strings. For example on the Java platform it may be reasonable to
consider any instance of <code>java.lang.CharSequence</code> to be a
string.
<p>The main part of the proposal specifies the
default bindings of various procedure names, as might be pre-defined in a
REPL. Specifically, some procedures that traditionally return mutable
strings are changed to return istrings. We later discuss compatibility
and other library issues.
<p>This combines <a href="https://srfi.schemers.org/srfi-13/">SRFI-13</a>,
<a href="https://srfi.schemers.org/srfi-135/">SRFI-135</a>, and <a href="/srfi-118/">SRFI-118</a>.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-139/"></a><a href="srfi-139/"><span class="number">139</span></a>: <span class="name">Syntax parameters</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-10-02</span></span><span class="keywords" data-keywords="binding,parameters">Keywords: <a href="https://srfi.schemers.org/?keywords=binding">Binding</a>, <a href="https://srfi.schemers.org/?keywords=parameters">Parameters</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>Syntax parameters are to the expansion process
of a Scheme program what parameters are to the evaluation process of a
Scheme program. They allow hygienic implementation of syntactic forms
that would otherwise introduce implicit identifiers
unhygienically.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-138/"></a><a href="srfi-138/"><span class="number">138</span></a>: <span class="name">Compiling Scheme programs to executables</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-09-28</span></span><span class="keywords" data-keywords="operating-system">Keywords: <a href="https://srfi.schemers.org/?keywords=operating-system">Operating System</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI describes, for sufficiently
POSIX-compatible systems, a portable interface for compiling Scheme
programs conforming to the R7RS to binaries that can be directly executed
on the host system.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-137/"></a><a href="srfi-137/"><span class="number">137</span></a>: <span class="name">Minimal Unique Types</span><span class="authors">, by John Cowan and Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-10-04</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI is intended to standardize a
primitive run-time mechanism to create disjoint types.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-136/"></a><a href="srfi-136/"><span class="number">136</span></a>: <span class="name">Extensible record types</span><span class="authors">, by Marc Nieper-Wißkirchen</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-12-25</span></span><span class="keywords" data-keywords="data-structure">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>SRFI 9 and the compatible R7RS-small provide
Scheme with record types. The basic problem that is solved by these
record types is that they allow the user to introduce new types, disjoint
from all existing types. The record type system described in this
document is a conservative extension to SRFI 9 and R7RS record types (in
other words, the keyword <code>define-record-type</code> defined in this
specification can serve as the equally named keyword from SRFI 9 and R7RS
and can thus be safely exported from <code>(srfi 9)</code> and
<code>(scheme base)</code>) that is intended to solve another fundamental
problem, namely the introduction of subtypes.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-135/"></a><a href="srfi-135/"><span class="number">135</span></a>: <span class="name">Immutable Texts</span><span class="authors">, by William D Clinger</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-09-06</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-red">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-red">R7RS Large: Red Edition</a></span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-118/">SRFI 118: Simple adjustable-size strings</a>, <a href="/srfi-130/">SRFI 130: Cursor-based string library</a>, <a href="/srfi-140/">SRFI 140: Immutable Strings</a>, and <a href="/srfi-152/">SRFI 152: String Library (reduced)</a>.</span><div class="abstract"> <p>In Scheme, strings are a mutable data type.
Although it "is an error" (<abbr title="Revised<sup>5</sup> Report on Scheme">R5RS</abbr> and
<abbr title="Revised<sup>7</sup> Report on Scheme">R7RS</abbr>) to use
<code>string-set!</code> on literal strings or on strings returned by
<code>symbol->string</code>, and any attempt to do so "should raise an
exception" (<abbr title="Revised<sup>6</sup> Report on Scheme">R6RS</abbr>), all
other strings are mutable.
<p>Although many mutable strings are never
actually mutated, the mere possibility of mutation complicates
specifications of libraries that use strings, encourages precautionary
copying of strings, and precludes structure sharing that could otherwise
be used to make procedures such as <code>substring</code> and
<code>string-append</code> faster and more space-efficient.
<p>This <abbr title="Scheme Request for Implementation">SRFI</abbr> specifies a new data type
of immutable texts. It comes with efficient and portable sample
implementations that guarantee O(1) indexing for both sequential and
random access, even in systems whose <code>string-ref</code> procedure
takes linear time.
<p>The operations of this new data type include
analogues for all of the non-mutating operations on strings specified by
the R7RS and most of those specified by <abbr title="String cursors"><a href="https://srfi.schemers.org/srfi-130/">SRFI 130</a></abbr>, but the
immutability of texts and uniformity of character-based indexing simplify
the specification of those operations while avoiding several
inefficiencies associated with the mutability of Scheme's strings.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-134/"></a><a href="srfi-134/"><span class="number">134</span></a>: <span class="name">Immutable Deques</span><span class="authors">, by Kevin Wortman and John Cowan</span><span class="based-on"></span><span class="date-group">Final: <span class="date">2016-07-01</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-red">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-red">R7RS Large: Red Edition</a></span><span class="status" data-status="final"></span><div class="abstract"> <p>This SRFI defines immutable deques. A deque is
a double-ended queue, a sequence which allows elements to be added or
removed efficiently from either end. A structure is immutable when all
its operations leave the structure unchanged. Note that none of the
procedures specified here ends with an exclamation point.</div></li>
<li class="card final"><a class="card-anchor" href="srfi-133/"></a><a href="srfi-133/"><span class="number">133</span></a>: <span class="name">Vector Library (R7RS-compatible)</span><span class="authors">, by John Cowan</span><span class="based-on">Based on SRFI 43 by Taylor Campbell.</span><span class="date-group">Final: <span class="date">2016-03-20</span></span><span class="keywords" data-keywords="data-structure,r7rs-large,r7rs-large-red">Keywords: <a href="https://srfi.schemers.org/?keywords=data-structure">Data Structure</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large">R7RS Large</a>, <a href="https://srfi.schemers.org/?keywords=r7rs-large-red">R7RS Large: Red Edition</a></span><span class="library-name">Library name: vectors</span><span class="status" data-status="final"></span><span class="see-also">See also <a href="/srfi-43/">SRFI 43: Vector library</a> and <a href="/srfi-160/">SRFI 160: Homogeneous numeric vector libraries</a>.</span><div class="abstract"> <p>This SRFI proposes a comprehensive library of