program	 	=	 	def-or-expr ...
 	 	 	 	 
  def-or-expr	 	=	 	definition
 	 	|	 	expr
 	 	|	 	test-case
 	 	|	 	library-require
 	 	 	 	 
  definition	 	=	 	(define (name variable ...) expr)
 	 	|	 	(define name expr)
 	 	|	 	(define-struct name (name ...))
 	 	|	 	(define-datatype name (name name ...) ...)
 	 	 	 	 
  expr	 	=	 	(begin expr expr ...)
 	 	|	 	(begin0 expr expr ...)
 	 	|	 	(set! variable expr)
 	 	|	 	(delay expr)
 	 	|	 	(lambda (variable ...) expr)
 	 	|	 	(λ (variable ...) expr)
 	 	|	 	(local [definition ...] expr)
 	 	|	 	(letrec ([name expr] ...) expr)
 	 	|	 	(shared ([name expr] ...) expr)
 	 	|	 	(let ([name expr] ...) expr)
 	 	|	 	(let name ([name expr] ...) expr)
 	 	|	 	(let* ([name expr] ...) expr)
 	 	|	 	(recur name ([name expr] ...) expr)
 	 	|	 	(expr expr ...)
 	 	|	 	(cond [expr expr] ... [expr expr])
 	 	|	 	(cond [expr expr] ... [else expr])
 	 	|	 	(case expr [(choice choice ...) expr] ...
           [(choice choice ...) expr])
 	 	|	 	(case expr [(choice choice ...) expr] ...
           [else expr])
 	 	|	 	(match expr [pattern expr] ...)
 	 	|	 	(if expr expr expr)
 	 	|	 	(when expr expr)
 	 	|	 	(unless expr expr)
 	 	|	 	(and expr expr expr ...)
 	 	|	 	(or expr expr expr ...)
 	 	|	 	(time expr)
 	 	|	 	name
 	 	|	 	’quoted
 	 	|	 	‘quasiquoted
 	 	|	 	’()
 	 	|	 	number
 	 	|	 	boolean
 	 	|	 	string
 	 	|	 	character
 	 	 	 	 
  choice	 	=	 	name
 	 	|	 	number
 	 	 	 	 
  pattern	 	=	 	_
 	 	|	 	name
 	 	|	 	number
 	 	|	 	true
 	 	|	 	false
 	 	|	 	string
 	 	|	 	character
 	 	|	 	’quoted
 	 	|	 	‘quasiquoted-pattern
 	 	|	 	(cons pattern pattern)
 	 	|	 	(list pattern ...)
 	 	|	 	(list* pattern ...)
 	 	|	 	(struct id (pattern ...))
 	 	|	 	(vector pattern ...)
 	 	|	 	(box pattern)
 	 	 	 	 
  quasiquoted-pattern	 	=	 	name
 	 	|	 	number
 	 	|	 	string
 	 	|	 	character
 	 	|	 	(quasiquoted-pattern ...)
 	 	|	 	’quasiquoted-pattern
 	 	|	 	‘quasiquoted-pattern
 	 	|	 	,pattern
 	 	|	 	,@pattern
 	 	 	 	 
  quoted	 	=	 	name
 	 	|	 	number
 	 	|	 	string
 	 	|	 	character
 	 	|	 	(quoted ...)
 	 	|	 	’quoted
 	 	|	 	‘quoted
 	 	|	 	,quoted
 	 	|	 	,@quoted
 	 	 	 	 
  quasiquoted	 	=	 	name
 	 	|	 	number
 	 	|	 	string
 	 	|	 	character
 	 	|	 	(quasiquoted ...)
 	 	|	 	’quasiquoted
 	 	|	 	‘quasiquoted
 	 	|	 	,expr
 	 	|	 	,@expr
 	 	 	 	 
  test-case	 	=	 	(check-expect expr expr)
 	 	|	 	(check-random expr expr)
 	 	|	 	(check-within expr expr expr)
 	 	|	 	(check-error expr expr ...)
 	 	|	 	(check-member-of expr expr expr)
 	 	|	 	(check-satisfied expr expr)
 	 	|	 	(check-range expr expr)
 	 	|	 	(check-range expr)
 	 	 	 	 
  library-require	 	=	 	(require string)
 	 	|	 	(require (lib string string ...))
 	 	|	 	(require (planet string package))
 	 	 	 	 
  package	 	=	 	(string string number number)

A name or a variable is a sequence of characters not including a space or one of the
 following:
   " , ' ` ( ) [ ] { } | ; #
A number is a number such as 123, 3/2, or 5.5.
A boolean is one of: #true or #false. Alternative spellings for the #true constant 
  are #t, true, and #T. Similarly, #f, false, or #F are also recognized as #false.
A symbol is a quote character followed by a name. A symbol is a value, just like 42,
  '(), or #false.
A string is a sequence of characters enclosed by a pair of ". Unlike symbols, 
  strings may be split into characters and manipulated by a variety of functions. 
  For example, "abcdef", "This is a string", and "This is a string with \\" inside" 
  are all strings.
A character begins with #\\ and has the name of the character. For example, #\\a, #\\b, 
  and #\\space are characters.
In function calls, the function appearing immediately after the open parenthesis can 
  be any functions defined with define or define-struct, or any one of the 
  pre-defined functions.