1. Construccion de Predicados o Consultas: And, Or, call And - Or Term1 , Term2 (and): Es verdadero si Term1 es verdadero y Term2 es verdadero Term1 ; Term2 (or): Es verdadero si Term1 es verdadero o si Term2 es verdadero call(+Term): es verdadero si y solo si Term representa un objetivo el cual es verdadero Para call se asume que X se instanciará con un término que puede ser interpretado como un objetivo a cumplir. call(f(a,X)) = f(a,X) 2. Verificación de tipos de términos: atom, integer, atomic, var, nonvar, float, compound atom(+Term) Atomos: Son palabra que no requieren de una sintaxis especial. Sin embargo, los átomos que contienen espacios o algunos otros caracteres especiales deben estar rodeados por comillas simples (O los que empiezan con letra capital para distinguirlos de las variables). La lista vacía también es un átomo. Ejemplos de átomos: x, blue, 'Taco', and 'some atom'. Por lo tanto, un el predicado atom tendrá éxito si el argumento es un átomo o una variable instanciada previamente con un átomo Ejemplos: ?- atom(abc). Yes ?- atom(‘Programación Exploratoria’). Yes ?- Var=abc, atom(Var). Var=abc Yes El predicado atom fallará si el argumento es una variabla sin instanciar, un número o un objeto estructurado (incluyendo una lista) Ejemplo: ?- atom(X). No ?- atom(13). No ?- atom([1,2,3|[X]]). No ?- atom([]). Yes integer(+Term) integer tendrá éxito si el argumento es un entero o una variable previamente instanciada con un entero Ejemplos: ?- integer(1). Yes ?- Var=2, integer(Var). Yes Integer fallará si el argumento es una variable sin instanciar, un átomo, un número flotante o un objeto estructurado ?- integer(Var). No ?- integer(abc). No ?- integer(1.3). No ?- integer(a(x,y,z)). No ?- integer([a,b,c]). No ?- integer([]). No atomic(+Term) atomic(X) :- integer(X). atomic(X) :- atom(X). atomic tendrá éxito si el argumento es un integer, un átomo o una variable previamente instanciada con un átomo o un integer. Ejemplos: ?- atomic(abc). Yes ?- atomic(1). Yes ?- Var=abc, atomic(Var). Yes ?- Var=1, atomic(Var). Yes atomic fallará si el argumento es una variable sin instanciar o un objeto estructurado (incluyendo la lista) Ejemplos: ?- atomic(Var). No ?- atomic(a(x,y,z)). No ?- atomic([a,b,c]). No ?- atomic([]). Yes var(+Term) YES: Si X es actualmente una variable sin instanciar. Una variable sin instanciar puede representar parte de una estructura que aún no ha sido llenada. Cuando tales estructuras están siendo examinadas el predicado var puede ser muy útil para determinar si alguna parte ya ha sido llenada. Ejemplos: ?- var(X). Yes ?-Var1=Var2, var(Var1). Yes Var fallará si el argumento es una variable instanciada, un átomo, un número o un objeto estructurado (incluyendo la lista): Ejemplos: ?- var(abc). No ?- var(123). No ?- var(a(X,Y,Z)). No ?- var([X,Y,Z]). No ?-X=Y, Y=23, var(X). No nonvar(+Term) Tiene éxito si Term NO es una variable libre. Es el opuesto del predicado var(X). Ejemplos: ?-nonvar(abc). Yes ?-nonvar(1). Yes ?-nonvar(a(x,y,z)). Yes ?-nonvar([X,Y,Z]). Yes Si una variable es previamente instanciada también se tiene éxito: ?-Var=abc, nonvar(Var). Yes Nonvar fallará si el argumento es una variable sin instanciar ?-nonvar(Var). No Ejemplo de uso en suma: plus(X,Y,Z) :- nonvar(X), nonvar(Y), Z is X+Y. plus(X,Y,Z) :- nonvar(X), nonvar(Z), Y is Z-X. plus(X,Y,Z) :- nonvar(Y), nonvar(Z), X is Z-Y. float(+Term) float tendrá éxito si el argumento es un flotante (con punto) o una variable previamente instanciada con un flotante: Ejemplos: ?-float(1.3). Yes Float fallará si el argumento es una variable sin instanciar, un átomo o un objeto estructurado: Ejemplos: ?-float(Var). No ?-float(abc). No ?-float(a(b,c)). No ?-float([a,b,c]). No compound(+Term) compound tendrá éxito si el argumento es una estructura o una lista Ejemplos: ?- compound(a(X)). Yes ?- compound([a, B]). Yes compound fallará si el argumento es una variable sin instanciar, un átomo o un número: Ejemplos: ?- compound(Var). no ?- compound(abc). no ?- compound(1). No 3. Análisis y Construcción de Términos: functor, arg, name functor(?Term,?Name,?Arity) Functor(T,F,N): T es una estructura con nombre o functor F y aridad (cantidad de argumentos) N. Este predicado permite extraer el functor y la aridad de un término cualquiera. Pero, al ser reversible, también permite construir nuevos términos a partir del functor y la aridad deseada. Los modos de uso son: functor(+Termino,-Functor,-Aridad). functor(-Termino,+Functor,+Aridad). Primero, si T esta instanciada. El propósito falla si T no es un átomo o una estructura. Si T es un átomo o una estructura, F se machea con el functor y N se machea con el entero dado por la aridad del functor (un átomo es considerado como una estructura con aridad 0). En el caso de las listas el functor es representado por ‘.’ y la aridad es siempre 2 (cabeza y cola). ?- functor(termino(arg(1),arg(2)),Functor,Aridad). Aridad = 2, Functor = termino yes La otra forma de usarlo es si T no está instanciado, en este caso los otros dos deben estar instanciados. T se instanciará con la estructura creada a partir del functor dado y la cantidad de argumentos dada por la aridad. Sus argumentos siempre serán nuevas variables libres: Ejemplos: ?- functor(NuevoTermino,prueba,4). NuevoTermino = prueba(_,_,_,_) Yes ?- functor(f(a,b,g(Z)),F,N) Yes Z=_23, F=f, N=3 ?- functor(a+b,F,N). Yes F=+, N=2 ?- functor([a,b,c,d],F,N). Yes F=‘.’, N=2 ?- functor(javaprolog,F,A). Yes F=javaprolog N=0. arg(+Arg,+Term,?Value) Ahora que podemos construir términos, sería deseable poder asignarles argumentos. Uno de los predicados que permiten esto es arg. Para ello se indica el número de índice del argumento deseado, empezando a numerar por el 1 de izquierda a derecha. El modo de uso es: arg(+Indice,+Termino,-Argumento). El predicado arg debe ser utilizado con sus dos primeros argumentos instanciados. El primero especifica el argumento (numero) requerido de la estructura. El segundo especifica la estructura en la que se debe encontrar el argumento buscado. El primer uso de este predicado es extraer un argumento concreto de un término: Ejemplos: ?- arg(2,termino(a,b,c,d),ARG). ARG = b yes Si el término tiene variables libres como argumento, se les puede asignar valor mediante arg. Pero el resultado es el mismo que una simple unificación mediante =. Esto se observa en el siguiente ejemplo: ?- Termino = p(X,b), arg(1,Termino,zzz). Termino = p(zzz,b), X = zzz yes ?- Termino = p(X,b), Termino = p(zzz,_). Termino = p(zzz,b), X = zzz yes El predicado arg solamente es útil cuando se conoce a priori el número de argumentos del término manipulado, pero en combinación con functor resulta muy eficaz. ?- arg(2,app(a,b,c),V). Yes V=b ?- arg(2,[a,b,c],V). Yes V=[b,c] ?- arg(2, a+(b+c), V). Yes V=‘+’(b,c) ?- functor (X, prueba, 1), arg(1, X, a). Yes X=prueba(a) name(+Term,?List) Relaciona un átomo con su lista de caracteres (código ACII). ?- name(apple, X). Yes X=[97,112,112,108,101] ?- name(apple, [97, 112, 112, 108, 101]). Yes 4. Igualdad: =, ==, \=,\== == es mucho más restrictivo que “=“. Si X==Y, entonces X=Y (No al revés). “=” considerará una variable no instanciada como igual a cualquier cosa, porque puede ser matcheada con cualquier cosa. Por otra parte “==” solo considera una variable no instanciada como igual a otra no instanciada. “\==” es el opuesto de “==“ Ejemplos: ?- X == 2 No ?- X = 2 Yes ?- X == Y. Yes ?- X == X. X=_23, Yes. ?- X=Y , X==Y. X=_23, Y=_23 Yes ?Term1 = ?Term2. COMPARA Y ASIGNA ?Term1 \= ?Term2. COMPARA Y ASIGNA ?Term1 == ?Term2 (más restrictivo que “=“) SOLO PARA COMPARAR ?Term1 \== ?Term2 (más restrictivo que “\=“) SOLO PARA COMPARAR Ejemplos: ?- X==Y. Yes ?- X==2. No ?- X=Y. Yes ?- X=2. Yes ?- X\=Y. No ?- X\=2. No ?- X\==Y. Yes ?- X\==2. Yes 5. Comparación de números +Integer1 = +Integer2 +Integer1 \= +Integer2 +Integer1 < +Integer2 +Integer1 =< +Integer2 +Integer1 > +Integer2 +Integer1 >= +Integer2 6. Aritmética Entera En el IS, si o si lo de la derecha tiene que estar instanciado y es la UNICA forma de hacer operaciones matemáticas. No sirve el igual. +Integer1 + +Integer2 +Integer1 - +Integer2 +Integer1 * +Integer2 +Integer1 / +Integer2 +Integer1 mod +Integer2 ?Integer is +Term -- Term debe ser aritméticamente evaluable Ejemplo: ?- X is 7 mod 4. X=3 Yes