Next: About this document
Up: FLIP: Functional-plus-Logic Programming on
Previous: References
- #'
- Higher-order Builtins
- %if
- if and Relatives
- %if
- if and Relatives
- %setq
- setq and Relatives
- %setq
- setq and Relatives
- %setq
- setq and Relatives
- &
- Relational-Functional Programming Languages
- '
- Simple ExpressionsLists,
- '
- Quoting
- *
- Numerical and String
- *
- Simple Builtins
- *
- Numerical Builtins
- +
- Numerical and String
- +
- Simple Builtins
- +
- Numerical Builtins
- -
- Numerical and String
- -
- Simple Builtins
- -
- Numerical Builtins
- /=
- Numerical and String
- /=
- Simple Builtins
- /=
- Numerical Builtins
- /
- Numerical and String
- /
- Simple Builtins
- /
- Numerical Builtins
- 1+
- Numerical and String
- 1+
- Simple Builtins
- 1+
- Numerical Builtins
- 1-
- Numerical and String
- 1-
- Simple Builtins
- 1-
- Numerical Builtins
- :-
- Declarations
- >=
- Numerical and String
- >=
- Simple Builtins
- >=
- Numerical Builtins
- >
- Numerical and String
- >
- Simple Builtins
- >
- Numerical Builtins
- <=
- Numerical and String
- <=
- Simple Builtins
- <=
- Numerical Builtins
- <
- Numerical and String
- <
- Simple Builtins
- <
- Numerical Builtins
- =
- Numerical and String
- =
- Simple Builtins
- =
- Numerical Builtins
- abstract interpretation
- Restricting the Query , RELFUN , Conclusions and Future
- abstract machine
- Objectives, Objectives, Objectives, Approach and Results, Approach and Results, Approach and Results, (, ), Equality, Integrating Relations and , Calling LL Functions , LL, (, ), (, ), Conclusions and Future , Conclusions and Future
- At-Kaci
- Abstract Machines
- ampersand
- Relational-Functional Programming Languages
- and
- Conditional Evaluation
- and
- if and Relatives
- and
- if and Relatives
- and
- if and Relatives
- append
- Prelude
- append
- Calling LL Functions
- append
- Determinism Transformation
- append
- Examples
- append
- (
- append
- )
- apply
- Higher-order Builtins
- apply
- funcall and Relatives
- arity
- Simple Builtins
- arity
- Data Types
- arity
- Structures
- asm
- RELFUN Toplevel
- assignments
- LL: LISP light, (Single and Re-) , (Single and Re-) , RELFUN , RELFUN , , LL, Stack Manipulation, setq and Relatives, let and let*
- assoc
- Prelude
- az
- Transforming Deterministic REL
- backtracking
- Calling Relations from , Determinism in Relational , Implementing Extra-logicals via , Implementing Extra-logicals via , Conclusions and Future
- bagof
- Integrating Relations and
- bagof
- Calling Relations from
- bagof
- Implementing Extra-logicals via
- bagof
- Implementing Extra-logicals via
- bagof
- Approach and Results
- bagof
- Conclusions and Future
- bagof
- LL: LISP light
- Benker
- Objectives
- Boley
- Objectives
- Boley
- Approach and Results
- Boley
- Relational-Functional Programming Languages
- Boley
- Relational-Functional Programming Languages
- Boley
- Relational-Functional Programming Languages
- Boley
- Relational-Functional Programming Languages
- Boley
- RELFUN Toplevel
- branch instructions
- Branch Instructions
- builtins
- Simple Builtins
- call-by-value
- Relational-Functional Programming Languages, LLAMA - The
- car
- Simple Builtins
- car
- Lists and Dotted
- catch stack
- (, )
- catch-all clauses
- LL, Examples, Examples, Examples, Examples, Conclusions and Future
- catch
- Non-local Exits and
- catch
- Non-local Exits and
- cdr
- Simple Builtins
- cdr
- Lists and Dotted
- compilation
- Objectives, Objectives, Approach and Results, Abstract Machines, Abstract Machines, Calling LL Functions , Determinism Transformation, Determinism in Relational , Transforming Relational Languages , RELFUN , LL, Examples, LLAMA - The , Higher-Order Instructions, (, ), RELFUN Toplevel, Transforming Deterministic REL
- compile
- Transforming Deterministic REL
- computation rule
- Determinism in Relational , Determinism in Relational , Determinism in Relational
- cond
- Conditional Evaluation
- cond
- if and Relatives
- conditional evaluation
- Conditional Evaluation, if and Relatives
- cons
- Simple ExpressionsLists,
- cons
- Simple Builtins
- cons
- Lists and Dotted
- consp
- Simple Builtins
- consp
- Lists and Dotted
- constant
- Constants, Constants, Simple ExpressionsLists,
- consult
- Transforming Deterministic REL
- control instructions
- Control Instructions
- cut
- Relational-Functional Programming Languages, Relational-Functional Programming Languages, Relational-Functional Programming Languages, , LL, LL, Examples, Conclusions and Future
- data types
- (, ), (, ), Simple ExpressionsLists,
- Debray
- LL
- declarations
- Approach and Results, Restricting the Query , Restricting the Query , Transforming Relational Languages , REL RELFUN Functions, LL, Examples, Conclusions and Future , (, )
- declarativeness
- Objectives, Relational-Functional Programming Languages, Relational-Functional Programming Languages, Determinism Transformation, Conclusions and Future
- declare
- Declarations
- defun
- User-definable Functions
- defun
- defun
- DeGroot
- Relational-Functional Programming Languages
- dereferencing
- Lists, Lists, Defining Assembler Instructions
- deta
- Transforming Deterministic REL
- determinism
- Objectives, Approach and Results, Relational-Functional Programming Languages, LL: LISP light, Non-local Exits and , Integrating Relations and , (, ), Declarations
- dfmode
- Declarations
- do
- Non-local Exits and
- Dorochevsky
- Objectives
- dotted pairs
- Relational-Functional Programming Languages, (, ), (, ), Lists, Simple ExpressionsLists,
- eager evaluation
- seecall-by-value
- elt
- Simple Builtins
- elt
- Data Types
- elt
- Structures
- emul
- RELFUN Toplevel
- eq
- Simple Builtins
- eq
- Equality
- eql
- Simple Builtins
- eql
- Equality
- equal
- Simple Builtins
- equal
- Equality
- equality
- Equality, RELFUN , , LL, (, )
- Ershov
- Determinism in Relational
- eval
- Higher-order Builtins
- eval
- Implementing Extra-logicals via
- eval
- funcall and Relatives
- even
- Examples
- expressiveness
- Objectives, Approach and Results, Relational-Functional Programming Languages
- free variables
- seelogic variables
- funcall
- Higher-order Builtins
- funcall
- funcall and Relatives
- function
- Higher-order Builtins
- function
- funcall and Relatives
- function
- funcall and Relatives
- function
- funcall and Relatives
- functor
- Simple Builtins
- functor
- Data Types
- functor
- Structures
- Futamara
- Determinism in Relational
- Gabriel
- Abstract Machines
- getvar
- Implementing Extra-logicals via
- global variables
- LL: LISP light, Integrating Relations and , (, ), Registers and Memory , (, ), Simple ExpressionsLists, , setq and Relatives, setq and Relatives, The Peep-Hole Optimizer, Defining Assembler Instructions
- guards
- Calling LL Functions , Transforming Relational Languages , LL
- Hall
- Conclusions and Future
- Hanus
- Approach and Results
- Hanus
- Relational-Functional Programming Languages
- Haraldsson
- Determinism in Relational
- hash tables
- (, ), Defining Assembler Instructions
- heap
- Abstract Machines, Data Types, Lists, Equality, Global Variables
- Henderson
- LLAMA - The
- higher order
- (, ), (, ), funcall and Relatives
- if
- Conditional Evaluation
- if
- if and Relatives
- if
- if and Relatives
- if
- if and Relatives
- if
- if and Relatives
- indexing
- LL, Conclusions and Future , Naive Reverse, Naive Reverse
- inter
- RELFUN Toplevel
- interpretation
- Objectives, Abstract Machines, Abstract Machines, Higher-Order Instructions, Benchmarks, RELFUN Toplevel
- is
- Calling LL Functions
- is
- Approach and Results
- is
- Relational-Functional Programming Languages
- is
- Relational-Functional Programming Languages
- Jones
- Determinism in Relational
- jump tables
- (, )
- Kleene
- Determinism in Relational
- Krause
- Restricting the Query
- Kurozumi
- Objectives
- lambda
- Higher-order Builtins
- lambda
- funcall and Relatives
- lambda
- funcall and Relatives
- let*
- let and let*
- let*
- (Single and Re-)
- let
- let and let*
- let
- (Single and Re-)
- LISP
- Approach and Results, Relational-Functional Programming Languages, (, ), Hash TablesJump
- list
- (
- list
- Simple ExpressionsLists,
- list
- Lists and Dotted
- lists
- (, ), (, ), ), Simple ExpressionsLists,
- llp
- Calling LL Functions
- llp
- Calling LL Functions
- ll
- RELFUN Toplevel
- Lloyd
- Background
- load
- RELFUN Toplevel
- local variables
- Simple ExpressionsLists, , setq and Relatives, setq and Relatives, funcall and Relatives
- Lock
- Approach and Results
- Lock
- Relational-Functional Programming Languages
- logic variables
- Relational-Functional Programming Languages, Transforming Relational Languages , Examples, Examples, Examples, Implementing Extra-logicals via , Lists, Global Variables
- loop
- Non-local Exits and
- loop
- Non-local Exits and
- loops
- LL: LISP light, (, ), Registers and Memory , Stack Manipulation, Non-local Exits, (, ), Conclusions and Future
- mapcar
- Prelude
- McCarthy
- LL: LISP light
- McCarthy
- Data Types
- member
- Prelude
- member
- Calling LL Functions
- member
- Relational-Functional Programming Languages
- member
- Relational-Functional Programming Languages
- memory
- (, ), Memory Organization
- mode
- Declarations
- modes
- Restricting the Query , Restricting the Query , Transforming Relational Languages , REL RELFUN Functions, LL, Conclusions and Future , Declarations, Declarations
- modules
- (, ), The Assembler and
- native code
- Objectives, Abstract Machines, Abstract Machines, The Assembler and , Conclusions and Future
- Nilsson
- Determinism in Relational
- non-ground
- seelogic variables
- non-local exits
- (, ), Registers and Memory , (, ), (, )
- nospy
- RELFUN Toplevel
- null
- Simple Builtins
- null
- Lists and Dotted
- Nystrøm
- Integrating Abstract Machines:
- once
- Calling Relations from
- once
- Approach and Results
- once
- Conclusions and Future
- once
- Relational-Functional Programming Languages
- or
- Conditional Evaluation
- or
- if and Relatives
- or
- if and Relatives
- or
- if and Relatives
- partial evaluation
- Determinism in Relational
- pattern matching
- Data Types
- peep-hole optimizer
- The Peep-Hole Optimizer
- pop
- The Peep-Hole Optimizer
- pop
- The Peep-Hole Optimizer
- prelude
- Special Forms and , Prelude, Defining Assembler Instructions
- print
- Simple Builtins
- print
- I/O Builtins
- progn
- Sequential Evaluation
- PROLOG
- Approach and Results, Approach and Results, Approach and Results, Approach and Results, Relational-Functional Programming Languages, Relational-Functional Programming Languages, Abstract Machines, Abstract Machines, LL: LISP light, Data Types, Determinism Transformation, Determinism in Relational , Determinism in Relational , Determinism in Relational , Determinism in Relational , Determinism in Relational , Determinism in Relational , Determinism in Relational , Restricting the Query , RELFUN , RELFUN , RELFUN , LL, Examples, Implementing Extra-logicals via , Hash TablesJump , Conclusions and Future , Conclusions and Future , Benchmarks, Declarations
- psetq
- setq and Relatives
- psetq
- (Single and Re-)
- push-constant
- The Peep-Hole Optimizer
- query set
- (, )
- quote
- Simple ExpressionsLists,
- quote
- Quoting
- read
- Simple Builtins
- read
- I/O Builtins
- registers
- Abstract Machines, Calling LL Functions , (, )
- REL
- Relational-Functional Programming Languages, Abstract Machines, Non-local Exits and , User-definable Functions, Integrating Relations and , Transforming Relational Languages , REL RELFUN Functions, LL, Examples, Implementing Extra-logicals via , Implementing Extra-logicals via , The Representation of , Lists, Naive Reverse, The User Interface, Transforming Deterministic REL\indexREL Predicates
- RELFUN
- Objectives, Approach and Results, Relational-Functional Programming Languages, Relational-Functional Programming Languages, Abstract Machines, REL RELFUN Functions, RELFUN , , Examples, Examples, Implementing Extra-logicals via , The User Interface, Declarations
- remove
- The Peep-Hole Optimizer
- return
- Non-local Exits and
- return
- Non-local Exits and
- reverse
- Prelude
- reverse
- Determinism Transformation
- reverse
- Examples
- reverse
- (
- reverse
- )
- reverse
- Naive Reverse
- Robinson
- Relational-Functional Programming Languages
- search
- Objectives, Objectives, Objectives, Objectives
- search rule
- Determinism in Relational
- sequential evaluation
- Sequential Evaluation, Sequential Evaluation
- set-nth-
- The Peep-Hole Optimizer
- set-nth
- The Peep-Hole Optimizer
- setq
- setq and Relatives
- setq
- (Single and Re-)
- setvar
- Implementing Extra-logicals via
- signatures
- seetypes
- Sloman
- Relational-Functional Programming Languages
- sort
- Prelude
- sorts
- seetypes
- special forms
- Special Forms and
- spy
- RELFUN Toplevel
- stack
- Abstract Machines, Data Types, Calling LL Functions , LLAMA - The , Calling Conventions, Lists, Structures, Equality, (, ), Calling Subroutines, Global Variables, The Compiler Environment, The Compiler Environment, Simple ExpressionsLists, , setq and Relatives, The Peep-Hole Optimizer
- static unification
- Transforming Relational Languages , RELFUN , RELFUN
- Steele
- Non-local Exits and
- Steele
- LL: LISP light
- Steele
- Special Forms and
- Stein
- REL RELFUN Functions
- Stein
- Naive Reverse
- string>
- Numerical and String
- string>
- Simple Builtins
- string>
- String Builtins
- string<
- Numerical and String
- string<
- Simple Builtins
- string<
- String Builtins
- struct
- Simple ExpressionsLists,
- struct
- Simple ExpressionsLists,
- struct
- Data Types
- struct
- Structures
- structp
- Simple Builtins
- structp
- Structures
- structures
- Data Types, (, ), Structures, Structures, Simple ExpressionsLists, , Simple ExpressionsLists,
- tail recursion
- LL: LISP light, Non-local Exits and , Conclusions and Future
- Taylor
- LL
- Taylor
- Objectives
- Taylor
- Conclusions and Future
- throw-nil
- Simple Builtins
- throw
- Non-local Exits and
- throw
- Simple Builtins
- tupof
- seebagof
- types
- Restricting the Query , Restricting the Query , LL, Examples, Examples, Defining Assembler Instructions, Conclusions and Future
- undeclare
- Transforming Deterministic REL
- unification
- Objectives, Objectives, Relational-Functional Programming Languages, Relational-Functional Programming Languages, Data Types, Calling LL Functions , Transforming Relational Languages , RELFUN , RELFUN , RELFUN , , LL, LL, Implementing Extra-logicals via , Conclusions and Future
- user-defined functions
- User-defined Functions
- Van Roy
- Determinism Transformation
- Van Roy
- LL
- Van Roy
- Objectives
- Van Roy
- Conclusions and Future
- Van Roy
- Abstract Machines
- Van Roy
- Abstract Machines
- von Neumann architecture
- Objectives, Abstract Machines
- Warren
- Approach and Results
- Warren
- Conclusions and Future
- Warren
- Abstract Machines
- Wikstrøm
- Background