6. Operadores en PROLOG6. Operadores en PROLOG

1.1. Definición de operadores propiosDefinición de operadores propios

2.2. Operadores predefinidosOperadores predefinidos IgualdadIgualdad

Entrada y Salida básicosEntrada y Salida básicos

Manejo de ficherosManejo de ficheros

Evaluación de expresiones Evaluación de expresiones

aritméticasaritméticas

Comparación de númerosComparación de números

Introducción de nuevas clausulasIntroducción de nuevas clausulas

6. Operadores en PROLOG6. Operadores en PROLOG

2. Operadores predefinidos (cont.)2. Operadores predefinidos (cont.) Cumplimiento y fracaso de objetivosCumplimiento y fracaso de objetivos

Clasificación de términosClasificación de términos

Manejo de clausulas como términosManejo de clausulas como términos

Construcción y acceso a componentes Construcción y acceso a componentes

de estructurasde estructuras

Control de la re-evaluaciónControl de la re-evaluación

MetavariablesMetavariables

1. Declaración de operadores (I)1. Declaración de operadores (I)

Utilización de un predicado predefinido:Utilización de un predicado predefinido: ?- op(Precedencia, Especificaciones, ?- op(Precedencia, Especificaciones,

Nombre).Nombre).

Precedencia Precedencia Є [1, 255] y depende de Є [1, 255] y depende de implementaciones.implementaciones.

Especificaciones:Especificaciones: AridadAridad Notación o posiciónNotación o posición

Infijo: xfy, yfx, xfx, yfy Infijo: xfy, yfx, xfx, yfy (f representa operador; x e y (f representa operador; x e y

operandos)operandos) Prefijo: fx, fy.Prefijo: fx, fy. Sufijo: xf, yfSufijo: xf, yf

Declaración de operadores (II)Declaración de operadores (II)

Asociatividad:Asociatividad: ““y” indica que el argumento puede contener y” indica que el argumento puede contener

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

Ejemplo: “+” declarado como yfx.Ejemplo: “+” declarado como yfx. ““a+b+c”:a+b+c”: a+(b+c) ó (a+b)+ca+(b+c) ó (a+b)+c

La La primera opciónprimera opción queda queda eliminada porque el segundo argumento no puede eliminada porque el segundo argumento no puede contener un operador de precedencia igual.contener un operador de precedencia igual.

Esto se conoce como asociatividad por la izquierda Esto se conoce como asociatividad por la izquierda (yfx), por la derecha (xfy) o indistintamente (xfx); (yfx), por la derecha (xfy) o indistintamente (xfx); según esto, no tendría sentido (yfy).según esto, no tendría sentido (yfy).

2. Operadores predefinidos2. Operadores predefinidos

Ya hemos visto:Ya hemos visto: Pueden tener efectos laterales al Pueden tener efectos laterales al

satisfacerse, además de instanciar satisfacerse, además de instanciar variables.variables.

Ejemplo: corteEjemplo: corte Pueden forzar a que los argumentos sean Pueden forzar a que los argumentos sean

de un cierto tipo.de un cierto tipo. Ejemplo: < necesita dos argumentos numéricosEjemplo: < necesita dos argumentos numéricos

Definiremos los predicados que Definiremos los predicados que deberíandeberían formar el núcleo del intérprete formar el núcleo del intérprete PROLOG, aunque habrá que revisarlos PROLOG, aunque habrá que revisarlos para cada versiónpara cada versión

2.1. Igualdad2.1. Igualdad

X = Y.X = Y. Intenta hacer X e Y iguales.Intenta hacer X e Y iguales.

X \= Y.X \= Y. Su opuesto.Su opuesto.

X == Y.X == Y. Más restrictivo que X = Y. Se satisface si X = Y, pero Más restrictivo que X = Y. Se satisface si X = Y, pero

no necesariamente a la inversa.no necesariamente a la inversa.?- X = Y.?- X = Y.?- X == X.?- X == X.?- X = Y, X == Y.?- X = Y, X == Y.?- append([A|B], C) == append(X, Y).?- append([A|B], C) == append(X, Y).?- append([A|B], C) == append([A|B], C).?- append([A|B], C) == append([A|B], C).

X \== Y.X \== Y. Su opuesto.Su opuesto.

2.2. Entrada y Salida básicos2.2. Entrada y Salida básicos

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

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

Formato:Formato: nlnl tab(X)tab(X)

skip(X)skip(X) op(X, Y, Z)op(X, Y, Z)

2.3. Manejo de ficheros2.3. Manejo de ficheros

Lectura:Lectura: see(X), see(X), seeing(X), seeing(X), seenseen

Escritura:Escritura: tell(X), tell(X), telling(X), telling(X), toldtold

2.4. Evaluación de expresiones 2.4. Evaluación de expresiones aritméticasaritméticas

X is Y.X is Y. Fuerza la evaluación de Y para coincidir con Fuerza la evaluación de Y para coincidir con

X.X. Los siguientes sólo se evalúan si están a la Los siguientes sólo se evalúan si están a la

derecha de is:derecha de is: X + Y.X + Y. X – Y.X – Y. X * Y.X * Y. X / Y.X / Y. X mod Y.X mod Y.

2.5. Comparación de números2.5. Comparación de números

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

2.6. Introducción de nuevas cláusulas2.6. Introducción de nuevas cláusulas

consult(X).consult(X). Añade nuevas clausulas. Si ya están definidos Añade nuevas clausulas. Si ya están definidos

predicados, añade clausulas al final.predicados, añade clausulas al final.?- consult(fichero).?- consult(fichero).?- consult(fichero1), consult(fichero2).?- consult(fichero1), consult(fichero2).

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

Notación de lista:Notación de lista: ficherofichero para consult. para consult. -fichero-fichero para reconsult. para reconsult.?- [fichero1, -’fichero3.pl’, ‘fichero2.pl’, -’fichero4.pl’?- [fichero1, -’fichero3.pl’, ‘fichero2.pl’, -’fichero4.pl’]]

2.7. Cumplimiento y fracaso de 2.7. Cumplimiento y fracaso de objetivosobjetivos

truetrue siempre se cumplesiempre se cumple

failfail siempre fracasasiempre fracasa Utilidades:Utilidades:

..., !, fail...., !, fail.si la ejecución llega hasta este punto, debemos dejar de si la ejecución llega hasta este punto, debemos dejar de

intentar satisfacer el objetivo: fail lo hace fracasar y el intentar satisfacer el objetivo: fail lo hace fracasar y el corte anula la re-satisfacción.corte anula la re-satisfacción.

!- genera(X), muestra(X), fail.!- genera(X), muestra(X), fail.queremos recorrer todas las soluciones de un objetivo y, queremos recorrer todas las soluciones de un objetivo y,

por ejemplo, mostrarlas.por ejemplo, mostrarlas.

2.8. Clasificación de términos2.8. Clasificación de términos

Permiten seleccionar ciertos tipos de términos Permiten seleccionar ciertos tipos de términos para ser utilizados en las clausulas:para ser utilizados en las clausulas: var(X)var(X)

se satisface si en ese momento X es una variable se satisface si en ese momento X es una variable no instanciadano instanciada

permite saber si una varible ya tiene o no un valor, permite saber si una varible ya tiene o no un valor, pero sin fijárselo como efecto lateralpero sin fijárselo como efecto lateral

?- var(X).?- var(X).yesyes?- var(23).?- var(23).nono?- X = Y, Y = 23, var(X).?- X = Y, Y = 23, var(X).¿?¿?

nonvar(X)nonvar(X) comportamiento opuesto al anteriorcomportamiento opuesto al anterior

Clasificación de términos (II)Clasificación de términos (II)

atom(X)atom(X) se cumple si X identifica en ese momento un átomose cumple si X identifica en ese momento un átomo?- atom(23).?- atom(23).nono?- atom(libros).?- atom(libros).yesyes?- atom(“esto es una cadena”).?- atom(“esto es una cadena”).¿?¿?

integer(X)integer(X) se satisface si X representa en ese momento a un se satisface si X representa en ese momento a un

enteroentero atomic(X)atomic(X)

se cumple si en ese momento X es un entero o un se cumple si en ese momento X es un entero o un átomoátomo

atomic(X):- atom(X).atomic(X):- atom(X).atomic(X):- integer(X).atomic(X):- integer(X).

2.9. Manejo de cláusulas como 2.9. Manejo de cláusulas como términostérminos

PROLOG permite al programador examinar y PROLOG permite al programador examinar y modificar otros programas PROLOG:modificar otros programas PROLOG: construir estructuras que representen cláusulasconstruir estructuras que representen cláusulas añadir clausulasañadir clausulas retirar clausulasretirar clausulas

Para PROLOG una cláusula es una estructuraPara PROLOG una cláusula es una estructurale_gusta_a(juan, X) :- le_gusta_a(X, vino).le_gusta_a(juan, X) :- le_gusta_a(X, vino).

Una clausula es una estructura cuyo functor Una clausula es una estructura cuyo functor principal es ‘:-’ y cuyos argumentos son cabeza y principal es ‘:-’ y cuyos argumentos son cabeza y cuerpo de la clausula.cuerpo de la clausula.

‘‘:-’(le_gusta_a(juan, X), le_gusta_a(X, vino)):-’(le_gusta_a(juan, X), le_gusta_a(X, vino)) Si la cola tiene varios términos, deben considerarse Si la cola tiene varios términos, deben considerarse

unidos por el functor ‘,’.unidos por el functor ‘,’. abuelo(X, Z):- padres(X, Y), padres(Y,Z).abuelo(X, Z):- padres(X, Y), padres(Y,Z). ‘‘:-’(abuelo(X, Z), ‘,’(padres(X,Y) padres(Y,Z))):-’(abuelo(X, Z), ‘,’(padres(X,Y) padres(Y,Z)))

Manejo de cláusulas como términos Manejo de cláusulas como términos (II)(II)

listing(A).listing(A). Se muestran por el canal de salida activo todas las Se muestran por el canal de salida activo todas las

cláusulas asociadas al átomo al que esté instanciado cláusulas asociadas al átomo al que esté instanciado A.A.

El formato depende del intérprete.El formato depende del intérprete. Útil para descubrir errores.Útil para descubrir errores.

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

Manejo de cláusulas como términos Manejo de cláusulas como términos (III)(III)

clause(X, Y).clause(X, Y). Si se satisface hace coincidir X e Y con la cabeza y el Si se satisface hace coincidir X e Y con la cabeza y el

cuerpo de una cláusula existente. Si no, falla.cuerpo de una cláusula existente. Si no, falla. Si no hay cláusulas asociadas, fracasa.Si no hay cláusulas asociadas, fracasa. X debe tener información para identificar el predicado X debe tener información para identificar el predicado

principal. principal. Se instancia a la primera cláusula y si se re-satisface, irán Se instancia a la primera cláusula y si se re-satisface, irán

instanciándose a las siguientes cláusulas.instanciándose a las siguientes cláusulas. Para los hechos instancia el cuerpo a true.Para los hechos instancia el cuerpo a true. Ejemplo:Ejemplo:

añadir_sin_duplicar(X, L, L):- member(X, L), !.añadir_sin_duplicar(X, L, L):- member(X, L), !.

añadir_sin_duplicar(X, L, [X|L]).añadir_sin_duplicar(X, L, [X|L]).?- clause(añadir_sin_duplicar(X, U, V), Y).?- clause(añadir_sin_duplicar(X, U, V), Y).U=VU=VY = member(X,L),! ;Y = member(X,L),! ;

V = [X|U]V = [X|U]Y = true.Y = true.

Manejo de cláusulas como términos Manejo de cláusulas como términos (IV)(IV)

asserta(X), assertz(X).asserta(X), assertz(X). Añade una nueva clausula a la BC: Añade una nueva clausula a la BC: assertassertaa()() lo hace lo hace

al principio de la misma y al principio de la misma y assertaassertazz()() al final. al final. X debe estar suficientemente instanciada para X debe estar suficientemente instanciada para

identificar al menos el predicado principal de una identificar al menos el predicado principal de una cláusula válida.cláusula válida.

Una vez satisfecho, no se deshace aunque haya Una vez satisfecho, no se deshace aunque haya reevaluación.reevaluación.

La única forma de eliminar entonces la cláusula es La única forma de eliminar entonces la cláusula es con:con:

retract(X).retract(X). X debe estar suficientemente instanciada para X debe estar suficientemente instanciada para

identificar al menos el predicado principal de una identificar al menos el predicado principal de una cláusula válida.cláusula válida.

Si se satisface, elimina la primera cláusula.Si se satisface, elimina la primera cláusula. Si se reevalúa, eliminará las siguientes.Si se reevalúa, eliminará las siguientes.

2.10. Construcción y acceso de 2.10. Construcción y acceso de componentes de estructurascomponentes de estructuras

Se pueden escribir programas con cláusulas Se pueden escribir programas con cláusulas que hagan referencia a estructuras arbitrariasque hagan referencia a estructuras arbitrarias

functor(T, F, N).functor(T, F, N). T es una estructura con functor F y aridad NT es una estructura con functor F y aridad N Si T está instanciada, fracasará si T no es un átomo o Si T está instanciada, fracasará si T no es un átomo o

una estructura. Si no fracasa, nos dará el functor F y una estructura. Si no fracasa, nos dará el functor F y su aridad Nsu aridad N

Si T no está instanciada, deben estarlo F y N. T Si T no está instanciada, deben estarlo F y N. T devolverá las estructuras que verifiquen F y N.devolverá las estructuras que verifiquen F y N.

Ejemplos:Ejemplos:?- functor(a+b, F, N).?- functor(a+b, F, N).F = +, N = 2F = +, N = 2?- functor([a, b, c], F, N).?- functor([a, b, c], F, N).F = ., N = 2F = ., N = 2?- functor([a, b, c], ‘.’, 3).?- functor([a, b, c], ‘.’, 3).NoNo

Construcción y acceso de Construcción y acceso de componentes de estructuras (II)componentes de estructuras (II)

arg(N, T, A).arg(N, T, A). N debe indicar una posición en los argumentos de TN debe indicar una posición en los argumentos de T Ambos deben estar instanciadosAmbos deben estar instanciados A será el argumento N-ésimo de TA será el argumento N-ésimo de T

X =.. LX =.. L Llamado históricamente “univ”Llamado históricamente “univ” L es la lista que consiste en el functor de X seguido L es la lista que consiste en el functor de X seguido

de los argumentos de Xde los argumentos de X Permite:Permite:

a) obtener todos los argumentos de una estructuraa) obtener todos los argumentos de una estructurab) construir una estructura a partir de una listab) construir una estructura a partir de una lista

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

Construcción y acceso de Construcción y acceso de componentes de estructuras (III)componentes de estructuras (III)

Ejemplo:Ejemplo:?- X =.. [f, a, b, c].?- X =.. [f, a, b, c].X = f(a, b, c).X = f(a, b, c).

name(A, L)name(A, L) Permite manejar átomos arbitrariosPermite manejar átomos arbitrarios Relaciona un átomo, A, con la lista de caracteres ASCII Relaciona un átomo, A, con la lista de caracteres ASCII

que lo compone, Lque lo compone, L

Ejemplos:Ejemplos:?- name(prueba, X).?- name(prueba, X).

L = [112, 114, 117, 101, 98, 97]L = [112, 114, 117, 101, 98, 97]?- name(prueba, “prueba”).?- name(prueba, “prueba”).yesyes?- name(X, [112, 114, 117, 101, 98, 97]).?- name(X, [112, 114, 117, 101, 98, 97]).X = pruebaX = prueba

2.11. Control de la reevaluación2.11. Control de la reevaluación

Predicado predefinido corte ó !Predicado predefinido corte ó ! Detiene la búsqueda de nuevas solucionesDetiene la búsqueda de nuevas soluciones

repeatrepeat Permite buscar soluciones alternativas.Permite buscar soluciones alternativas. Sería equivalente a tener definido:Sería equivalente a tener definido:repeat.repeat.repeat :- repeat.repeat :- repeat.

Se usa en combinación con corte y failSe usa en combinación con corte y failecho :- repeat, read(X), echo(X),!.echo :- repeat, read(X), echo(X),!.

echo(X):- X=end_of_file, !.echo(X):- X=end_of_file, !.

echo(X):- write(X), nl, failecho(X):- write(X), nl, fail..

2.12. Metavariables2.12. Metavariables

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

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

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

X, YX, Y conjunción de objetivosconjunción de objetivos

X ; YX ; Y disyunción de objetivosdisyunción de objetivos