exprがペアならば #t 、そうでなければ、#fを返す。
リストもペアに含まれるます。

>(pair? 1)
#f
>(pair? (cons 1 2))
#t
>(pair? (list 1 2))
#t
>(pair? '(1 2))
#t
>(pair? '(1 . 2))
#t
>(pair? '())
#f

空リスト '() ならば #t 、そうでなければ、#f を返す。

>(null? '())
#t
>(null? "abc")
#f
>(null? '(a b))
#f
>(null? (cdr '(a)))
#t

Schemeでは、nilはあまり使われないようです。

左側に a 、右側に d を持つ新しいペアを作る返す。

ペアとリストの構造を知らないと使いにくいです。

>(cons 1 2)
(1 . 2)
>(cons 1 '())
(1)
>(cons 1 '(1 2))
(1 1 2)
>(cons '(1 2) '(3 4))
((1 2) 3 4)

ペアの最初の要素を返します。ペアがリストならば、リストの最初の要素を返すことになります。

>(car '(1 . 2))
1
>(car '(1 2))
1
>(car '( (a b) c d))
(a b)

ペアの二番目の要素を返します。ペアがリストならば、二番目以降の要素でできたリストを返します。

>(cdr '(1 . 2))
2
>(cdr '(1 2))
(2)
>(cdr '(1 2 3))
(2 3)
>(cdr '(1))
()
>(cdr '())
	error になる

exprがリストならば #t 、そうでなければ #f を返します。
空リストがリストと判定されるのは微妙なところですね。

>(list? 1)
#f
>(list? '(1 2 3))
#t
>(list? '(1 . 2))
#f
>(list? '(1 . (2 . 3)))
#f
>(list? '(1 . (2 . '())))
#t
>(list? '())
#t

exprを要素に持つリストを作成して返却する。

>(list 1 2 3)
(1 2 3)
>(list "abc")
("abc")
>(list '())
(())
>(list)
()

exprからなるペア連鎖を作るが、最後の連鎖の二番目の要素をtailとする。この値を返す。

>(list* 1 2)
(1 . 2)
>(list* 1 2 3)
(1 2 . 3)

　最初がペアがひとつだけ作られる例です。

>(list* 1 2 3 4 5 '())
(1 2 3 4 5)

　(list 1 2 3 4 5) と同じです。

>(list* 1 2 '(3 4 5))
(1 2 3 4 5)

　これが多分、一番標準的な使い方。tailのリストの前にexprを順に追加したリストになります。

　この場合は多分、仕様外でしょう。

リストの要素の数を返します。空リストと () の場合には 0を返します。
lstがリストや空リスト以外の場合、エラーになります。

>(length '())
0
>(length '(1 2 3))
3
>(length '(1 (2 3) 4))
3

リストlstのpos番目の要素を返します。位置は先頭を0として数えます。

>(list-ref (list 'a 'b 'c) 0)
a
>(list-ref (list 'a 'b 'c) 1)
b
>(list-ref (list 'a 'b 'c) 2)
c
>(list-ref (list 'a 'b 'c) 3)
	エラーになります

まるで配列のようにリストを扱えます。構造上後ろに行くほど遅くなりますが…

>(list-ref '(1 . 2) 0)
1
>(list-ref '(1 2 . 3) 1)
2

　実際はペアの連鎖に対しても動作するようです。

リスト lst の pos 番目以降の要素からなるリスト。先頭の要素は0番目とする。

>(list-tail '(1 2 3 4 5 6 7) 0)
(1 2 3 4 5 6 7)
>(list-tail '(1 2 3 4 5 6 7) 3)
(4 5 6 7)
>(list-tail '(1 2 3 4 5 6 7) 6)
(7)
>(list-tail '(1 2 3 4 5 6 7) 7)
()
>(list-tail '(1 2 3 4 5 6 7) 8)
	エラーになります
>(list-tail '() 0)
()
>(list-tail (list* 1 2 3) 0)
(1 2 . 3)
>(list-tail (list* 1 2 3) 1)
(2 . 3)
>(list-tail (list* 1 2 3) 2)
3
>(list-tail (list* 1 2 3) 3)
	エラーになります
>(list-tail (list* 1 2 '()) 2)
()

引数のリストの要素からなるリストを返す。
下で示すように lst がひとつしかない場合の振る舞いは、バグだと思います。

>(append '(1 2))
((1 2))

　本当は、(1 2) のはず。これは困った。

>(append '(1 2) '(3 4 5) '(6 7))
(1 2 3 4 5 6 7)
>(append '(1 2) '())
(1 2)
>(append '(1 2) '() '(3 4))
(1 2 3 4)
>(append '(1 2) '(3 (4 5)) '(6 7))
(1 2 3 (4 5) 6 7)

引数 lst の要素からなるペア連鎖をつくり、最後のペアの二番目の要素を tail とする。tailが()ならば通常のappendと同じ。

>(append '(1 2) 3)
(1 2 . 3)
>(append '(1 2) '(3 4) 5)
(1 2 3 4 . 5)
>(append '(1 2) '())
(1 2)
>(append '(1 2) '(3 4) '())
(1 2 3 4)

　こちらの記法では lst がひとつの場合のバグが出ないようです。tail に'()を書けば、appendのバグ回避に使えそうです。

lst の要素の並びを逆にして返却します。

(reverse '(1 2 3 4 5 6 7))
(7 6 5 4 3 2 1)
(reverse '())
	エラーになります

　lstが () のときにエラーになるのは、痛いです。

lst の要素一つ一つに対して、それを引数に proc を評価し、結果をリストとして返す。
proc の引数が複数ある場合は、その数だけ lst を指定する。最初のproc の引数は、複数のlstの先頭要素を取り出したものになる。
proc は lamda式で書くことが多い。

>(map not '(#t #f #t))
(#f #t #f)
>(map + '(1 2 3) '(4 5 6))
(5 7 9)
>(map + '() '())
()
>(map (lambda (x y)
       (* x y)
     )
     '(2 4 6)
     '(1 3 5)
)
(2 12 30)

lstの要素を順に取り出し、それを引数としてprocを実行する。
本来の仕様では、戻り値は無いはずですが、このインプリメントでは要素数の足りない結果のリストが戻ります。
あえてこの関数を使わずに map を使えばよいかと思います。

lst の要素の先頭から、v に等しい要素を見つけ、その要素以降を要素とするリストを返却する。
見つからなければ #f を返却する。
　要素が「等しい」検定に equal? を用いる。

>(member "神奈川" '("東京" "大阪" "神奈川" "新潟"))
("神奈川" "新潟")
>(member "福岡" '("東京" "大阪" "神奈川" "新潟"))
#f

lst の要素の先頭から、v に等しい要素を見つけ、その要素以降を要素とするリストを返却する。
見つからなければ #f を返却する。
　要素が「等しい」検定に eqv? を用いる。

>(memv 3 '(1 2 3 4))
(3 4)
>(memv 5 '(1 2 3 4))
#f
>(memv "神奈川" '("東京" "大阪" "神奈川" "新潟"))
#f

lst の要素の先頭から、v に等しい要素を見つけ、その要素以降を要素とするリストを返却する。
見つからなければ #f を返却する。
　要素が「等しい」検定に eq? を用いる。

>(memq 3 '(1 2 3 4))
#f
>(memq "神奈川" '("東京" "大阪" "神奈川" "新潟"))
#f
>(define a 4)
a
>(memq a (list 1 2 3 a 5 6))
(4 5 6)
>(define a 4)
a
>(define b a)
b
>(memq a (list 1 2 3 b 5 6))
(4 5 6)

その要素がすべてペアであるリスト lst を順に検索し、要素のペアの先頭要素が vに等しければ、検索を中止し、そのペアを返却する。
　見つからなければ #f を返却する。
　「等しい」検定に equal? を用いる。

>(assoc 2 '((1 . "1st") (2 . "2nd") (3 . "3rd")))
(2 . "2nd")
>(assoc 4 '((1 . "1st") (2 . "2nd") (3 . "3rd")))
#f
>(assoc 2 '((1 "1st" "ss") (2 "2nd" "tt") (3 "3rd" "nn")))
(2 "2nd" "tt")

その要素がすべてペアであるリスト lst を順に検索し、要素のペアの先頭要素が vに等しければ、検索を中止し、そのペアを返却する。
　見つからなければ #f を返却する。
　「等しい」検定に eqv? を用いる。

>(assv 2 '((1 "1st") (2 "2nd") (3 "3rd")))
(2 "2nd")
>(assv 4 '((1 "1st") (2 "2nd") (3 "3rd")))
#f
>(assv "大阪" '(("東京 "1st" ) ("大阪" "2nd") ("名古屋" "3rd")))
#f
>(define a "大阪")
a
>(assv a (list '("東京 "1st" ) (list a "2nd") '("名古屋" "3rd")))
("大阪" "2nd")

その要素がすべてペアであるリスト lst を順に検索し、要素のペアの先頭要素が vに等しければ、検索を中止し、そのペアを返却する。
　見つからなければ #f を返却する。
　「等しい」検定に eq? を用いる。

>(assq 2 '((1 "1st") (2 "2nd") (3 "3rd")))
#f
>(define a "大阪")
a
>(assv a (list '("東京 "1st" ) (list a "2nd") '("名古屋" "3rd")))
("大阪" "2nd")

最初の要素のリストの最初の要素。 以降は、car と cdr の組み合わせの略記法関数が続きます。
名前の先頭に c、最後に r があります。この二つを除いた部分は a と r の組み合わせでできています。
a を car に、d を cdr に置き換え、これらが後ろから順に適用されることになります。
caarならば、car car と並べて、(car (car v))となります。

>(caar '((11 12) (21 22) (31 32)))
11

リストの二番目の要素。

>(cadr '( 1 2 3 4))
2

先頭の要素のリストの二番目以降のリスト。

>(cdar '( (11 12 13) (21 22 23) (31 32 33)))
(12 13)

三番目の要素以降からなるリスト。

>(cddr '(1 2 3 4 5 6 7))
(3 4 5 6 7)

先頭の先頭の先頭の要素。

>(caaar '( ((111 112 113) (121 122 123) )
          ( (211 212 113) (221 222 223) )
        )
)
111

二番目の要素のリストの先頭

>(caadr '( (11 12) (21 22) (31 32) ) )
21

先頭のリストの二番目の要素

>(cadar '( (11 12) (21 22) (31 32) ) )
12

三番目の要素

>(caddr '( 1 2 3 4))
3

先頭の先頭の二番目以降のリスト

>(cdaar '( ( (111 112 113) (121 122 123) (131 132 133) )
          ( (211 212 213) (221 222 223) (231 232 233) )
          ( (311 312 313) (321 322 323) (331 332 333) )
        )
)
(112 113)

二番目のリストの二番目以降

>(cdadr '( (11 12 13) (21 22 23) (31 32 33) ) )
(22 23)

先頭のリストの三番目以降

>(cddar '( (11 12 13 14) (21 22 23 24) (31 32 33 34) ) )
(13 14)

４番目以降の要素のリスト

>(cdddr '(1 2 3 4 5 6 7))
(4 5 6 7)

先頭の先頭の先頭の先頭の要素。

>(caaaar '( ( ( (1111 1112) (1121 1122)
             )
             ( (1211 1212) (1221 1222)
             )
           )
           ( ( (2111 2112) (2121 2122)
             )
             ( (2211 2212) (2221 2222)
             )
           )
         )
)
1111

二番目のリストの先頭の先頭

>(caaadr '( ( (111 112 113) (121 122 123) (131 132 133) )
           ( (211 212 213) (221 222 223) (231 232 233) )
           ( (311 312 313) (321 322 323) (331 332 333) )
         )
)
211

先頭のリストの二番目の先頭

>(caadar '( ( (111 112 113) (121 122 123) (131 132 133) )
           ( (211 212 213) (221 222 223) (231 232 233) )
           ( (311 312 313) (321 322 323) (331 332 333) )
         )
)
121

三番目のリストの先頭

>(caaddr '( (11 12 13) (21 22 23) (31 32 33) (41 42 43) ))
31

先頭の先頭の二番目の要素

>(cadaar '( ( (111 112 113) (121 122 123) (131 132 133) )
           ( (211 212 213) (221 222 223) (231 232 233) )
           ( (311 312 313) (321 322 323) (331 332 333) )
         )
)
112

二番目のリストの二番目

>(cadadr '( (11 12 13) (21 22 23) (31 32 33) (41 42 43) ))
22

先頭のリストの三番目の要素

>(caddar '( (11 12 13) (21 22 23) (31 32 33) (41 42 43) ))
13

四番目の要素

>(cadddr '(1 2 3 4 5 6 7))
4

先頭の先頭の先頭リストのの二番目以降のリスト

>(cdaaar '( ( ( (1111 1112 1113) (1121 1122 1123)
             )
             ( (1211 1212 1213) (1221 1222 1223)
             )
           )
           ( ( (2111 2112 2113) (2121 2122 2123)
             )
             ( (2211 2212 2213) (2221 2222 2223)
             )
           )
         )
)
(1112 1113)

二番目のリストの先頭の二番目以降のリスト

>(cdaadr '( ( (111 112 113) (121 122 123) (131 132 133) )
           ( (211 212 213) (221 222 223) (231 232 233) )
           ( (311 312 313) (321 322 323) (331 332 333) )
         )
)
(212 213)

先頭のリストの二番目のリストの二番目以降の要素でできたリスト

>(cdadar '( ( (111 112 113) (121 122 123) (131 132 133) )
           ( (211 212 213) (221 222 223) (231 232 233) )
           ( (311 312 313) (321 322 323) (331 332 333) )
         )
)
(122 123)

三番目のリストの二番目以降の要素からなるリスト

>(cdaddr '( (11 12 13) (21 22 23) (31 32 33) (41 42 43) ))
(32 33)

先頭の先頭のリストの三番目以降の要素からなるリスト。

>(cddaar '( ( (111 112 113 114) (121 122 123 124) (131 132 133 134) )
           ( (211 212 213 214) (221 222 223 224) (231 232 233 234) )
           ( (311 312 313 314) (321 322 323 324) (331 332 333 334) )
         )
)
(113 114)

二番目のリストの三番目以降の要素からなるリスト

>(cddadr '( (11 12 13 14) (21 22 23 24) (31 32 33 34) (41 42 43 44) ))
(23 24)

先頭のリストの四番目以降の要素からなるリスト

>(cdddar '( (11 12 13 14 15) (21 22 23 24 25) (31 32 33 34 35) (41 42 43 44 45) ))
(14 15)

五番目以降の要素からなるリスト

>(cddddr '(1 2 3 4 5 6 7))
(5 6 7)

リストの最後のペアを返します。

>(last-pair '( 1 2 3 4 5))
(5)
>(last-pair '( 1 2 3 4 5 . 6))
(5 . 6)
>(last-pair '( (11 12 13) (21 22 23) (31 32 33)))
(31 32 33)
>(car (last-pair '( 1 2 3 4 5)))
5

k 個の v を要素とするリストを作成し、返します。

>(make-list 4 "abc")
("abc" "abc" "abc" "abc")
>(make-list 0 "abc")
()