Objetivos Integrados do Prolog
Objetivos integrados ao Prolog
Este capítulo contém um resumo descritivo da maioria dos objetivos internos importantes do Prolog. Para mais detalhes consulte a documentação do SWI-Prolog
4.1 Objetivos de Utilidade
help(S)
S deve ser um átomo simbólico, por exemplo, help(assert).
halt
Para o Prolog, retoma o sistema operacional.
trace, notrace
Liga e desliga o trace, respectivamente.
4.2 Universais (verdadeiro e falha)
true
Sempre verdadeiro como objetivo.
fail
Sempre falha como objetivo.
4.3 Carregando programas Prolog
consult(F)
Carrega o programa do arquivo F. F deve ser vinculado à expressão do designador do arquivo, por exemplo, F='[root.programs.prolog]prog.pro' ou F='/home/user/prolog/sample.pl', dependendo do sistema operacional.
reconsult(F)
Semelhante ao consult, exceto que cada predicado já definido tem sua definição substituída pela nova definição sendo carregada.
[F1,F2,...]
Notação de colchetes, ou seja, consulta F1, depois consulta F2, então ...
4.4 Objetivos aritméticos
N > M , N < M, N =< M, N >= M
Essas relações testam exatamente como parecem. Obviamente, M e N devem ser associados a números para que esses objetivos sejam bem-sucedidos ou falhem (e não causem erros).
4.5 Tipos de teste
atom(X)
Testa se X está ligado a um átomo simbólico. Por exemplo,
?- atom(foot).
yes
?- atom(3).
no
?- atom('foot').
yes
?- atom("foot").
no
integer(X)
Testa se X está associado a um número inteiro.
real(X)
Testa se X está associado a um número real.
string(X)
Testa se X está associado a uma string.
4.6 Igualdade de termos Prolog e unificação
X = Y, X \=Y
Testa se X e Y podem ser unificados ou não, respectivamente. Por exemplo,
?- [X,Y|R] = [a,b,c].
X = a, Y = b, R = [c]
?- [X,Y,Z] = [a,b].
no
X ==Y, X \== Y
Testa se X e Y estão atualmente co-ligados, ou seja, foram associados ou compartilham o mesmo valor, ou não, respectivamente. Por exemplo,
?- X = 3, Y = 1 * 3, X == Y.
no
?- X = a, [Y|_]= [a,b,c], X == Y.
X = a, Y = a4.7 Controle no Prolog
call(P)
Força P a ser um objetivo; tem sucesso se P conseguir, senão falhará.
!
Cut - Predicado de corte de Prolog.
4.8 Teste de variáveis no Prolog
ground(G)
Testa se G possui variáveis lógicas não associadas.
var(X)
Testa se X está vinculado a uma variável Prolog.
4.9 Assert e Retract
asserta(C)
A adiciona a cláusula C no banco de dados acima de outras cláusulas com o mesmo predicado de chave. O predicado chave de uma cláusula é o primeiro predicado encontrado quando a cláusula é lida da esquerda para a direita.
assertz(C), assert(C)
A adiciona a cláusula no banco de dados abaixo de outras cláusulas com o mesmo predicado de chave.
retract(C)
Remove C do banco de dados. C deve ser suficientemente instanciado para determinar a chave do predicado.
retractall(X)
Remove todas ocorrências do predicado cuja a chave seja X.
4.10 Vinculando uma variável a um valor numérico
X is E
Vincula a variável lógica V ao valor numérico de E. A expressão E deve ser um número ou uma expressão com valor numérico, convencionalmente entre parênteses, como, por exemplo, (2 * Z + W) / (4 * Z - W ), supondo que Z e W próprios estão vinculados a números no momento da avaliação desta expressão.
?- X is 22, Y is X * 3, Z is sqrt(Y).
X = 22 .
Y = 66 .
Z = 8.12404 .4.11 Negação procedural e negação como falha
not(Q), \+Q
Negação como falha, como definido por:
not(Q) :- call(Q), !, fail.
not(Q).4.12 Entrada / saída no Prolog
seeing(X)
É bem-sucedido se X estiver (ou puder ser) vinculado à porta de leitura atual. X=entrada via teclado.
see(X)
Abre a porta para o arquivo de entrada vinculado a X. A entrada subsequente para read é então obtida dessa porta.
seen
Fecha qualquer porta/arquivo de entrada selecionado e faz com que read observe o usuário.
read(X)
Lê a expressão do tipo Prolog da porta atual, armazenando valor em X.
telling(X)
É bem-sucedido se X estiver (ou puder ser) vinculado à porta de saída atual; X=tela.
tell(X)
Abre a porta para o arquivo de saída vinculado a X. A saída subsequente de 'gravação' ou 'exibição' é enviada para essa porta.
told
Fecha qualquer porta/arquivo de saída selecionado e reverte para a saída da tela.
write(E)
Grava a expressão do Prolog vinculada a E na porta de saída atual.
display(+Termo)
Escreve um termo no dispositivo padrão de saída na forma prefixada.
nl
Próxima linha (line feed).
ola :- read(X), write('Olá '), write(X).
?- ola.
|: Aluno. % aguarda digitação que deve ser finalizada por ponto (.).
Olá Aluno
true
tab(N)
Escreva N espaços na porta de saída selecionada.
4.13 Termos e cláusulas do Prolog como dados
clause(H,B)
Recupera cláusulas na memória cujo a cabeça corresponde a H e corpo corresponde a B. H deve ser suficientemente instanciado para determinar o predicado principal da cabeça.
functor(E,F,N)
E deve ser associado a uma expressão de 'functor' da forma 'f(...)'. F será vinculado a 'f' e N será vinculado ao número de argumentos que 'f' possui.
arg(N,E,A)
E deve ser vinculado a uma expressão de 'functor', N é um número inteiro e A será vinculado ao enésimo argumento de E (ou falhará).
name(A,L)
Converte entre átomo e lista.
?- name('.pl',L).
L = [46,112,108].
?- writeln("prog").
[112, 114, 111, 103]
Yes
?- append("prog",[46,112,108],F), name(N,F).
F = [112, 114, 111, 103, 46, 112, 108]
N = 'prog.pl'
=..
'univ' converte entre termo e lista. Por exemplo,
?- parent(a,X) = .. L.
L = [parent, a, _X001]
?- P=..[parent,jack,mary].
P= parent(jack,mary)
?- yes = .. L.
L = [yes]
?- P=..[fact].
P= fact
listing
Lista no dispositivo padrão de saída todos os predicados da base de dados.
listing(:Nome/Grau)
Lista no dispositivo padrão de saída os predicados especificados, com símbolo funcional dado por Nome e número de argumentos dado por Grau.
4.14 Operadores Prolog
:- op(P,T,O).
Declara um símbolo de operador. Por exemplo, com o código fonte ...
:- op(500,xfx,'has_color').
a has_color red.
b has_color blue.Então ...
?- b has_color C.
C = red
?- What has_color red.
What = aP é a precedência, um número inteiro. Um P maior tem menos precedência (capacidade de agrupar). Os valores de número de precedência para objetivos internos dependem do sistema Prolog atual. O usuário precisa descobrir quais são esses valores. (Consulte os materiais de referência ou use o recurso de ajuda com a palavra-chave 'operador').
T é o tipo de operador:
xfx infix não associativo
xfy infix associativo à direita
yfx infix associativo à esquerda
fx prefix não associativo
fy prefix associativo à direita
xf postfix não associativo
yf postfix associativo à esquerda
O é o nome do operador. Os símbolos que podem ser usados podem depender do leitor de expressão Prolog (ou seja, que tipo de Prolog você está usando).
Operadores internos, em ordem de precedência ("capacidade de agrupar", menor capacidade primeiro):
:- xfx, fx valor P alto
?- fx
; xfy
, xfy
not fy
is, =.. , <, etc. xfx
+, - yfx, fx
*, / yfx
^ xfy valor P menorÀs vezes, é necessário paciência para atribuir valores de precedência apropriados para os operadores do usuário, de modo que eles sejam lidos com o significado pretendido.
4.15 Encontrando todas as respostas no prolog
findall(Things,GoalExpression,Bag)
Calcula todas as coisas que satisfaçam a GoalExpresssion e as coloca na lista Bag. Se GoalExpression falhar, Bag será a lista vazia []. findall trata todas as variáveis em GoalExpression como se fossem quantificadas existencialmente.
bagof(Things,GoalExpression,Bag)
Calcula todas as coisas que satisfaçam a GoalExpresssion e as coloca na lista Bag. bagof falhará se GoalExpression falhar. Variáveis livres em GoalExpression podem ser vinculadas, gerando muitos retornos. Veja os exemplos na Seção 2.12.
setof(Things,GoalExpression,Bag)
Calcula todas as coisas que satisfaçam a GoalExpresssion e as coloca na lista Bag. Semelhante ao bagof, exceto que o Bag não conterá duplicatas e será ordenado.
4.16 Predicados para Listas
length(?List, ?Int)
verdadeiro se Int representa o número de elementos da lista List
member(?Elem, ?List)
verdadeiro se Elem é membro da lista List
?- member(3, [1,2,3]).
true
?- member(4, [1,2,3]).
false
?- member(2, [1,2,3]).
true
?- member(2, [1,2,3,2]).
true
reverse(?List1, ?List2)
verdadeiro se List2 é equivalente à lista List1 na ordem reversa
?- reverse([a,z,b], X).
X = [b, z, a]
?- reverse([4,1,9], X).
X = [9, 1, 4]
?- reverse(['Fulano','Beltrano'], X).
X = ['Beltrano', 'Fulano']
?- reverse([4,1,9,1], X).
X = [1, 9, 1, 4]
?- reverse([2,1],[1,2]).
true
?- reverse([2,1,1],[1,2]).
false
?- reverse([2,1,1,2],[1,2]).
false
?- reverse([2,1,1,2],[2,1,1,2]).
true
sort(+List, -Sorted)
verdadeiro se Sorted é equivalente à lista List ordenada; elementos duplicados são removidos do resultado
?- sort([a,z,b], X).
X = [a, b, z]
?- sort([4,1,9], X).
X = [1, 4, 9]
?- sort(['Fulano','Beltrano'], X).
X = ['Beltrano', 'Fulano']
?- sort([4,1,9,1], X).
X = [1, 4, 9]
?- sort([2,1],[1,2]).
true
?- sort([2,1,1],[1,2]).
true
?- sort([2,1,1,2],[1,2]).
true
?- sort([2,1,1,2],[2,1,1,2]).
false
append(?List1, ?List2, ?List1AndList2)
verdadeiro se List1AndList2 é a concatenação de List1 e List2
?- append([1,2], [3,4], X).
X = [1, 2, 3, 4]
?- append(A, [3,4], [1,2,3,4]).
A = [1, 2]
?- append(A, B, [1,2,3,4]).
A = [],
B = [1, 2, 3, 4] ;
A = [1],
B = [2, 3, 4] ;
A = [1, 2],
B = [3, 4] ;
A = [1, 2, 3],
B = [4] ;
A = [1, 2, 3, 4],
B = [] ;
false
nextto(?X, ?Y, ?List)
verdadeiro se Y segue X em List
nth0(?N, ?List, ?Elem)
verdadeiro se Elem é o N-ésimo elemento de List (índices começando em 0)
nth1(?N, ?List, ?Elem)
verdadeiro se Elem é o N-ésimo elemento de List (índices começando em 1)
last(?List, ?Last)
verdadeiro se Last é o último elemento de List