Ciao (programming language)

Ciao is a general-purpose programming language which supports logic, constraint, functional, higher-order, and object-oriented programming styles. Its main design objectives are high expressive power, extensibility, safety, reliability, and efficient execution.

Language characteristics

Ciao provides a full Prolog system (supporting ISO-Prolog),
declarative subsets and extensions of Prolog, functional programming (including lazy evaluation), higher-order (with predicate abstractions), constraint programming, and objects, as well as feature terms
(records), persistence, several control rules (breadth-first search, iterative deepening, ...), concurrency (threads/engines), distributed execution (agents), and parallel execution. Libraries also support WWW programming, sockets, external interfaces ( C, Java, TclTk, relational databases, etc.), etc.

Ciao is built on a kernel with an extensible modular design which
allows both restricting and extending the language — it can be seen as a language building language. These restrictions and extensions can be activated separately on each program module so that several extensions can coexist in the same application for different modules.

Developing safe and reliable programs

Programming in the large in Ciao is supported via:

* A robust module/object system. This provides module-based separate/incremental compilation (which is automatic without need for makefiles).
* An integrated assertion language for declaring (optional) program properties (specifications). These include types, modes, determinacy, non-failure, cost (time, memory), etc.
* Automatic inference and static/dynamic checking of such assertions (including unit testing).

Ciao has also support for programming in the small: the compiler is
capable of producing small executables (including only those builtins
used by the program) and the interpreter supports scripting.

The ''environment'' includes a classical top-level and an evolved emacs
interface with an embeddable source-level debugger and a number of
execution visualization tools.

The Ciao preprocessor supports static debugging and verification
assertion checking and optimization via source to source program
transformation. These tasks are performed by Ciaopp, distributed
separately).

Auto-documentation

Ciao includes , an automatic documentation generator. It
processes programs adorned with (Ciao) assertions and machine-readable
comments and generates manuals in many formats including HTML, pdf,
texinfo, info, man, etc., as well as on-line help, ascii README
files, entries for indices of manuals (info, WWW, ...), and maintains
WWW distribution sites.

Portability and efficiency

The Ciao compiler (which can be run outside the top level shell)
generates several forms of architecture-independent and stand-alone
executables, which run with speed, efficiency and executable size
which are very competitive with other high-level languages in general
and in particular with commercial and academic Prolog/CLP
systems. Modules can be compiled into compact bytecode or C source
files, and linked statically, dynamically, or autoloaded.

Example

:- module(qsort, sort/2 []).

% Example: ?- qsort([5,2,3,4,1],X).

qsort(Data, Out) :-
qsort_(Data, Out, []).

qsort_([], R, R).
qsort_([X, L], R, R0) :-
partition(L, X, L1, L2),
qsort_(L2, R1, R0),
qsort_(L1, R, R1.

partition([],_,[],[]).
partition([X, L],Y,[X, L1],L2) :-
X =< Y, !,
partition(L,Y,L1,L2).
partition([X, L],Y,L1,[X, L2]) :-
partition(L,Y,L1,L2).

See also

* Comparison of Prolog implementations
* Prolog syntax and semantics

Further reading

*
*
*
*

References

External links

*

{{DEFAULTSORT:Ciao (programming language)
Prolog programming language family
Functional languages
Functional logic programming languages
Cross-platform software
Dynamically typed programming languages
Free and open source compilers
Cross-platform free software
Object-oriented programming languages
Scripting languages
Text-oriented programming languages