|
halt.
== Tipos de dados ==
Prolog não emprega [[tipos de dados]] do mesmo modo que as linguagens de programação mais comuns normalmente fazem. Todos os dados são tratados como sendo de um único tipo, '''Termo''', cuja natureza depende da forma como esse termo foi declarado. Ou seja, os elementos léxicos utilizados na sua declaração determinam se esse termo será um número, um texto, uma variável, uma estrutura complexa e assim por diante.
===Escopo dos identificadores=== <!-- conteudo acrescentado -->
Com exceção de átomos numéricos, funções ou predicados construídos, os nomes em Prolog para constantes, variáveis, funções e predicados, não têm nenhum significado intrínseco e podem ser escolhidos livremente pelo programador. Em geral, duas notações distintas denotarão ou serão objetos distintos. Como em qualquer linguagem de programação, a cada nome deve ser dado um escopo.
Em Prolog, as regras de escopo são:
* O escopo de uma variável é a asserção (fato, regra, ou consulta) na qual aparece.
* O escopo de qualquer outro nome (constante, nome de função, ou nome de predicado) é todo o programa.
Isto significa que um nome de variável pode ser utilizado e reutilizado a vontade no programa para denotar variáveis diferentes, enquanto qualquer outra notação representa, ou é, o mesmo objeto para o programa todo.
<!-- fim do conteudo acrescentado -->
=== Átomos ===
As constantes de texto são introduzidas por meio de átomos. Um átomo é uma seqüência constituída de letras, números e [[underscore]], mas iniciando com uma letra minúscula. Se um átomo não alfanumérico é necessário, pode-se usar qualquer seqüência entre aspas simples (ex: 'um átomo contendo espaços').
Um átomo pode ser definido das seguintes maneiras:
começando com letra minúscula:
pedro henrique_iv
como uma sequência de caracteres entre aspas simples:
'quem é você?' 'eu não sei'.
=== Números ===
Um número é uma seqüência de dígitos, permitindo também os sinais de '''.''' (para números reais), '''-''' (número negativo) e '''e''' ([[notação científica]]). Algumas implementações do Prolog não fazem distinção entre inteiros e números reais.
exemplos:
321 3.21
=== Variáveis ===
Variáveis são declaradas da mesma forma que átomos, porém iniciando com uma letra maiúscula ou underscore. No ambiente Prolog uma variável não é um [[container (programação)|contêiner]] cujo valor pode ser atribuído (como ocorre nas [[Programação imperativa|linguagens imperativas]]). Seu comportamento é mais próximo de um padrão, que é incrementalmente especificado pela [[unificação]]. Em outras palavras, uma variável Prolog é como uma incógnita, cujo valor é desconhecido a princípio mas, após descoberto, não sofre mais mudanças.
Um tipo especial de variável, a ''variável anônima'' (explicada mais adiante), é uma expressão que significa 'qualquer variável', e é escrita como um único subtraço (_).
exemplos:
X Nome Rei_da_Espanha
=== Termos compostos ===
Termos compostos são a única forma de se expressar estruturas de dados complexas em Prolog. Um termo composto consiste de uma cabeça, também chamada funtor (que é obrigatoriamente um átomo) e parâmetros (de quaisquer tipos) listados entre parênteses e separados por vírgulas.
O número de parâmetros, chamado [[aridade]] do termo, é significativo. Um termo é identificado por sua cabeça e aridade, normalmente escrita como funtor/aridade. Átomos e números também podem ser identificados dessa forma, como um termo de aridade zero (ex: um_atomo/0).
==== Exemplos ====
rodrigo
é um átomo, e pode ser considerado um funtor de aridade 0.
gordo(rodrigo)
é um termo composto por um funtor de aridade 1 (''gordo''), com um parâmetro.
pai(rodrigo, gabriel)
é um termo composto por um funtor de aridade 1 (''pai''), com dois parâmetros (''rodrigo'' e ''gabriel'').
Nada impede que os parâmetros também sejam termos compostos:
produto(fracao(1,raiz(produto(2,pi))),exp(menos(fracao(quadrado(x),2))))
é um termo composto por um funtor de aridade 2 (''produto''), com dois parâmetros compostos.
Sintaticamente, termos como:
2 + 2
são termos compostos usando um funtor de aridade 2 ('+'). Ou seja, é a mesma coisa escrever ''2 + 2'' ou '' '+'(2,2)'', como pode ser visto com:
2 + 2 = '+'(2,2).
=== Listas ===
Uma lista não é um tipo de dados à parte, mas sim definida por uma construção recursiva (usando o termo '.'/2):
# o átomo [] é uma lista vazia;
# se ''T'' é uma lista e ''H'' é um elemento, então o termo '.'(''H'', ''T'') é uma lista.
O primeiro elemento, chamado cabeça, é ''H'', que é seguida pelo conteúdo do restante da lista, ''T'', também chamado de cauda.
A lista [1, 2, 3] seria representada internamente como '.'(1, '.'(2, '.'(3, []))).
Um atalho sintático é [''H'' | ''T''], que é mais usado para construir regras.
Uma lista pode ser processada como um todo processando o primeiro elemento, e em seguida o restante da lista, de forma [[Recursividade|recursiva]].
Para conveniência do programador, as listas podem ser construídas e destruídas de várias formas.
* Enumerando os elementos: [abc, 1, f(X), ''Y'', g(''A'',rst)]
* Precedendo-a com um elemento: [abc | ''L1'']
* Precedendo-a com múltiplos elementos: [abc, 1, f(X) | ''L2'']
* Expandindo o termo: '.'(abc, '.'(1, '.'(f(X), '.'(''Y'', '.'(g(''A'',rst), [])))))
* O predicado '''append'''
=== Strings ===
Strings são normalmente escritas como uma seqüência de caracteres entre aspas. É comum serem representadas internamente como listas de códigos de caracteres, em geral utilizando a codificação local ou [[Unicode]], se o sistema dá suporte a Unicode. O ISO Prolog também permite que strings sejam representadas por uma lista de átomos com um único caractere.
== Fatos ==
Programar em Prolog é bem diferente de programar em uma linguagem procedimental. Em Prolog se fornecem fatos e regras para uma base de dados; então se executam consultas ou (''queries'') a essa base de dados. A unidade básica do Prolog é o predicado, que é postulado verdadeiro. Um predicado consiste de uma cabeça e um número de argumentos. Por exemplo:
gato(tom).
Isso informa à base de dados o fato que 'tom' é um 'gato'. Deve-se notar que esta interpretação é absolutamente flexível, não existe nenhuma obrigatoriedade de interpretar ''gato(tom).'' como significando que ''tom'' é um ''gato''. Nada impede, por exemplo, que a base de dados tenha a seguinte estrutura:
tom(gato).
jerry(rato).
spike(cachorro).
butch(gato).
Voltando ao exemplo ''gato(tom).'', formalmente, 'gato' é a cabeça e 'tom' é o único argumento do predicado. Alguns exemplos de consultas que podem ser feitas ao interpretador Prolog baseado nesse fato. Para saber se tom é um gato, escrevemos:
?- gato(tom).
yes.
Para saber que coisas (conhecidas) são gatos:
?- gato(X).
X = tom;
yes.
É importante notar que, sendo a base de dados apenas formada pelo predicado ''gato(tom).'', temos os seguintes resultados:
?- rato(tom).
No.
?- gato(jerry).
No.
?- rato(jerry).
No.
?- gato(butch).
No.
Note-se que ''No'' significa ''não sei''. A negação em Prolog é um assunto delicado, e o seu tratamento requer um cuidado especial.
Predicados são normalmente definidos para expressar algum fato sobre o mundo que o programa deve conhecer. Na maioria dos casos, o uso de predicados requer uma certa convenção. Por exemplo, qual das duas versões abaixo significaria que José é o pai de Ana?
pai(ana,jose).
pai(jose,ana).
Em ambos os casos 'pai' é a cabeça e 'ana' e 'jose' são argumentos. Entretanto, no primeiro caso Ana vem primeiro na lista de argumentos, e no segundo, quem vem primeiro é José (a ordem nos argumentos é importante). O primeiro caso é um exemplo de definição na ordem '''Verbo Sujeito Objeto''', e o segundo, na ordem '''Verbo Objeto Sujeito'''. Como Prolog não entende português, ambas as versões estão corretas de acordo com seu escopo; no entanto é uma boa prática de programação escolher uma única convenção para ser usada no mesmo programa, para evitar escrever algo como
pai(jose,ana).
pai(maria,joao).
De novo, nada impede que os predicados sejam escritos como:
ana(mae,maria).
joao(pai,jose).
Alguns predicados são pre-definidos na própria linguagem, permitindo que os programas Prolog desempenhem atividades rotineiras (como entrada/saída, uso de gráficos e outros tipos de comunicação com o sistema operacional). Por exemplo, o predicado <tt>write</tt> pode ser usado para saída na tela. Então,
write('Olá').
vai exibir a palavra 'Olá' na tela.
| 