Good Site: http://www.cs.hut.fi/Studies/T-93.210/schemetutorial/schemetutorial.html

-= Syntax =-
- (operator operands)
- ; comments

> (define a 5)
> a
5


(if (< a 10)
    1
    a)


-= Procedures =-
- Created by lambda's
- (lambda (x) (* x x))
- ((lambda (x) (* x x)) 5)


-= Conditionals =-
(if condition consequent)
  or
(if condition consequent alternative)

(cond ( (cond1) (do something) )
      ( (cond2) (do something) )
      ( (cond3) (do something) )
      ...
      (else (do something) )
)

(cond ((< a 10) a)
      ((> a 20) (* a a))
      (else 0))

(case key clause1 clause2 ...)
key => any expression
clause => ((datanum1 ...) expression)

eg:
(case (+ 3 4)
    ((7) 'seven)
    ((2) 'two)
    (else 'nothing))

seven


(case 'a
    ((a b c d) 'first)
    ((e f g h) 'second)
    (else 'rest))

first


-= Lambda =-
(define fib
  (lambda (n)
    (cond ((= n 0) 0)  
          ((= n 1) 1)
          (else (+ (fib (- n 1))
                   (fib (- n 2)))))))

(define sum
  (lambda (x . y)
    (apply + x y)))



-= Let =-
(let ((var1 exp1) 
      (var2 exp2) 
      .
      .
      . 
      (varn expn))
  body)

syntactic sugar for

((lambda (var1 var2 ... varn)
   body)
 exp1 exp2 ... expn)


eg.
(let ((x 2) (y 10)) (+ x y))
((lambda (x y) (+ x y)) 2 10)




-= Logic =-
(and expr1 expr2 ...)
(or expr1 expr2 ...)
(not expr)
(and #t #f)
(or #t #f)



-= Quote =-
- Used when you want symbols rather than numbers
(quote a)
  or
'a
- Can be used to have a list not evaluated:
  (a 1 2) would be '(a 1 2)
  


----------------------------
----------------------------

EXAMPLE -> Factorial (recursive vs tail recursive)

; Normal recursion
(define fact
  (lambda (x)
    (if (= x 1)
        1
        (* x (fact (- x 1))))))

(fact 10000)

; Tail recursion
(define fact
  (lambda (n)
    (define iter
      (lambda (product counter)
        (if (> counter n)
            product
            (iter (* product counter) (+ counter 1)
                  ))))
    (iter 1 1)))


----------------------------


EXAMPLE -> Return the max clause sum in a list of clauses:

(define count_clause
  (lambda (cls)
    (if (null? cls)
        0
        (+ (car cls) (count_clause (cdr cls))))))

(define max_list_sum
  (lambda (lst)
    (if (null? lst)
        0
        (let ((val1 (count_clause (car lst)))
              (val2 (max_list_sum (cdr lst))))
          (if (> val1 val2)
              val1
              val2)))))


----------------------------


EXAMPLE -> Generate a list of random numbers

(define rand_list
  (lambda (size max)
    (if (= size 0)
        '()
        (cons (random max) (rand_list (- size 1) max)))
    ))
    

----------------------------


EXAMPLE -> Adjust a list of ints to random sign

(define rand_sign
  (lambda () (if (= (random 2) 1) 1 -1)))

(define rand_sign_list
  (lambda (lst)
    (if (null? lst)
        '()
        (cons (* (rand_sign) (car lst)) (rand_sign_list (cdr lst))))))

----------------------------
----------------------------