Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more ➡
Standard view
Full view
of .
×

1.3. References
2.1. Overview of the imperative paradigm
2.2. Overview of the functional paradigm
2.3. Overview of the logic paradigm
2.4. Overview of the object-oriented paradigm
2.5. References
3.1. Lisp
3.2. Scheme
3.3. References
4.4. Arithmetic expressions
4.5. Equality in Scheme
4.7. References
5.1. Types
5.2. Type checking
5.3. Static type checking
5.4. An example of type checking
5.5. Types in functional programming languages
5.6. References
6.1. Proper lists
6.2. Symbolic expressions and improper lists
6.3. Practical list construction
6.4. List functions
6.5. Association lists
6.6. Property lists
6.7. Tables as lists of rows
7.2. Vectors
7.3. Strings
7.4. References
8.1. Definitions
8.2. The function concept
8.3. Lambda calculus
8.4. Functions in Scheme
8.5. Function objects
8.6. Functions as first class values
8.7. Anonymous functions
8.8. Lambda expressions in Scheme
8.9. Optional parameters of Scheme functions (1)
8.10. Optional parameters of Scheme functions (2)
8.11. Closures
8.12. Function definition in Scheme
8.13. Simple web-related functions (1)
8.14. Simple web-related functions (2)
8.15. Function exercises
8.16. References
9.1. The let name binding expression
9.2. The equivalent meaning of let
9.3. Examples with let name binding
9.4. The let* name binding construct
9.5. An example with let*
9.6. The letrec namebinding construct
9.7. LAML time functions
9.8. References
10.1. Conditional expressions
10.2. Examples with if
10.3. Example with cond: leap-year?
10.4. Example with cond: american-time
10.5. Example with cond: as-string
10.6. References
11.1. Recursion
11.2. List processing
11.3. Tree processing (1)
11.4. Tree processing (2)
11.5. Recursion versus iteration
11.6. Example of recursion: number-interval
11.7. Examples of recursion: string-merge
11.8. Examples with recursion: string-of-char-list?
11.9. References
12.1. Hilbert Curves
12.2. Building Hilbert Curves of order 1
12.3. Building Hilbert Curves of order 2
12.4. Building Hilbert Curves of order 3
12.5. Building Hilbert Curves of order 4
12.6. A program making Hilbert Curves
13.1. Introduction and motivation
13.2. The catch and throw idea
13.3. A catch and throw example
13.4. The intuition behind continuations
13.5. Being more precise
13.6. The capturing of continuations
13.7. Capturing, storing, and applying continuations
13.8. Use of continuations for escaping purposes
13.9. Practical example: Length of an improper list
13.10. Practical example: Searching a binary tree
13.11. References
14.1. Higher-order functions
14.2. Some simple and general higher-order functions
14.3. Linear search in lists
14.4. Generation of list selectors
14.5. References
15.1. Classical higher-order functions: Overview
15.2. Mapping
15.3. The mapping function
15.4. Examples of mapping
15.5. Filtering
15.6. The filtering function
15.7. Examples of filtering
15.8. References
16.1. Reduction
16.2. The reduction functions
16.3. Accumulation
16.4. Zipping
16.5. The zipping function
17.1. The idea of currying
17.2. Currying in Scheme
17.3. Examples of currying
17.4. Ad hoc currying in Scheme (1)
17.5. Ad hoc currying in Scheme (2)
17.6. References
18.1. HTML mirror generation
18.2. HTML mirror usage examples
18.3. Making tables with the real mirror
18.4. Tables with higher-order functions
18.5. HTML element modifications
18.6. The function simple-html-table
18.7. The XHTML mirror in LAML
18.8. Generation of a leq predicate from enumeration
18.9. References
19.1. Referential transparency
19.2. An illustration of referential transparency
19.3. Arbitrary evaluation order - with some limits
19.4. A motivating example
19.5. A motivating example - clarification
19.6. References
20.1. Rewrite rules
20.2. The alpha rewrite rule
20.3. The beta rewrite rule
20.4. The eta rewrite rule
20.5. Normal forms
20.6. The ordering of reductions
20.7. An example of normal versus applicative evaluation
20.8. Theoretical results
20.9. Practical implications
20.10. Conditionals and sequential boolean operators
20.11. Lazy evaluation
20.12. References
21.1. Delayed evaluation in Scheme
21.2. Examples of delayed evaluation
21.3. Infinite lists in Scheme: Streams
21.4. Example streams
21.5. Stream example: The sieve of Eratosthenes
21.6. Applications of The sieve of Eratosthenes
21.7. References
22.1. Linguistic abstraction
22.2. Linguistic abstraction in Lisp
22.3. Fine grained linguistic abstraction in Lisp
22.4. An example of fine grained abstraction
22.5. Coarse grained linguistic abstraction in Lisp
22.6. An example of coarse grained abstraction
22.7. References
23.1. Embedded languages
23.2. Examples of language embedding in HTML
23.4. References
24.1. Mirrored Languages
24.5. Embedding versus mirroring
24.6. References
25.1. Why 'Lisp in Lisp'
25.2. An overview of Scheme constructs
25.3. Scheme in Scheme
25.4. The eval and apply primitives
25.5. References
0 of .
Results for:
P. 1
Functional Programming in Scheme

# Functional Programming in Scheme

Ratings: (0)|Views: 129|Likes:

### Availability:

See More
See less

03/11/2014

pdf

text

original

Pages 5 to 15 are not shown in this preview.
Pages 20 to 36 are not shown in this preview.
Pages 41 to 197 are not shown in this preview.