[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
feature list for workshop (long message)
List of features to be considered at the workshop.
For each of the following features (e.g. special forms, data types,
and procedures) should the feature be
essential -- every implementation of Scheme must have it.
Programs written in Essential Scheme will run on any
implementation of Scheme worthy of the name.
optional -- not every implementation of Scheme will have it,
but all implementations that have the feature will use
the same syntax and semantics for the feature. Code that
makes use of optional features will run on any
implementation of Scheme that supplies the optional
features.
extended -- not every implementation of Scheme will have it,
and the feature's syntax and semantics may vary even
among implementations that have the feature. Code that
makes use of extended features is not portable. (E.g. at
the moment input and output is an extended feature.)
----------------------------------------------------------------
Lexical features
The space character is a whitespace character.
The tab character is a whitespace character.
The newline character is a whitespace character.
The carriage return character is a whitespace character.
The line feed character is a whitespace character.
The form feed character is a whitespace character.
Any whitespace character is a delimiter.
Left parenthesis is a delimiter.
Right parenthesis is a delimiter.
Left bracket is a delimiter.
Right bracket is a delimiter.
Left curly brace is a delimiter.
Left parenthesis is a delimiter.
Right curly brace is a delimiter.
Semicolon is a delimiter.
Single quote is a delimiter.
Double quote is a delimiter.
Backquote is a delimiter.
End of file is a delimiter.
Backslash is an escape character.
Lists are opened by left parentheses and closed by right
parentheses.
When notating lists, matching left and right brackets are
stylistic alternatives to matching left and right parentheses.
Conses may be notated as (x . y), where y is any object.
Possibly improper lists may be notated as (... x . y).
Strings are delimited by double quotes.
Double quotes may be included inside strings by escaping them.
Quote marks have the meanings we have grown to know and love.
Backquote and comma work as we are accustomed.
With a backquoted list, comma at-sign works as we are accustomed.
Comments are opened by semicolons and closed by end of line
characters.
Sharp sign macros are introduced by a sharp sign.
Unreadable objects are printed using sharp sign notation. (We
need to agree whether the notation is #{...} or #<...>.)
Vectors may be written using sharp sign notation. (We need to
agree whether the notation is #(...) or something else.)
Binary numbers may be written using the #b notation.
Octal numbers may be written using the #o notation.
Decimal numbers may be written using the #d notation.
Hexadecimal numbers may be written using the #x notation.
Special characters may be written using the #\ notation. (We
need to agree on the names for the special characters using this
notation.)
Miscellaneous objects may be written using the #[...] syntax.
Miscellaneous objects may be written using the #! syntax.
Integers may be written in the usual way, with or without signs.
Floating point numbers may be written using decimal points. (We
need to agree on the notation.)
Floating point numbers may be written using exponents. (We need
to agree on the notation.)
Symbols may be written as sequences of characters that contain no
special characters and begin with a character that cannot begin a
number.
Sequences of characters containing no special characters are
interpreted as numbers if possible; if not possible they are
interpreted as symbols.
When the 26 letters of the alphabet are used to write a symbol,
case is immaterial unless the letter is slashified.
----------------------------------------------------------------
Special variables (constants?)
nil evaluates to the empty list.
nil evaluates to some false value.
t evaluates to some true value.
else evaluates to some true value.
----------------------------------------------------------------
Special forms
quote
lambda (with a proper list of bound variables)
lambda (with a symbol in place of a list of bound variables)
lambda (with a possibly improper list of bound variables)
lambda (with destructuring -- we need to agree on pattern syntax)
mulambda
let
let*
labels or letrec
rec
named-lambda
if
cond
case
and or conjunction
or or disjunction
locale
make-environment
the-environment
access
defrec (such that (defrec i e) means (define i (rec i e)))
define (with what semantics?)
set or set!
do or step
iterate
block or sequence or begin
block0 or begin0
catch (with dynamic extent restriction)
catch (without dynamic extent restriction)
throw
delay (memoized)
force (memoized)
freeze (not memoized)
thaw (not memoized)
locative
fluid-lambda
fluid
fluid-set!
fluid-let or bind
fluid-bound?
dynamic-wind
unwind-protect
define-constant
define-integrable
define-syntax or ...
----------------------------------------------------------------
Data types
The essential data types are disjoint.
There is an object nil that represents false and the empty list.
Procedures are a kind of object.
Numbers are a kind of object.
Symbols are a kind of object.
Pairs (conses?) are a kind of object.
Structures are a kind of object.
Characters are a kind of object.
Strings are a kind of object.
Vectors are a kind of object.
Bytevectors are a kind of object.
Streams (channels? ports?) are a kind of object.
Locales (environments?) are a kind of object.
Syntax tables are a kind of object.
Macros are a kind of object.
Locatives (refs?) are a kind of object.
----------------------------------------------------------------
Procedures
NULL? NULL? null? null?
NIL?
NOT NOT not not
PROCEDURE? APPLICABLE? procedure? proc?
APPLY APPLY apply apply
call-with-current-continuation call/cc
NUMBER? NUMBER? number? number?
INTEGER? INTEGER? fix?
RATIO?
FLOAT? float?
ODD? ODD?
EVEN? EVEN?
1+ 1+ 1+
ADD1 add1 add1
-1+ -1+ 1-
SUBTRACT1 sub1 sub1
+ (...) + (...) + (2) + (2)
plus (...)
- (2) - (...) - (2) - (2)
- (1) -- (1) minus (1)
* (...) * (...) * (2) * (2)
times (...)
/ / (...) /
DIV QUOTIENT / /
REMAINDER REMAINDER remainder remainder
MOD
INTEGER-DIVIDE
ABS ABS abs abs
GCD GCD
MIN (...) MIN (...) min (...) min (...)
MAX (...) MAX (...) max (...) max (...)
random (1) random (1)
= = =? =
EQUAL?
< < <? <
LESS?
> > >? >
GREATER?
N=
NOT-EQUAL?
>= >= >=? >=
NOT-LESS?
<= <= <=? <=
NOT-GREATER?
=0? 0? =0
ZERO? ZERO?
<0? <0
NEGATIVE? NEGATIVE?
>0? >0
POSITIVE? POSITIVE?
N=0?
NOT-ZERO?
>=0?
NOT-NEGATIVE?
<=0?
NOT-POSITIVE?
EXP EXP exp
LOG LOG log
EXPT EXPT expt
SQRT SQRT sqrt
SIN SIN sin
COS COS cos
TAN TAN tan
ASIN arcsin
ACOS arccos
arctan
ATAN2 ATAN
LOGAND logand
LOGIOR logior
LOGXOR logxor
LOGNOT lognot
lsh
rot
ASH
BIT-FIELD
SET-BIT-FIELD
->INTEGER fix
->FLOAT float
FLOOR
CEILING
TRUNCATE
ROUND
All trigonometric functions take their arguments in radians.
SYMBOL? SYMBOL? symbol? symbol?
EQ? EQ? eq? eq?
NEQ?
SYMBOL->STRING pname
ascii symbol->ascii
STRING->SYMBOL
CONCATENATE-SYMBOL concat
ALPHALESS? alphaless? alpha<
EXPLODE explode
IMPLODE implode
GENERATE-SYMBOL GENERATE-UNINTERNED-SYMBOL
gensym gensym
PAIR? PAIR? cons? pair? (?)
ATOM? ATOM? atom? atom? (?)
LIST?
PROPER-LIST? LIST?
ALIKE?
ALIKEQ?
ALIKEV? EQUAL? equal? equal?
CONS CONS cons cons
LIST LIST list list
CONS* LIST*
COPY-LIST
copy
CAR CAR car car
CDR CDR cdr cdr
C....R C....R c..r c...r
NTH LIST-REF nth
NTHCDR LIST-TAIL
NTH
NTHCDR
LAST
LASTCDR LAST last-pair
FIRST
SECOND
THIRD
FOURTH
FIFTH
SIXTH
SEVENTH
EIGHTH
SET-CAR! set-car! set-car!
SET-CDR! set-cdr! set-cdr!
LENGTH LENGTH length length
APPEND (...) APPEND (>=2) append (2) append (>=2)
APPEND! (...) append! (>=2)
REVERSE REVERSE reverse reverse
REVERSE! reverse!
SUBLIST
SUBST
SUBSTQ
SUBSTV
subst
COPY-TREE
MEM?
MEMQ?
MEMQ memq memq
MEMV
MEMBER member member
ASS
ASSQ ASSQ assq assq
ASSV
ASSOC assoc assoc
ANY?
EVERY?
DEL
DELQ
DEL!
DELQ! delq!
delete!
MAP MAPCAR mapcar mapcar
MAPCDR
MAP!
WALK MAPC mapc mapc
WALKCDR
TREE-HASH
The car of nil is nil.
The cdr of nil is nil.
STRING? string? string?
string-equal?
ALPHALESS? alphaless? alpha<
MAKE-STRING
STRING-APPEND
COPY-STRING
CHAR->STRING
LIST->STRING list-to-string
STRING->LIST string-to-list
STRING-LENGTH
STRING-EMPTY?
STRING-ELT
NTHCHAR
et cetera
VECTOR? VECTOR? vector?
vector-equal?
MAKE-VECTOR
VECTOR
VECTOR-CONS vector-cons
LIST->VECTOR list-to-vector
VECTOR->LIST vector-to-list
VECTOR-ELT VECTOR-REF vector-ref
VREF
VSET VECTOR-SET! vector-set!
COPY-VECTOR
VECTOR-FILL
VECTOR-REPLACE
VECTOR-LENGTH VECTOR-SIZE vector-length
VECTOR-POS
VECTOR-POSQ
WALK-VECTOR
----------------------------------------------------------------
Input and output
All input and output is routed through the stream to which
certain distinguished variables are bound.
There is a way to read an object from the standard input.
There is a way to write objects to the standard output, with
slashification.
There is a way to write objects to the standard output, without
slashification.
There is a way to write a string to the standard output, without
the double quotes.
There is a way to write an end of line to the standard output.
There is a way to read a character from the standard input.
There is a way to peek at a character from the standard input.
There is a way to write a character to the standard output.
There is a way to open a file for input.
There is a way to open a file for output.
There is a way to close an open file.
There is a way to test for end of file on an open input file.
There is a way to test if an object that has been read is the end
of file.
There is a way to pretty print an object on the standard output.
There is a way to pretty print some approximation to the
definition of a procedure on the standard output.
There is a way to generate a transcript file.