Comparison

(\x y -> x^2 + y^2) 3 4
-> 25

((lambda (x y) (+ (* x x) (* y y))) 3 4)
-> 25

((lambda (x y) (+ (* x x) (* y y))) 3 4)
-> 25

((fn[x y] (+ (* x x) (* y y))) 3 4)
-> 25

sos = (\x y -> x^2 + y^2)
sos 3 4
-> 25

in ghci 'let' is needed. 

(setq sos (lambda (x y) (+ (* x x) (* y y)))
(funcall sos 3 4)
-> 25

(let ((sos (lambda (x y) (+ (* x x) (* y y)))))
(sos 3 4))
-> 25
(sos 3 4)
-> unbound variable: sos 

(let ((sos (lambda (x y) (+ (* x y) (* y y)))))
(funcall sos 3 4))
-> 25
(funcall sos 3 4)
-> The variable SOS is unbound

sos x y = x^2 + y^2
sos 3 4
-> 25 

let sos x y = x^2 + y^2 in
sos 3 4
-> 25 

(labels ((sos (x y) (+ (* x x) (* y y))))
(sos 3 4))
-> 25
(sos 3 4)
-> undefined function sos 

(cons 3 '(1 4 1 5 9 2))
-> (3 1 4 1 5 9 2)

(conj '(1 4 1 5 9 2) 3)
-> (3 1 4 1 5 9 2) 

(use srfi-1)
(take '(3 1 4 1 5 9 2) 5)
-> (3 1 4 1 5)

(labels
((take (n ls)
(if (or (<= n 0) (null ls)) nil
(cons (car ls) (take (1- n) (cdr ls))))))
(take 5 '(3 1 4 1 5 9 2)))
->  (3 1 4 1 5)

(subseq '(3 1 4 1 5 9 2) 0 5)
-> (3 1 4 1 5) 

(labels
((drop (n ls)
(if (or (<= n 0) (null ls)) ls
(drop (1- n) (cdr ls)))))
(drop 5 '(3 1 4 1 5 9 2)))
-> (9 2)

(letrec
((take-while
(lambda (p ls)
(if (p (car ls))
(cons (car ls) (take-while p (cdr ls)))
'()))))
(take-while odd? '(3 1 4 1 5 9 2)))
-> (3 1)

(letrec
((drop-while
(lambda (p ls)
(if (p (car ls))
(drop-while p (cdr ls))
ls))))
(drop-while odd? '(3 1 4 1 5 9 2)))
-> (4 1 5 9 2)

(map (lambda (x) (* x x)) '(3 1 4 1 5 9 2))
-> (9 1 16 1 25 81 4)

(map #(* % %) '(3 1 4 1 5 9 2))
-> (9 1 16 1 25 81 4)

x2y x y = x^2 + y
foldr x2y 5 [3,1,4,1]
-> 32

(define (x2y x y) (+ (* x x) y))
(fold x2y 5 '(3 1 4 1))
-> 32

(defun x2y (x y) (+ (* x x) y))
(reduce #'(lambda (y x) (x2y x y)) '(3 1 4 1) :initial-value 5)
-> 32

(define (x2y x y) (+ (* x x) y))
(letrec
((fold-left
(lambda (f h ls)
(if (null? ls) h
(fold-left f (f h (car ls)) (cdr ls))))))
(fold-left x2y 3 '(1 4 1 5)))
-> 117007494 

[R6RS] has fold-left 

(defun x2y (x y) (+ (* x x) y))
(reduce #'x2y '(1 4 1 5) :initial-value 3)
-> 117007494

(some #(= % 2) '(3 1 4 1 5 9 2))
-> true
(some #(= % 7) '(3 1 4 1 5 9 2))
-> nil

any even [3,1,4,1]
-> True
any even [3,5,7,9]
-> False 

(any even? '(3 1 4 1))
-> #t
(any even? '(3 5 7 9))
-> #f

(use srfi-1)
(every odd? '(3 1 4 1))
-> #f
(every odd? '(3 5 7 9))
-> #t

(range 5)
-> (0 1 2 3 4) 

(range 2 7)
->  (2 3 4 5 6)

sum [3,1,4,1,5]
-> 14

foldl (+) 0 [3,1,4,1,5]
-> 14 

(apply + '(3 1 4 1 5))
-> 14

(fold-right + 0 '(3 1 4 1 5))
-> 14 

(apply #'+ '(3 1 4 1 5))
-> 14

(reduce #'+ '(3 1 4 1 5))
-> 14 

(apply + '(3 1 4 1 5))
-> 14

(reduce + 0 '(3 1 4 1 5))
-> 14 

x2 x = 2 * x
le100 x = 100 <= x
takeWhile (not . le100) $ iterate x2 1
-> [1,2,4,8,16,32,64] 

(defun x2 (x) (* 2 x))
(defun le100 (x) (<= 100 x))
(labels
((unfold (p f g s)
(if (funcall p s) nil
(cons (funcall f s)
(unfold p f g (funcall g s))))))
(unfold #'le100 #'x2 1))
-> (1 2 4 8 16 32 64)

(fun x y -> x*x + y*y) 3 4;;
-> int = 25

let sos = fun x y -> x*x + y*y;;
sos 3 4;;
-> int = 25

function(){
var sos = function(x, y){return x*x + y*y};
return sos(3, 4);
}()
-> 25
sos(3,4)
-> sos is not defined

(() => {
var sos = (x:Int, y:Int) => x*x + y*y
sos(3, 4)
})()
-> Int = 25
sos(3, 4)
-> not found: value sos 

let sos = fun x y -> x*x + y*y in sos 3 4
-> int = 25
sos 3 4;;
-> The value or constructor 'sos' is not defined 

def x2y(x:Int, y:Int) = x*x + y
List(3,1,4,1).foldRight(5){x2y}
-> Int = 32

(List(3,1,4,1) :\ 5){x2y}
-> Int = 32

def x2y(x:Int, y:Int) = x*x + y
List(1,4,1,5).foldLeft(3){x2y}
-> Int = 117007494

(3 /: List(1,4,1,5)){x2y}
-> Int = 117007494 

Steeel Bank Common Lisp (SBCL)
CLISP
GNU Common Lisp (GCL)
Allegro CL
LispWorks
CMUCL
Clozure Common Lisp (Clozure CL) 

(exit)

(quit)

(System/exit 0)

^D

exit

:quit 

:l hoge.hs

:l hoge

#load "hoge.fsx"

note:
.fs is used for things belonging to some name space. use .fsx if you want it as just a script. 

$ cat args.scm
(define (main args)
(print args)
(print (car args))
(print (cdr args)))
$ gosh args.scm a b c
(args.scm a b c)
args.scm
(a b c)

:{
:} 

eq?