**Prolog** é unha linguaxe de programación lóxica. O nome de Prolog provén de *programation logique* ("programación lóxica" en francés). Foi creada por Alain Colmerauer e Robert Kowalski sobre o 1972 e é unha alternativa ó Lisp deseñado nos Estados Unidos. Foi un intento de criar unha linguaxe de programación que usase expresións lóxicas na vez de instrucións específicas do computador. En certa maneira, Prolog é un subconxunto de Planner. As ideas de Planner foron máis tarde completamente desenvolvidas na Scientific Community Metaphor.

Prolog é usada en moitos programas de intelixencia artificial e cómputo de linguaxes (especialmente a natural, para a cal foi deseñada). A súa sintaxe e semántica considéranse moi simples e claras, xa que o obxectivo orixinal era fornecer unha ferramenta para lingüistas sen coñecementos en informática.

Os programas de Prolog están constituídos por cláusulas de Horn que constitúen regras do tipo modus ponens, e dicir "Se é verdade o antecedente entón e verdade o consecuente". Os conceptos fundamentais que implementa Prolog son a unificación, a recursividade pola cola (*tail recursion*) e a volta atrás (*backtracking*).

Tipos de datos
--------------

Prolog non emprega tipos de datos da mesmo xeito que o fan a maioría das linguaxes. É preferible falar de elementos lóxicos de Prolog na vez de tipos de datos.

### Átomos

Son constantes de texto. Un átomo é unha secuencia de letras, números e o carácter '\_', que comeza cunha letra minúscula. Usualmente, para representar un átomo non alfanumérico, escríbese entre apóstrofes (p. ex. 'átomo con espazos').

### Números

A maioría das implementacións de Prolog non distinguen entre enteiros e números reais.

### Variables

As variables se denotan por unha cadea de letras, números e o carácter ('\_'), e comeza cunha letra maiúscula. En Prolog unha variable non é un contedor ao que se lle poida asignar un valor coma na programación imperativa.

### Termos

Os termos son a única maneira na que Prolog pode representar datos complexos. Un termo consiste nunha cabeza chamada funtor (que debe ser un átomo) e parámetros (sen restrición de tipos) listados entre parénteses e separados por comas. O número de parámetros chámase aridade do termo. Un termo e identificado pola súa cabeza e a aridade, usualmente escrito funtor/aridade.

### Listas

Unha lista non é un tipo de datos autónomo, está definido recursivamente (usando o termo '.'/2):

1. atom [] é a lista baleira
2. se *T* e unha lista e *H* é un elemento, entón o termo '.'(*H*, *T*) é unha lista.

O primeiro elemento, chamado cabeza, é *H*, que está seguido dos contidos do resto da lista, designado *T* ou cola. A lista [1,2,3] estaría representada internamente como '.'(1, '.'(2, '.'(3, []))). Un atallo sintáctico e [*H* | *T*], que e moi usado para construír regras. A lista enteira pode ser procesada procesando o primeiro elemento, e logo o resto da lista de maneira recursiva.

Por conveniencia de programación, as listas poden ser construídas e desconstruídas de moitos xeitos:

* Enumeración de elementos: [abc, 1, f(x), *Y*, g(*A*,rst)]
* Precedido dun elemento: [abc | *L1*]
* Precedido de múltiplos elementos: [abc, 1, f(x) | *L2*]
* Termo: '.'(abc, '.'(1, '.'(f(x), '.'(*Y*, '.'(g(*A*,rst), [])))))

### Cadeas (Strings)

As cadeas se escriben usualmente como unha secuencia de caracteres entre comiñas. Normalmente se representan internamente como unha lista de códigos ASCII.

Exemplo de Código Prolog
------------------------

```
%%
%% declaracións
%%

paide('xoan', 'maria'). % Xoán é pai de María
paide('pablo', 'xoan'). % Pablo é pai de Juan
paide('pablo', 'marcela').
paide('carlos', 'debora').

% A é fillo de B se B é pai de A
fillode(A,B) :- paide(B,A).

% A é avó de B se A é pai de C y C é pai de B
avode(A,B) :- 
   paide(A,C), 
   paide(C,B).

% A e B son irmáns se o pai de A e tamén o pai de B e se A e B non son o mesmo
irmande(A,B) :- 
   paide(C,A) , 
   paide(C,B), 
   A \== B.

% A e B son familiares se A é pai de B ou A é fillo de B ou A é irmán de B
familiarde(A,B) :- 
   paide(A,B).

familiarde(A,B) :-
   fillo(A,B).

familiarde(A,B) :- 
   irmande(A,B).

%%
%% consultas
%%

% Xoán e irmán de Marcela?
?- irmande('xoan', 'marcela').
yes

%Carlos é irmán de Xoán?
?- irmande('carlos', 'xoan').
no

% Pablo é avó de María?
?- avode('pablo', 'maria').
yes

% María é avoa de Pablo?
?- avode('maria', 'pablo').
no

```

Véxase tamén
------------

### Ligazóns externas

* Laboratorio de programación lóxica da Universidade Politécnica de Madrid.
* Tutorial de programación en Prolog
* Curso intermedio de programación en Prolog

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q163468
* BNF: 11970224v
* GEC: 0052839
* JSTOR: prolog
* LCCN: sh85107397
* MAG: 81721847
* PSH: 12525
* SUDOC: 027719774

 |