Entrada/Saída

	ISO Standard
Abrir ficheiro/Stream	open(Stream, Mode, StreamID) Stream é um átomo representando o pathname do ficheiro ou pipe(Command) Mode pode ser read, write, append ou update StreamID é o identificador do/a ficheiro/stream aberto/a. Deve usar-se nas instruções de Input/Output
Fechar um ficheiro/stream	Close(StreamID)
Que ficheiros/Steams existem e quais as suas propriedades?	stream_property(?Stream, ?StreamProperty)
Ler um termo do teclado ou de um ficheiro/Stream. read instancia o termo lido com end_of_file quando chega ao fim do ficheiro.	read(Term) read(Stream, Term)
Escrever um termo no ecrã ou num ficheiro/Stream	write(Term); writeq(Term) write(Stream, Term); writeq(Stream, Term)
Mudar de linha	nl/0, nl(Stream)
Leitura de caracteres	get_code(Code); get_code(Stream, Code); get_char(Ch); get_char(Stream, Ch); get_byte(Byte); get_byte(Stream, Byte) Code = -1, Byte = -1 no fim do ficheiro; Ch = end_of_file no fim do ficheiro
Teste de final do ficheiro	at_end_of_stream ; at_end_of_stream(Stream)
Escrita de caracteres	put_code(Code); put_code(Stream, Code); put_char(Ch); put_char(Stream, Char); put_byte(Byte); put_byte(Stream, Byte)

Manipulação de estruturas

Goal
arg(N, Term, Arg)	N: aridade; Term: estrutura; Arg: argumento. Obter/fixar o valor do N-ésimo argumento de uma estrutura.
Term=..[ F|Args]	F é o functor da estrutura Term; Args é a lista dos argumentos de Term
functor(Term, F, N)	F é o functor de Term; N é a aridade de Term

Emparelhamento de padrões

Goal
A = B	Emparelha A e B, i.e., testa se A e B são iguais, ou efectua o conjunto mínimo de substituições em A e/ou B para que eles fiquem iguais.
A \= B	Testa se A e B são emparelháveis (o contrário de =).

Comparação

Predicado
==	Testa se dois termos são iguais. Se X for uma variável não instanciada, X==b falha. Sendo X e Y duas variáveis não instanciadas, X == Y falha. X==Y tem sucesso. Sendo X e Y duas variáveis inicialmente não instanciadas, X=Y, X==Y tem sucesso. a+b == b+a falha porque os termos a+b e b+a não são iguais
\==	A \== B: equivalente a not(A==B)
=:=	Compara os valores de dois termos numéricos. a =:= a falha porque a não é nenhum termo com valor numérico 1=:=1 tem sucesso 1+2 =:= 2+1 tem sucesso
>, >=, <, =<	Operadores relacionais para expressões numéricas. Avaliam as expressões antes da comparação.
@>, @<, ¼	Operadores de comparação para qualquer tipo de termos. Não avalia expressões numéricas. ?- 5 @> 2 Tem sucesso ?- 5 @> 2+1 Não tem sucesso porque a comparação faz-se entre o 5 e o functor principal de 2+1, isto é, +. Os termos são comparados por ordem alfabética. Por exemplo, [b] @> [a, b, c] é verdade.

Conversões

Predicate/Arity
atom_chars/2	converts between an atom and a list of characters
atom_codes/2	converts between an atom and a list of codes
number_chars/2	convert between a number and a list of characters
number_codes/2	convert between a number and a list of codes
atomic_list_concat/2	Converte uma lista de átomos/números num átomo

Predicados de teste de tipos de dados

Predicate/Arity
atom/1	Tests if its argument is an atom
atomic/1	Tests if its argument is an atom or a number
compound/1	tests for a compound term
float/1	tests for a floating point number
ground/1	checks for completely bound terms
integer/1	Tests if its argument is an integer
is_list/1	Tests if its argument is a list
var/1	Tests for a non instantiated variable
nonvar/1	Tests if its argument is not a variable. For instance, nonvar(a) succeeds. (X=a, nonvar(X)) also succeeds.
number/1	Tests for a number (either float or integer)
simple/1	checks for an atomic term or a variable
string/1	tests for a string