6.

Operadores en PROLOG
1. Definicin de operadores propios
2. Operadores predefinidos

Igualdad

Entrada y Salida bsicos

Manejo de ficheros

Evaluacin de expresiones aritmticas

Comparacin de nmeros

Introduccin de nuevas clusulas

6. Operadores en PROLOG
2. Operadores predefinidos (cont.)

Cumplimiento y fracaso de objetivos

Clasificacin de trminos

Manejo de clusulas como trminos

Construccin y acceso a componentes de

estructuras

Control de la re-evaluacin

Metavariables

1. Declaracin de operadores (I)

Utilizacin de un predicado predefinido:

?- op(Precedencia, Tipo, Nombre).

?- op(500, yfx, por).
yes
?- X= a por b.
X= a por b

Precedencia [1, 1200] y depende de implementaciones.

Tipo:

Aridad
Notacin o posicin

Infijo: xfy, yfx, xfx, yfy

(f representa operador; x e y operandos)
Prefijo: fx, fy.
Sufijo: xf, yf

Declaracin de operadores (II)

Asociatividad:

y indica que el argumento puede contener operadores

de igual o menor precedencia.
x obliga a que sea estrictamente menor.

Ejemplo: + declarado como yfx.

a+b+c:

a+(b+c) (a+b)+c

La primera opcin queda eliminada porque el

segundo argumento no puede contener un operador de
precedencia igual.

Esto se conoce como asociatividad por la izquierda (yfx),

por la derecha (xfy) o indistintamente (xfx); segn esto,
no tendra sentido (yfy).

2. Operadores predefinidos

Ya hemos visto:

Pueden tener efectos laterales al satisfacerse,

adems de instanciar variables.

Pueden forzar a que los argumentos sean de un

cierto tipo.

Ejemplo: corte

Ejemplo: < necesita dos argumentos numricos

Definiremos los predicados que deberan

formar el ncleo del intrprete PROLOG,
aunque habr que revisarlos para cada
versin

2.1. Igualdad

X = Y.

X \= Y.

Unificacin: intenta hacer X e Y iguales mediante

unificacin.
Su opuesto: no unifican

X == Y. Identidad

Ms restrictivo que X = Y. Se satisface si X = Y, pero no

necesariamente a la inversa.
?????-

X = Y.
X == X.
X = Y, X == Y.
append([A|B], C) == append(X, Y).
append([A|B], C) == append([A|B], C).

X \== Y.

Su opuesto.

2.2. Entrada y Salida bsicos

Lectura

Escritura

write(X),
display(X)
put(X)

Formato:

read(X),
get0(X),
get(X)

nl
tab(X)

skip(+Code)

skip(a).

2.3. Manejo de ficheros

Lectura:

see(X),
seeing(X),
seen

Escritura:

tell(X),
telling(X),
told

2.4. Evaluacin de expresiones

aritmticas

X is Y.

X
X
X
X
X

Fuerza la evaluacin de Y para unificar con X.

Los siguientes slo se evalan si estn a la
derecha de is:

+ Y.
Y.
* Y.
/ Y.
mod Y.

2.5. Comparacin de nmeros

X
X
X
X
X
X

= Y.
\= Y.
< Y.
> Y.
>= Y.
=< Y.

2.6. Introduccin de nuevas clusulas

consult(X).
Aade nuevas clausulas. Si ya estn definidos predicados,
aade clausulas al final.
?- consult(fichero).
?- consult(fichero1), consult(fichero2).

reconsult(X).
Las clausulas leidas substituyen a las actuales.
?- reconsult(fichero3), reconsult(fichero4).

Notacin de lista:
fichero para consult.
-fichero para reconsult.
?- [fichero1, -fichero3.pl, fichero2.pl, -fichero4.pl]

2.7. Cumplimiento y fracaso de objetivos

true

siempre se cumple

fail

siempre fracasa
Utilidades:

..., !, fail.

si la ejecucin llega hasta este punto, debemos dejar de intentar

satisfacer el objetivo: fail lo hace fracasar y el corte anula la
re-satisfaccin.

,!, genera(X), muestra(X), fail.

queremos recorrer todas las soluciones de un objetivo y, por

ejemplo, mostrarlas.

2.8. Clasificacin de trminos

Permiten seleccionar ciertos tipos de trminos para
ser utilizados en las clausulas:
var(X)
se satisface si en ese momento X es una variable no
instanciada
permite saber si una variable ya tiene o no un valor,
pero sin fijrselo como efecto lateral
?- var(X).
yes
?- var(23).
no
?- X = Y, Y = 23, var(X).
?

nonvar(X)

comportamiento opuesto al anterior

Clasificacin de trminos (II)

atom(X)
se cumple si X identifica en ese momento un tomo
?- atom(23).
no
?- atom(libros).
yes
?- atom(esto es una cadena).
?

integer(X)

se satisface si X representa en ese momento a un entero

atomic(X)
se cumple si en ese momento X es un entero o un
tomo
atomic(X):- atom(X).
atomic(X):- integer(X).

2.9. Manejo de clusulas como trminos

PROLOG permite al programador examinar y modificar
otros programas PROLOG:

construir estructuras que representen clusulas

aadir clausulas
retirar clausulas

Para PROLOG una clusula es una estructura

le_gusta_a(juan, X) :- le_gusta_a(X, vino).

Una clausula es una estructura cuyo functor principal es :-

y cuyos argumentos son cabeza y cuerpo de la clausula.
:-(le_gusta_a(juan, X), le_gusta_a(X, vino))

Si la cola tiene varios trminos, deben considerarse unidos

por el functor ,.

abuelo(X, Z):- padres(X, Y), padres(Y,Z).

:-(abuelo(X, Z), ,(padres(X,Y) padres(Y,Z)))

Manejo de clusulas como trminos (II)

listing(A).

Se muestran por el canal de salida activo todas las clusulas

asociadas al tomo al que est instanciado A.
El formato depende del intrprete.
til para descubrir errores.

Ejemplo:

?- [recorrer_fichero].
?- listing(mostrar_fichero).
mostrar_fichero :write('Nombre de fichero: '),
read(A),
see(A),
muestra_contenido,
seen.

Manejo de clusulas como trminos (III)

clause(X, Y).

Si se satisface hace coincidir X e Y con la cabeza y el cuerpo de

una clusula existente. Si no, falla.
Si no hay clusulas asociadas, fracasa.
X debe tener informacin para identificar el predicado principal.
Se instancia a la primera clusula y si se re-satisface, irn
instancindose a las siguientes clusulas.
Para los hechos instancia el cuerpo a true.
Ejemplo:
aadir_sin_duplicar(X, L, L):- member(X, L), !.
aadir_sin_duplicar(X, L, [X|L]).
?- clause(aadir_sin_duplicar(X, U, V), Y).
U=V
Y = member(X,L),! ;
V = [X|U]
Y = true.

Manejo de clusulas como trminos (IV)

asserta(X), assertz(X).

Aade una nueva clausula a la BC: asserta() lo hace al

principio de la misma y assertaz() al final.
X debe estar suficientemente instanciada ser una clusula
vlida.
Una vez satisfecho, no se deshace aunque haya
reevaluacin.
La nica forma de eliminar entonces la clusula es con:

retract(X).

X debe estar suficientemente instanciada para identificar

una clusula vlida.
Si se satisface, elimina la primera clusula.
Si se reevala, eliminar las siguientes.

2.10. Construccin y acceso de

componentes de estructuras

Se pueden escribir programas con clusulas que

hagan referencia a estructuras arbitrarias
functor(T, F, N).

T es una estructura con functor F y aridad N

Si T est instanciada, fracasar si T no es un tomo o una
estructura. Si no fracasa, nos dar el functor F y su aridad N
Si T no est instanciada, deben estarlo F y N. T devolver
las estructuras que verifiquen F y N.
Ejemplos:
?- functor(a+b, F, N).
F = +, N = 2
?- functor([a, b, c], F, N).
F = ., N = 2
?- functor([a, b, c], ., 3).
No

Construccin y acceso de
componentes de estructuras (II)

arg(N, T, A).

N debe indicar una posicin en los argumentos de T

Ambos deben estar instanciados
A ser el argumento N-simo de T

X =.. L

Llamado histricamente univ

L es la lista que consiste en el functor de X seguido de los
argumentos de X
Permite:
a) obtener todos los argumentos de una estructura
b) construir una estructura a partir de una lista

Ejemplo:
?- algo(a, b, c) =.. L.
L = [algo, a, b, c]

Construccin y acceso de
componentes de estructuras (III)
Ejemplo:
?- X =.. [f, a, b, c].
X = f(a, b, c).

name(A, L)

Permite manejar tomos arbitrarios

Relaciona un tomo, A, con la lista de caracteres ASCII que lo
compone, L
Ejemplos:
?- name(prueba, X).

X = [112, 114, 117, 101, 98, 97]

?- name(prueba, prueba).
yes
?- name(X, [112, 114, 117, 101, 98, 97]).
X = prueba

2.11. Control de la reevaluacin

Predicado predefinido corte !

Detiene la bsqueda de nuevas soluciones

repeat
Permite buscar soluciones alternativas.
Sera equivalente a tener definido:
repeat.
repeat :- repeat.

Se usa en combinacin con corte y fail

echo :- repeat, read(X), echo(X),!.
echo(X):- X=end_of_file, !.
echo(X):- write(X), nl, fail.

2.12. Metavariables

call(X)

el objetivo call(X) se cumple si se satisface X como objetivo

?- padre(X).
?- call(padre(X)).
?-Meta=..[padre ,X], call(Meta).

not(X)

\+ padre(X).
not(padre(X)).

X, Y

conjuncin de objetivos

X;Y

disyuncin de objetivos