BeginnerLanguage

== Beginning Student Language ==

Matthias Felleisen extracted this for us from the PLT Scheme HelpDesk documentation.

* PROGRAM
* DEF-OR-EXP ...
* DEF-OR-EXP
* DEFINITION
* EXPRESSION
* DEFINITION
* (define (NAME NAME NAME ...) EXPRESSION)
* (define NAME EXPRESSION)
* (define NAME (lambda (NAME NAME ...) EXPRESSION)) 
* (define-struct NAME (NAME ...)) 
* EXPRESSION
* (NAME EXPRESSION EXPRESSION ...)
* (PRIM-OP EXPRESSION ...)
* (cond (EXPRESSION EXPRESSION) (EXPRESSION EXPRESSION) ...)
* (cond (EXPRESSION EXPRESSION) ... (else EXPRESSION))
* (if EXPRESSION EXPRESSION EXPRESSION)
* (and EXPRESSION EXPRESSION EXPRESSION ...)
* (or EXPRESSION EXPRESSION EXPRESSION ...)
* empty
* NAME
* 'NAME
* NUMBER
* true
* false
* STRING
* CHARACTER
* NAME
* a sequence of keyboard characters not including: space " , ' ` ( ) [ ] { } | ; # 
* PRIM-OPs
* Numbers: Integers, Rationals, Reals, Complex, Exacts, Inexacts
* * : (num num num ... -> num)
* + : (num num num ... -> num)
* - : (num num ... -> num)
* / : (num num num ... -> num)
* < : (real real real ... -> boolean)
* <= : (real real real ... -> boolean)
* = : (num num num ... -> boolean)
* > : (real real real ... -> boolean)
* >= : (real real ... -> boolean)
* abs : (real -> real)
* acos : (num -> num)
* add1 : (number -> number)
* angle : (num -> real)
* asin : (num -> num)
* atan : (num -> num)
* ceiling : (real -> int)
* complex? : (any -> bool)
* conjugate : (num -> num)
* cos : (num -> num)
* cosh : (num -> num)
* current-seconds : (-> int)
* denominator : (rat -> int)
* e : real
* even? : (integer -> bool)
* exact->inexact : (num -> num)
* exact? : (num -> bool)
* exp : (num -> num)
* expt : (num num -> num)
* floor : (real -> int)
* gcd : (int int ... -> int)
* imag-part : (num -> real)
* inexact->exact : (num -> num)
* inexact? : (num -> bool)
* integer->char : (int -> char)
* integer? : (any -> bool)
* lcm : (int int ... -> int)
* log : (num -> num)
* magnitude : (num -> real)
* make-polar : (real real -> num)
* max : (real real ... -> real)
* min : (real real ... -> real)
* modulo : (int int -> int)
* negative? : (number -> bool)
* number->string : (num -> string)
* number? : (any -> boolean)
* numerator : (rat -> int)
* odd? : (integer -> bool)
* pi : real
* positive? : (number -> bool)
* quotient : (int int -> int)
* random : (int -> int)
* rational? : (any -> bool)
* real-part : (num -> real)
* real? : (any -> bool)
* remainder : (int int -> int)
* round : (real -> int)
* sgn : (real -> (union 1 #i1.0 0 #i0.0 -1 #i-1.0))
* sin : (num -> num)
* sinh : (num -> num)
* sqr : (num -> num)
* sqrt : (num -> num)
* sub1 : (number -> number)
* tan : (num -> num)
* zero? : (number -> bool)
* Booleans
* boolean=? : (boolean boolean -> boolean)
* boolean? : (any -> boolean)
* not : (boolean -> boolean)
* Symbols
* symbol->string : (symbol -> string)
* symbol=? : (symbol symbol -> boolean)
* symbol? : (any -> boolean)
* Lists
* append : ((listof any) ... -> (listof any))
* assq : (X (listof (cons X Y)) -> (union false (cons X Y)))
* caaar : ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> W)
* caadr : ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> (listof Z))
* caar : ((cons (cons Z (listof Y)) (listof X)) -> Z)
* cadar : ((cons (cons W (cons Z (listof Y))) (listof X)) -> Z)
* cadddr : ((listof Y) -> Y)
* caddr : ((cons W (cons Z (cons Y (listof X)))) -> Y)
* cadr : ((cons Z (cons Y (listof X))) -> Y)
* car : ((cons Y (listof X)) -> Y)
* cdaar : ((cons (cons (cons W (listof Z)) (listof Y)) (listof X)) -> (listof Z))
* cdadr : ((cons W (cons (cons Z (listof Y)) (listof X))) -> (listof Y))
* cdar : ((cons (cons Z (listof Y)) (listof X)) -> (listof Y))
* cddar : ((cons (cons W (cons Z (listof Y))) (listof X)) -> (listof Y))
* cdddr : ((cons W (cons Z (cons Y (listof X)))) -> (listof X))
* cddr : ((cons Z (cons Y (listof X))) -> (listof X))
* cdr : ((cons Y (listof X)) -> (listof X))
* cons : (X (listof X) -> (listof X))
* cons? : (any -> boolean)
* eighth : ((listof Y) -> Y)
* empty? : (any -> boolean)
* fifth : ((listof Y) -> Y)
* first : ((cons Y (listof X)) -> Y)
* fourth : ((listof Y) -> Y)
* length : (list -> number)
* list : (any ... (listof any) -> (listof any))
* list : (any ... -> (listof any))
* list* : (any ... (listof any) -> (listof any))
* list-ref : ((listof X) natural-number -> X)
* member : (any list -> (union false list))
* memq : (any list -> (union false list))
* memv : (any list -> (union false list))
* null : empty
* null? : (any -> boolean)
* pair? : (any -> boolean)
* rest : ((cons Y (listof X)) -> (listof X))
* reverse : (list -> list)
* second : ((cons Z (cons Y (listof X))) -> Y)
* seventh : ((listof Y) -> Y)
* sixth : ((listof Y) -> Y)
* third : ((cons W (cons Z (cons Y (listof X)))) -> Y)
* Posns
* make-posn : (number number -> posn)
* posn-x : (posn -> number)
* posn-y : (posn -> number)
* posn? : (anything -> boolean)
* Characters
* char->integer : (char -> integer)
* char-alphabetic? : (char -> boolean)
* char-ci<=? : (char char ... -> boolean)
* char-ci : (char char ... -> boolean)
* char-ci=? : (char char ... -> boolean)
* char-ci>=? : (char char ... -> boolean)
* char-ci>? : (char char ... -> boolean)
* char-downcase : (char -> char)
* char-lower-case? : (char -> boolean)
* char-numeric? : (char -> boolean)
* char-upcase : (char -> char)
* char-upper-case? : (char -> boolean)
* char-whitespace? : (char -> boolean)
* char<=? : (char char ... -> boolean)
* char : (char char ... -> boolean)
* char=? : (char char ... -> boolean)
* char>=? : (char char ... -> boolean)
* char>? : (char char ... -> boolean)
* char? : (any -> boolean)
* Strings
* format : (string any ... -> string)
* list->string : ((listof char) -> string)
* make-string : (nat char -> string)
* string : (char ... -> string)
* string->list : (string -> (listof char))
* string->number : (string -> (union number false))
* string->symbol : (string -> symbol)
* string-append : (string ... -> string)
* string-ci<=? : (string string ... -> boolean)
* string-ci : (string string ... -> boolean)
* string-ci=? : (string string ... -> boolean)
* string-ci>=? : (string string ... -> boolean)
* string-ci>? : (string string ... -> boolean)
* string-copy : (string -> string)
* string-length : (string -> nat)
* string-ref : (string nat -> char)
* string<=? : (string string ... -> boolean)
* string : (string string ... -> boolean)
* string=? : (string string ... -> boolean)
* string>=? : (string string ... -> boolean)
* string>? : (string string ... -> boolean)
* string? : (any -> boolean)
* substring : (string nat nat -> string)
* Images
* image=? : (image image -> boolean)
* image? : (any -> boolean)
* Misc
* =~ : (real real non-negative-real -> boolean)
* eof : eof
* eof-object? : (any -> boolean)
* eq? : (any any -> boolean)
* equal? : (any any -> boolean)
* equal~? : (any any non-negative-real -> boolean)
* eqv? : (any any -> boolean)
* error : (symbol string -> void)
* exit : (-> void)
* identity : (any -> any)
* struct? : (any -> boolean)