Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more
Standard view
Full view
of .
Look up keyword or section
Like this

Table Of Contents

Value declarations
Function expressions, functions
Polymorphism and type constraints
Type declarations and pattern matching
Pattern matching
Type declaration
Sum types
Recursive types
Parametrized types
Scope of declarations
Function types
Example: representing trees
Recursive values which are not functions
Typing, domain of definition, and
Partial functions and exceptions
Definition of an exception
Raising an exception
Exception handling
Desktop Calculator
Merging two lists
Lexical trees
Graph traversal
To learn more
Modifiable Data Structures
Character Strings
Mutable Fields of Records
Polymorphism and Modifiable Values
Reading and Writing
Example: Higher/Lower
Control Structures
Example: Implementing a Stack
Example: Calculations on Matrices
Order of Evaluation of Arguments
Calculator With Memory
Doubly Linked Lists
Solving linear systems
To Learn More
The Functional Side
The Imperative Side
Recursive or Iterative
Which Style to Choose?
Sequence or Composition of Functions
Shared or Copy Values
How to Choose your Style
Mixing Styles
Closures and Side Effects
Physical Modifications and Exceptions
Modifiable Functional Data Structures
Lazy Modifiable Data Structures
Streams of Data
Destruction and Matching of Streams
Binary Trees
Spelling Corrector
Set of Prime Numbers
Types and functions for events
Program skeleton
Example: telecran
A Graphical Calculator
Polar coordinates
Bitmap editor
Earth worm
Database queries
Data format
Reading a database from a file
General principles for database processing
Selection criteria
Processing and computation
An example
Further work
BASIC interpreter
Abstract syntax
Program pretty printing
Finishing touches
The abstract mine field
Displaying the Minesweeper game
Interaction with the player
Development Tools
Steps of Compilation
The Objective Caml Compilers
Description of the Bytecode Compiler
Command Names
Compilation Unit
Naming Rules for File Extensions
The Bytecode Compiler
Native Compiler
Toplevel Loop
Construction of a New Interactive System
Standalone Executables
Portability and Efficiency
Standalone Files and Portability
Efficiency of Execution
Creation of a Toplevel and Standalone Executable
Comparison of Performance
Categorization and Use of the Libraries
Preloaded Library
Standard Library
Linear Data Structures
Simple Linear Data Structures
Interface with the System
Other Libraries in the Distribution
Exact Math
Dynamic Loading of Code
Resolution of Linear Systems
Search for Prime Numbers
Displaying Bitmaps
Garbage Collection
Program Memory
Allocation and Deallocation of Memory
Explicit Allocation
Explicit Reclamation
Implicit Reclamation
Automatic Garbage Collection
Reference Counting
Sweep Algorithms
Other Garbage Collectors
Memory Management by Objective Caml
Module Gc
Module Weak
Following the evolution of the heap
Memory Allocation and Programming Styles
Dependency Analysis
Debugging Tools
Execution Control
The ocamllex Tool
Production and Recognition
Top-down Parsing
Bottom-up Parsing
The ocamlyacc Tool
Contextual Grammars
Basic Revisited
File basic parser.mly
File basic lexer.mll
Compiling, Linking
Filtering Comments Out
Communication between C and Objective
External declarations
Declaration of the C functions
Linking with C
Mixing input-output in C and in Objective Caml
Exploring Objective Caml values from C
Classification of Objective Caml representations
Accessing immediate values
Representation of structured values
Modifying Objective Caml values
Allocating new blocks
Storing C data in the Objective Caml heap
Garbage collection and C parameters and local
Calling an Objective Caml closure from C
Exception handling in C and in Objective
Raising a predefined exception
Raising a user-defined exception
Catching an exception
Main program in C
Linking Objective Caml code with C
Polymorphic Printing Function
Matrix Product
Counting Words: Main Program in C
Constructing a Graphical Interface
Graphics Context, Events and Options
Components and Containers
Event Handling
Defining Components
Enriched Components
Setting up the Awi Library
Example: A Franc-Euro Converter
Where to go from here
Finding Least Cost Paths
Graph Representions
Dijkstra’s Algorithm
Application Structure
Modules as Compilation Units
Interface and Implementation
Relating Interfaces and Implementations
Separate Compilation
The Module Language
Two Stack Modules
Modules and Information Hiding
Type Sharing between Modules
Extending Simple Modules
Parameterized Modules
Functors and Code Reuse
Local Module Definitions
Organization of the Program
Signatures for the Module Parameters
The Parameterized Module for Managing Accounts
Implementing the Parameters
Association Lists
Parameterized Vectors
Lexical Trees
Classes, Objects, and Methods
Object-Oriented Terminology
Class Declaration
Instance Creation
Sending a Message
Relations between Classes
Inheritance Relation
Other Object-oriented Features
References: self and super
Delayed Binding
Object Representation and Message Dispatch
Private Methods
Types and Genericity
Abstract Classes and Methods
Classes, Types, and Objects
Multiple Inheritance
Parameterized Classes
Subtyping and Inclusion Polymorphism
Subtyping is not Inheritance
Inclusion Polymorphism
Equality between Objects
Functional Style
Other Aspects of the Object Extension
Local Declarations in Classes
Stacks as Objects
Abstract Classes and an Expression Evaluator
The Game of Life and Objects
Comparison of Modules and Objects
Translation of Modules into Classes
Simulation of Inheritance with Modules
Limitations of each Model
Extending Components
In the Functional Model
In the Object Model
Extension of Data and Methods
Mixed Organisations
Classes and Modules for Data Structures
Abstract Types
Two Player Games
The Problem of Two Player Games
Minimax αβ
Organization of a Game Program
Connect Four
Fancy Robots
“Abstract” Robots
Pure World
Textual Robots
Textual World
Graphical Robots
Graphical World
Concurrency and distribution
The Unix Module
Error Handling
Portability of System Calls
File Descriptors
File Manipulation
Input / Output on Files
Executing a Program
Process Creation
Creation of Processes by Duplication
Order and Moment of Execution
Descendence, Death and Funerals of Processes
Communication Between Processes
Communication Pipes
Communication Channels
Signals under Unix
Counting Words: the wc Command
Pipes for Spell Checking
Interactive Trace
Concurrent Processes
Compilation with Threads
Module Thread
Synchronization of Processes
Critical Section and Mutual Exclusion
Mutex Module
Waiting and Synchronization
Condition Module
Synchronous Communication
Synchronization using Communication Events
Transmitted Values
Module Event
Example: Post Office
The Components
Clients and Clerks
The System
The Philosophers Disentangled
More of the Post Office
Object Producers and Consumers
The Internet
The Unix Module and IP Addressing
Description and Creation
Addresses and Connections
Client-server Action Model
Client-server Programming
Code for the Server
Testing with telnet
The Client Code
Client-server Programming with Lightweight
Multi-tier Client-server Programming
Some Remarks on the Client-server Programs
Communication Protocols
Text Protocol
Protocols with Acknowledgement and Time Limits
Interoperating with Different Languages
Service: Clock
A Network Coffee Machine
Client-server Toolbox
The Robots of Dawn
HTTP Servlets
HTTP and CGI Formats
HTML Servlet Interface
Dynamic Pages for Managing the Association
Analysis of Requests and Response
Main Entry Point and Application
Elements of the evaluation
Libraries and tools
Other development tools
Editing tools
Syntax extension
Interoperability with other languages
Graphical interfaces
Parallel programming and distribution
Applications developed in Objective Caml
Similar functional languages
ML family
Languages with delayed evaluation
Communication languages
Object-oriented languages: comparison
Main characteristics
Differences with Objective Caml
Future of Objective Caml development
Cyclic Types
Cyclic types
Option -rectypes
Language Extensions
Optional arguments
Labels and objects
Polymorphic variants
LablTk Library
0 of .
Results for:
No results containing your search query
P. 1


Ratings: (0)|Views: 52|Likes:
Published by FelixCrown

More info:

Published by: FelixCrown on Mar 16, 2011
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less





You're Reading a Free Preview
Pages 16 to 141 are not shown in this preview.
You're Reading a Free Preview
Pages 157 to 305 are not shown in this preview.
You're Reading a Free Preview
Pages 321 to 412 are not shown in this preview.
You're Reading a Free Preview
Pages 428 to 549 are not shown in this preview.
You're Reading a Free Preview
Pages 565 to 757 are not shown in this preview.

Activity (2)

You've already reviewed this. Edit your review.
1 thousand reads
1 hundred reads

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->