Intermediate Student Language

• PROGRAM
  • DEF-OR-EXP ...
• DEF-OR-EXP
  • DEFINITION
  • EXPRESSION
  • REQUIRE
• DEFINITION
  • (define (NAME NAME NAME ...) EXPRESSION)
  • (define NAME EXPRESSION)
  • (define NAME (lambda (NAME NAME ...) EXPRESSION))
  • (define-struct NAME (NAME ...))
• EXPRESSION
  • (local (DEFINITION ...) EXPRESSION)
  • (letrec ((NAME EXPRESSION-FOR-LET) ...) EXPRESSION)
  • (let ((NAME EXPRESSION-FOR-LET) ...) EXPRESSION)
  • (let* ((NAME EXPRESSION-FOR-LET) ...) 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 ...)
  • (time EXPRESSION)
  • empty
  • NAME
  • 'QUOTED
  • `QUASIQUOTED
  • NUMBER
  • true
  • false
  • STRING
  • CHARACTER
• EXPRESSION-FOR-LET
  • EXPRESSION
  • (lambda (NAME NAME ...) EXPRESSION)
• NAME
  • a sequence of keyboard characters not including: space " , ' ` ( ) [ ] { } | ; #
• QUOTED
  • NAME
  • NUMBER
  • STRING
  • CHARACTER
  • (QUOTED ...)
  • 'QUOTED
  • `QUOTED
  • ,QUOTED
  • ,@QUOTED
• QUASIQUOTED
  • NAME
  • NUMBER
  • STRING
  • CHARACTER
  • (QUASIQUOTED ...)
  • 'QUASIQUOTED
  • `QUASIQUOTED
  • ,EXPRESSION
  • ,@EXPRESSION
• REQUIRE
  • (require STRING)
  • (require (lib STRING STRING ...))
  • (require (planet STRING (STRING STRING NUMBER NUMBER)))
• 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) (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)
  • Higher-Order Functions
    • andmap : ((X -> boolean) (listof X) -> boolean)
    • apply : ((X-1 ... X-N -> Y) X-1 ... X-i (list X-i+1 ... X-N) -> Y)
    • build-list : (nat (nat -> X) -> (listof X))
    • build-string : (nat (nat -> char) -> string)
    • compose : ((Y-1 -> Z) ... (Y-N -> Y-N-1) (X-1 ... X-N -> Y-N) -> (X-1 ... X-N -> Z))
    • filter : ((X -> boolean) (listof X) -> (listof X))
    • foldl : ((X Y -> Y) Y (listof X) -> Y)
    • foldr : ((X Y -> Y) Y (listof X) -> Y)
    • for-each : ((any ... -> any) (listof any) ... -> void)
    • map : ((X ... -> Z) (listof X) ... -> (listof Z))
    • memf : ((X -> boolean) (listof X) -> (union false (listof X)))
    • ormap : ((X -> boolean) (listof X) -> boolean)
    • procedure? : (any -> boolean)
    • quicksort : ((listof X) (X X -> boolean) -> (listof X))

This language is a superset of Beginning Student with List Abbreviations.