Table of Contents
1
Introduction
1.1
Positioning SWI-Prolog
1.2
Status and releases
1.3
Should I be using SWI-Prolog?
1.4
Support the SWI-Prolog project
1.5
Implementation history
1.6
Acknowledgements
2
Overview
2.1
Getting started quickly
2.1.1
Starting SWI-Prolog
2.1.1.1
Starting SWI-Prolog on Unix
2.1.1.2
Starting SWI-Prolog on Windows
2.1.2
Adding rules from the console
2.1.3
Executing a query
2.1.4
Examining and modifying your program
2.1.5
Stopping Prolog
2.2
The user's initialisation file
2.3
Initialisation files and goals
2.4
Command line options
2.4.1
Informational command line options
2.4.2
Command line options for running Prolog
2.4.3
Controlling the stack sizes
2.4.4
Running goals from the command line
2.4.5
Compilation options
2.4.6
Maintenance options
2.5
UI Themes
2.5.1
Status of theme support
2.6
GNU Emacs Interface
2.7
Online Help
2.7.1
library(help): Text based manual
2.7.2
library(explain): Describe Prolog Terms
2.8
Command line history
2.9
Reuse of top-level bindings
2.10
Overview of the Debugger
2.10.1
The Byrd Box Model And Ports
2.10.2
Trace Mode Example
2.10.3
Trace Mode Options: leash/1 and visible/1
2.10.4
Trace Mode Commands When Paused
2.10.4.1
Control Flow Commands
2.10.4.2
Informational Commands
2.10.4.3
Formatting Commands
2.10.5
Trace Mode vs. Trace Point
2.10.6
Spy Points and Debug Mode
2.10.7
Breakpoints
2.10.8
Command Line Debugger Summary
2.10.8.1
Trace Mode
2.10.8.2
Trace Points
2.11
Compilation
2.11.1
During program development
2.11.2
For running the result
2.11.2.1
Using PrologScript
2.11.2.2
Creating a shell script
2.11.2.3
Creating a saved state
2.11.2.4
Compilation using the -c command line option
2.12
Environment Control (Prolog flags)
2.13
An overview of hook predicates
2.14
Automatic loading of libraries
2.15
Packs: community add-ons
2.16
The SWI-Prolog syntax
2.16.1
ISO Syntax Support
2.16.1.1
Processor Character Set
2.16.1.2
Nested comments
2.16.1.3
Character Escape Syntax
2.16.1.4
Syntax for non-decimal numbers
2.16.1.5
Using digit groups in large integers
2.16.1.6
Rational number syntax
2.16.1.7
NaN and Infinity floats and their syntax
2.16.1.8
Force only underscore to introduce a variable
2.16.1.9
Unicode Prolog source
2.16.1.10
Singleton variable checking
2.17
Rational trees (cyclic terms)
2.18
Just-in-time clause indexing
2.18.1
Deep indexing
2.18.2
Future directions
2.18.3
Indexing for body code
2.18.4
Indexing and portability
2.19
Wide character support
2.19.1
Wide character encodings on streams
2.19.1.1
BOM: Byte Order Mark
2.20
System limits
2.20.1
Limits on memory areas
2.20.1.1
The heap
2.20.2
Other Limits
2.20.3
Reserved Names
2.21
SWI-Prolog and 64-bit machines
2.21.1
Supported platforms
2.21.2
Comparing 32- and 64-bits Prolog
2.21.3
Choosing between 32- and 64-bit Prolog
2.22
Binary compatibility
3
Initialising and Managing a Prolog Project
3.1
The project source files
3.1.1
File Names and Locations
3.1.1.1
File Name Extensions
3.1.1.2
Project Directories
3.1.1.3
Sub-projects using search paths
3.1.2
Project Special Files
3.1.3
International source files
3.2
Using modules
3.3
The test-edit-reload cycle
3.3.1
Locating things to edit
3.3.2
Editing and incremental compilation
3.4
Using the PceEmacs built-in editor
3.4.1
Activating PceEmacs
3.4.2
Bluffing through PceEmacs
3.4.2.1
Edit modes
3.4.2.2
Frequently used editor commands
3.4.3
Prolog Mode
3.4.3.1
Finding your way around
3.5
The Graphical Debugger
3.5.1
Invoking the window-based debugger
3.6
The Prolog Navigator
3.7
Cross-referencer
3.8
Accessing the IDE from your program
3.9
Summary of the IDE
4
Built-in Predicates
4.1
Notation of Predicate Descriptions
4.1.1
The argument mode indicator
4.1.2
Predicate indicators
4.1.2.1
Non-terminal indicators
4.1.3
Predicate behaviour and determinism
4.2
Character representation
4.3
Loading Prolog source files
4.3.1
Conditional compilation and program transformation
4.3.1.1
Program transformation with source layout info
4.3.1.2
Conditional compilation
4.3.2
Reloading files, active code and threads
4.3.2.1
Errors and warnings during compilation
4.3.2.2
Compilation of mutually dependent code
4.3.2.3
Compilation with multiple threads
4.3.3
Quick load files
4.4
Editor Interface
4.4.1
Customizing the editor interface
4.5
Verify Type of a Term
4.6
Comparison and Unification of Terms
4.6.1
Standard Order of Terms
4.6.2
Special unification and comparison predicates
4.7
Control Predicates
4.8
Meta-Call Predicates
4.9
Delimited continuations
4.10
Exception handling
4.10.1
Urgency of exceptions
4.10.2
Debugging and exceptions
4.10.3
The exception term
4.10.3.1
General form of the ISO standard exception term
4.10.3.2
Throwing exceptions from applications and libraries
4.11
Printing messages
4.11.1
Printing from libraries
4.12
Handling signals
4.12.1
Notes on signal handling
4.13
DCG Grammar rules
4.14
Database
4.14.1
Managing (dynamic) predicates
4.14.1.1
Transactions
4.14.1.2
Impact of transactions
4.14.2
The recorded database
4.14.3
Flags
4.14.4
Tries
4.14.5
Update view
4.14.6
Indexing databases
4.15
Declaring predicate properties
4.16
Examining the program
4.17
Input and output
4.17.1
Predefined stream aliases
4.17.2
ISO Input and Output Streams
4.17.3
Edinburgh-style I/O
4.17.4
Switching between Edinburgh and ISO I/O
4.17.5
Adding IRI schemas
4.17.6
Write onto atoms, code-lists, etc.
4.17.7
Fast binary term I/O
4.18
Status of streams
4.19
Primitive character I/O
4.20
Term reading and writing
4.21
Analysing and Constructing Terms
4.21.1
Non-logical operations on terms
4.22
Analysing and Constructing Atoms
4.23
Localization (locale) support
4.24
Character properties
4.24.1
Case conversion
4.24.2
White space normalization
4.24.3
Language-specific comparison
4.25
Operators
4.26
Character Conversion
4.27
Arithmetic
4.27.1
Special purpose integer arithmetic
4.27.2
General purpose arithmetic
4.27.2.1
Arithmetic types
4.27.2.2
Rational number examples
4.27.2.3
Rational numbers or floats
4.27.2.4
IEEE 754 floating point arithmetic
4.27.2.5
Floating point arithmetic precision
4.27.2.6
Arithmetic Functions
4.28
Misc arithmetic support predicates
4.29
Built-in list operations
4.30
Finding all Solutions to a Goal
4.31
Forall
4.32
Formatted Write
4.32.1
Writef
4.32.2
Format
4.32.3
Programming Format
4.33
Global variables
4.33.1
Compatibility of SWI-Prolog Global Variables
4.34
Terminal Control
4.35
Operating System Interaction
4.35.1
Windows-specific Operating System Interaction
4.35.2
Apple specific Operating System Interaction
4.35.3
Dealing with time and date
4.35.3.1
Time and date data structures
4.35.3.2
Time and date predicates
4.35.4
Controlling the
swipl-win.exe
console window
4.36
File System Interaction
4.37
User Top-level Manipulation
4.38
Creating a Protocol of the User Interaction
4.39
Debugging and Tracing Programs
4.40
Debugging and declaring determinism
4.41
Obtaining Runtime Statistics
4.42
Execution profiling
4.42.1
Profiling predicates
4.42.2
Visualizing profiling data
4.42.3
Information gathering
4.42.3.1
Profiling in the Windows Implementation
4.43
Memory Management
4.43.1
Garbage collection
4.43.2
Heap memory (malloc)
4.43.2.1
TCMalloc control predicates
4.44
Windows DDE interface
4.44.1
DDE client interface
4.44.2
DDE server mode
4.45
Miscellaneous
5
SWI-Prolog extensions
5.1
Lists are special
5.1.1
Motivating‘
[|]
’and
[]
for lists
5.2
The string type and its double quoted syntax
5.2.1
Representing text: strings, atoms and code lists
5.2.2
Predicates that operate on strings
5.2.3
Why has the representation of double quoted text changed?
5.2.4
Adapting code for double quoted strings
5.2.5
Predicates to support adapting code for double quoted strings
5.3
Syntax changes since SWI-Prolog 7
5.3.1
Operators and quoted atoms
5.3.2
Compound terms with zero arguments
5.3.3
Block operators
5.4
Dicts: structures with named arguments
5.4.1
Functions on dicts
5.4.1.1
User defined functions on dicts
5.4.1.2
Predefined functions on dicts
5.4.2
Predicates for managing dicts
5.4.2.1
Destructive assignment in dicts
5.4.3
When to use dicts?
5.4.4
A motivation for dicts as primary citizens
5.4.5
Implementation notes about dicts
5.5
Integration of strings and dicts in the libraries
5.5.1
Dicts and option processing
5.5.2
Dicts in core data structures
5.5.3
Dicts, strings and XML
5.5.4
Dicts, strings and JSON
5.5.5
Dicts, strings and HTTP
5.6
Single Sided Unification rules
5.6.1
Single Sided Unification Guards
5.6.2
Consequenses of
=>
single sided unification rules
5.6.3
SSU: Future considerations
5.7
Remaining issues
6
Modules
6.1
Why Use Modules?
6.2
Defining a Module
6.3
Importing Predicates into a Module
6.4
Controlled autoloading for modules
6.5
Defining a meta-predicate
6.6
Overruling Module Boundaries
6.6.1
Explicit manipulation of the calling context
6.7
Interacting with modules from the top level
6.8
Composing modules from other modules
6.9
Operators and modules
6.10
Dynamic importing using import modules
6.11
Reserved Modules and using the‘user' module
6.12
An alternative import/export interface
6.13
Dynamic Modules
6.14
Transparent predicates: definition and context module
6.15
Module properties
6.16
Compatibility of the Module System
7
Tabled execution (SLG resolution)
7.1
Example 1: using tabling for memoizing
7.2
Example 2: avoiding non-termination
7.3
Answer subsumption or mode directed tabling
7.4
Tabling for impure programs
7.5
Variant and subsumptive tabling
7.6
Well Founded Semantics
7.6.1
Well founded semantics and the toplevel
7.7
Incremental tabling
7.8
Monotonic tabling
7.8.1
Eager and lazy monotonic tabling
7.8.2
Tracking new answers to monotonic tables
7.8.3
Monotonic tabling with external data
7.9
Shared tabling
7.9.1
Abolishing shared tables
7.9.2
Status and future of shared tabling
7.10
Tabling restraints: bounded rationality and tripwires
7.10.1
Restraint subgoal size
7.10.2
Restraint answer size
7.10.3
Restraint answer count
7.11
Tabling predicate reference
7.12
About the tabling implementation
7.12.1
Status of tabling
8
Constraint Logic Programming
8.1
Attributed variables
8.1.1
Attribute manipulation predicates
8.1.2
Attributed variable hooks
8.1.3
Operations on terms with attributed variables
8.1.4
Special purpose predicates for attributes
8.2
Coroutining
9
CHR: Constraint Handling Rules
9.1
Introduction to CHR
9.2
CHR Syntax and Semantics
9.2.1
Syntax of CHR rules
9.2.2
Semantics of CHR
9.3
CHR in SWI-Prolog Programs
9.3.1
Embedding CHR in Prolog Programs
9.3.2
CHR Constraint declaration
9.3.3
CHR Compilation
9.4
Debugging CHR programs
9.4.1
CHR debug ports
9.4.2
Tracing CHR programs
9.4.3
CHR Debugging Predicates
9.5
CHR Examples
9.6
CHR compatibility
9.6.1
The Old SICStus CHR implementation
9.6.2
The Old ECLiPSe CHR implementation
9.7
CHR Programming Tips and Tricks
9.8
CHR Compiler Errors and Warnings
9.8.1
CHR Compiler Errors
10
Multithreaded applications
10.1
Creating and destroying Prolog threads
10.2
Monitoring threads
10.3
Thread communication
10.3.1
Message queues
10.3.2
Waiting for events
10.3.3
Signalling threads
10.3.4
Threads and dynamic predicates
10.4
Thread synchronisation
10.5
Thread support library(threadutil)
10.5.1
Debugging threads
10.5.2
Profiling threads
10.6
Multithreaded mixed C and Prolog applications
10.6.1
A Prolog thread for each native thread (one-to-one)
10.6.2
Pooling Prolog engines (many-to-many)
10.7
Multithreading and the XPCE graphics system
11
Coroutining using Prolog engines
11.1
Examples using engines
11.1.1
Aggregation using engines
11.1.2
State accumulation using engines
11.1.3
Scalable many-agent applications
11.2
Engine resource usage
11.3
Engine predicate reference
12
Foreign Language Interface
12.1
Overview of the Interface
12.2
Linking Foreign Modules
12.2.1
What linking is provided?
12.2.2
What kind of loading should I be using?
12.2.3
library(shlib): Utility library for loading foreign objects (DLLs, shared objects)
12.2.4
Low-level operations on shared libraries
12.2.5
Static Linking
12.3
Interface Data Types
12.3.1
Type
term_t
: a reference to a Prolog term
12.3.1.1
Interaction with the garbage collector and stack-shifter
12.3.2
Other foreign interface types
12.3.2.1
PL_ARITY_AS_SIZE
12.4
The Foreign Include File
12.4.1
Argument Passing and Control
12.4.1.1
Non-deterministic Foreign Predicates
12.4.1.2
Yielding from foreign predicates
12.4.2
Atoms and functors
12.4.2.1
Atoms and atom garbage collection
12.4.3
Analysing Terms via the Foreign Interface
12.4.3.1
Testing the type of a term
12.4.3.2
Reading data from a term
12.4.3.3
Exchanging text using length and string
12.4.3.4
Wide-character versions
12.4.3.5
Reading a list
12.4.3.6
Processing option lists and dicts
12.4.3.7
An example: defining write/1 in C
12.4.4
Constructing Terms
12.4.5
Unifying data
12.4.6
Convenient functions to generate Prolog exceptions
12.4.7
Serializing and deserializing Prolog terms
12.4.8
BLOBS: Using atoms to store arbitrary binary data
12.4.8.1
Defining a BLOB type
12.4.8.2
Accessing blobs
12.4.9
Exchanging GMP numbers
12.4.10
Calling Prolog from C
12.4.10.1
Predicate references
12.4.10.2
Initiating a query from C
12.4.11
Discarding Data
12.4.12
String buffering
12.4.13
Foreign Code and Modules
12.4.14
Prolog exceptions in foreign code
12.4.15
Catching Signals (Software Interrupts)
12.4.16
Miscellaneous
12.4.16.1
Term Comparison
12.4.16.2
Recorded database
12.4.16.3
Database
12.4.16.4
Getting file names
12.4.16.5
Dealing with Prolog flags from C
12.4.17
Errors and warnings
12.4.18
Environment Control from Foreign Code
12.4.19
Querying Prolog
12.4.20
Registering Foreign Predicates
12.4.21
Foreign Code Hooks
12.4.22
Storing foreign data
12.4.22.1
Examples for storing foreign data
12.4.23
Embedding SWI-Prolog in other applications
12.4.23.1
Threading, Signals and embedded Prolog
12.5
Linking embedded applications using swipl-ld
12.5.1
A simple example
12.6
The Prolog‘home' directory
12.7
Example of Using the Foreign Interface
12.8
Notes on Using Foreign Code
12.8.1
Foreign debugging functions
12.8.2
Memory Allocation
12.8.3
Compatibility between Prolog versions
12.8.4
Foreign hash tables
12.8.5
Debugging and profiling foreign code (valgrind, asan)
12.8.6
Name Conflicts in C modules
12.8.7
Compatibility of the Foreign Interface
12.9
Foreign access to Prolog IO streams
12.9.1
Get IO stream handles
12.9.2
Creating an IO stream
12.9.3
Interacting with foreign streams
12.9.4
Foreign stream error handling
12.9.5
Foreign stream encoding
12.9.6
Foreign stream line endings
12.9.7
Foreign stream position information
13
Deploying applications
13.1
Deployment options
13.2
Understanding saved states
13.2.1
Creating a saved state
13.2.2
Limitations of qsave_program
13.2.3
Runtimes and Foreign Code
13.3
State initialization
13.4
Using program resources
13.4.1
Resources as files
13.4.2
Access resources using open_resource
13.4.3
Declaring resources
13.4.4
Managing resource files
13.5
Debugging and updating deployed systems
13.6
Protecting your code
13.6.1
Obfuscating code in saved states
13.7
Finding Application files
A
The SWI-Prolog library
A.1
library(aggregate): Aggregation operators on backtrackable predicates
A.2
library(ansi_term): Print decorated text to ANSI consoles
A.3
library(apply): Apply predicates on a list
A.4
library(assoc): Association lists
A.4.1
Introduction
A.4.2
Creating association lists
A.4.3
Querying association lists
A.4.4
Modifying association lists
A.4.5
Conversion predicates
A.4.6
Reasoning about association lists and their elements
A.5
library(broadcast): Broadcast and receive event notifications
A.6
library(charsio): I/O on Lists of Character Codes
A.7
library(check): Consistency checking
A.8
library(clpb): CLP(B): Constraint Logic Programming over Boolean Variables
A.8.1
Introduction
A.8.2
Boolean expressions
A.8.3
Interface predicates
A.8.4
Examples
A.8.5
Obtaining BDDs
A.8.6
Enabling monotonic CLP(B)
A.8.7
Example: Pigeons
A.8.8
Example: Boolean circuit
A.8.9
Acknowledgments
A.8.10
CLP(B) predicate index
A.9
library(clpfd): CLP(FD): Constraint Logic Programming over Finite Domains
A.9.1
Introduction
A.9.2
Arithmetic constraints
A.9.3
Declarative integer arithmetic
A.9.4
Example: Factorial relation
A.9.5
Combinatorial constraints
A.9.6
Domains
A.9.7
Example: Sudoku
A.9.8
Residual goals
A.9.9
Core relations and search
A.9.10
Example: Eight queens puzzle
A.9.11
Optimisation
A.9.12
Reification
A.9.13
Enabling monotonic CLP(FD)
A.9.14
Custom constraints
A.9.15
Applications
A.9.16
Acknowledgments
A.9.17
CLP(FD) predicate index
A.9.17.1
Arithmetic constraints
A.9.17.2
Membership constraints
A.9.17.3
Enumeration predicates
A.9.17.4
Global constraints
A.9.17.5
Reification predicates
A.9.17.6
Reflection predicates
A.9.17.7
FD set predicates
A.9.17.8
FD miscellaneous predicates
A.9.18
Closing and opening words about CLP(FD)
A.10
library(clpqr): Constraint Logic Programming over Rationals and Reals
A.10.1
Solver predicates
A.10.2
Syntax of the predicate arguments
A.10.3
Use of unification
A.10.4
Non-linear constraints
A.10.5
Status and known problems
A.11
library(csv): Process CSV (Comma-Separated Values) data
A.12
library(dcg/basics): Various general DCG utilities
A.13
library(dcg/high_order): High order grammar operations
A.14
library(debug): Print debug messages and test assertions
A.15
library(dicts): Dict utilities
A.16
library(error): Error generating support
A.17
library(fastrw): Fast reading and writing of terms
A.18
library(gensym): Generate unique symbols
A.19
library(heaps): heaps/priority queues
A.20
library(increval): Incremental dynamic predicate modification
A.21
library(intercept): Intercept and signal interface
A.22
library(iostream): Utilities to deal with streams
A.23
library(listing): List programs and pretty print clauses
A.24
library(lists): List Manipulation
A.25
library(main): Provide entry point for scripts
A.26
library(nb_set): Non-backtrackable set
A.27
library(www_browser): Open a URL in the users browser
A.28
library(occurs): Finding and counting sub-terms
A.29
library(option): Option list processing
A.30
library(optparse): command line parsing
A.30.1
Notes and tips
A.31
library(ordsets): Ordered set manipulation
A.32
library(pairs): Operations on key-value lists
A.33
library(persistency): Provide persistent dynamic predicates
A.34
library(pio): Pure I/O
A.34.1
library(pure_input): Pure Input from files and streams
A.35
library(portray_text): Portray text
A.36
library(predicate_options): Declare option-processing of predicates
A.36.1
The strength and weakness of predicate options
A.36.2
Options as arguments or environment?
A.36.3
Improving on the current situation
A.36.3.1
Options as types
A.36.3.2
Reflective access to options
A.37
library(prolog_debug): User level debugging tools
A.38
library(prolog_jiti): Just In Time Indexing (JITI) utilities
A.39
library(prolog_pack): A package manager for Prolog
A.40
library(prolog_xref): Prolog cross-referencer data collection
A.41
library(quasi_quotations): Define Quasi Quotation syntax
A.42
library(random): Random numbers
A.43
library(rbtrees): Red black trees
A.44
library(readutil): Read utilities
A.45
library(record): Access named fields in a term
A.46
library(registry): Manipulating the Windows registry
A.47
library(settings): Setting management
A.48
library(statistics): Get information about resource usage
A.49
library(strings): String utilities
A.50
library(simplex): Solve linear programming problems
A.50.1
Introduction
A.50.2
Delayed column generation
A.50.3
Solving LPs with special structure
A.50.4
Examples
A.50.4.1
Example 1
A.50.4.2
Example 2
A.50.4.3
Example 3
A.51
library(solution_sequences): Modify solution sequences
A.52
library(tables): XSB interface to tables
A.53
library(terms): Term manipulation
A.54
library(thread): High level thread primitives
A.55
library(thread_pool): Resource bounded thread management
A.56
library(ugraphs): Graph manipulation library
A.57
library(url): Analysing and constructing URL
A.58
library(varnumbers): Utilities for numbered terms
A.59
library(yall): Lambda expressions
B
Hackers corner
B.1
Examining the Environment Stack
B.2
Ancestral cuts
B.3
Intercepting the Tracer
B.4
Breakpoint and watchpoint handling
B.5
Adding context to errors: prolog_exception_hook
B.6
Hooks using the exception predicate
B.7
Prolog events
B.8
Hooks for integrating libraries
B.9
Hooks for loading files
C
Compatibility with other Prolog dialects
C.1
Some considerations for writing portable code
C.2
Notes on specific dialects
C.2.1
Notes on specific dialects
C.2.1.1
Loading XSB source files
C.2.2
The XSB import directive
D
Glossary of Terms
E
SWI-Prolog License Conditions and Tools
E.1
Contributing to the SWI-Prolog project
E.2
Software support to keep track of license conditions
E.3
License conditions inherited from used code
E.3.1
Cryptographic routines
F
Summary
F.1
Predicates
F.2
Library predicates
F.2.1
library(aggregate)
F.2.2
library(ansi_term)
F.2.3
library(apply)
F.2.4
library(assoc)
F.2.5
library(broadcast)
F.2.6
library(charsio)
F.2.7
library(check)
F.2.8
library(clpb)
F.2.9
library(clpfd)
F.2.10
library(clpqr)
F.2.11
library(csv)
F.2.12
library(dcgbasics)
F.2.13
library(dcghighorder)
F.2.14
library(debug)
F.2.15
library(dicts)
F.2.16
library(error)
F.2.17
library(fastrw)
F.2.18
library(explain)
F.2.19
library(help)
F.2.20
library(gensym)
F.2.21
library(heaps)
F.2.22
library(increval)
F.2.23
library(intercept)
F.2.24
library(iostream)
F.2.25
library(listing)
F.2.26
library(lists)
F.2.27
library(main)
F.2.28
library(occurs)
F.2.29
library(option)
F.2.30
library(optparse)
F.2.31
library(ordsets)
F.2.32
library(persistency)
F.2.33
library(portraytext)
F.2.34
library(predicate_options)
F.2.35
library(prologdebug)
F.2.36
library(prologjiti)
F.2.37
library(prologpack)
F.2.38
library(prologxref)
F.2.39
library(pairs)
F.2.40
library(pio)
F.2.40.1
library(pure_input)
F.2.41
library(random)
F.2.42
library(rbtrees)
F.2.43
library(readutil)
F.2.44
library(record)
F.2.45
library(registry)
F.2.46
library(settings)
F.2.47
library(simplex)
F.2.48
library(statistics)
F.2.49
library(terms)
F.2.50
library(ugraphs)
F.2.51
library(url)
F.2.52
library(www_browser)
F.2.53
library(solution_sequences)
F.2.54
library(thread)
F.2.55
library(thread_pool)
F.2.56
library(varnumbers)
F.2.57
library(yall)
F.3
Arithmetic Functions
F.4
Operators
G
Bibliography
