Category:Lambda Prolog: Difference between revisions

From Rosetta Code
Content added Content deleted
(Genrating template)
 
mNo edit summary
 
(One intermediate revision by the same user not shown)
Line 1: Line 1:
{{stub}}{{language|Lambda Prolog}}
{{language
|exec=compiled
|site=http://www.lix.polytechnique.fr/~dale/lProlog/
|strength=strong
|safety=safe
|express=explicit
|checking=static
|parampass=value
|compat=structural
|gc=yes
|LCT=yes
|bnf=no}}{{language programming paradigm|Declarative}}{{language programming paradigm|Logic_Programming}}

From [http://www.lix.polytechnique.fr/~dale/lProlog/ the principle λProlog] page:

<blockquote>
λProlog is a logic programming language based on an intuitionistic fragment of Church's Simple Theory of Types. Such a strong logical foundation provides λProlog with logically supported notions of

# modular programming,
# abstract datatypes,
# higher-order programming, and
# the lambda-tree syntax approach to the treatment of bound variables in syntax.

Implementations of λProlog contain implementations of the simply typed λ-terms as well as (of subsets) of higher-order unification.
</blockquote>

The syntax is similar to [[Prolog]], but it extends Prolog's basis of [https://en.wikipedia.org/wiki/Horn_clause Horn clause logic] to [https://en.wikipedia.org/wiki/Harrop_formula higher-order hereditary Harrop formulas]. Its higher-order nature allows for quantifying over predicates, and its basis in lambda-tree syntax facilitates construction of terms using lambda abstraction. All λProlog predicates require explicit type signatures.

λProlog was first developed in 1986. It has had a number implementations, and is still under active development.

Latest revision as of 17:23, 27 March 2016

Language
Lambda Prolog
This programming language may be used to instruct a computer to perform a task.
Official website
Execution method:
Garbage collected: Yes
Parameter passing methods: By value
Type safety: Safe
Type strength: Strong
Type compatibility: Structural
Type expression: Explicit
Type checking: Static
See Also:
Listed below are all of the tasks on Rosetta Code which have been solved using Lambda Prolog.


From the principle λProlog page:

λProlog is a logic programming language based on an intuitionistic fragment of Church's Simple Theory of Types. Such a strong logical foundation provides λProlog with logically supported notions of

  1. modular programming,
  2. abstract datatypes,
  3. higher-order programming, and
  4. the lambda-tree syntax approach to the treatment of bound variables in syntax.

Implementations of λProlog contain implementations of the simply typed λ-terms as well as (of subsets) of higher-order unification.

The syntax is similar to Prolog, but it extends Prolog's basis of Horn clause logic to higher-order hereditary Harrop formulas. Its higher-order nature allows for quantifying over predicates, and its basis in lambda-tree syntax facilitates construction of terms using lambda abstraction. All λProlog predicates require explicit type signatures.

λProlog was first developed in 1986. It has had a number implementations, and is still under active development.

Pages in category "Lambda Prolog"

This category contains only the following page.