List of Standard Predicates

 		  abolish(Name/Arity) 		     

		  abolish(Name, Arity) 		     

		  abolish_all_tables 		     

		  abolish_table_call(Term) 		     

		  abolish_table_pred(Pred) 		     

		  abort 		     

		  abort(Message) 		     

		  analyze_table(Pred) 		     

		  arg(Index, Term, Arg) 		     

		  arg0(Index, Term, Arg)		     

		  assert(Clause) 		     

		  asserta(Clause) 		     

		  assertz(Clause) 		     

		  atom(Term) 		     

		  atomic(Term) 		     

		  atom_codes(Atom, CharList) 		    

		  bagof(Elem, Goal, Bag)		     

		  break 		     

		  'C'(List1, Token, List2) 		     

		  call(Term) 		     

		  callable(Term) 		     

		  cd(Dir) 		     

		  clause(Head, Body) 		     

		  close(FileName) 		     

		  compare(Res, Term1, Term2) 		     

		  compile(Module) 		     

		  compile(Module, Options) 		     

		  compound(Term) 		     

		  consult(Module) 		     

		  consult(Module, Options) 		     

		  copy_term(Term, Copy) 		     

		  cputime(Time) 		     

		  current_atom(Atom) 		    

		  current_functor(Functor) 		    

		  current_functor(Functor, Term) 		    

		  current_input(File) 		     

		  current_module(Module) 		    

		  current_module(Module, File) 		    

		  current_op(Precedence, Type, Name) 		   

		  current_output(File) 		     

		  current_predicate(Predicate) 		    

		  current_predicate(Predicate, Term) 		   

		  debug 		     

		  debugging 		     

		  edit(File) 		     

		  erase(Reference) 		     

		  expand_term(Term, Expanded_Term) 		    

		  fail 		     

		  fail_if(Goal) 		     

		  file_exists(File) 		     

		  findall(Elem, Goal, List) 		     

		  float(Term) 		     

		  functor(Term, Functor, Arity) 		    

		  garbage_collection(Option) 		    

		  get(Char) 		     

		  get0(Char) 		     

		  get_call(Skeleton,Subgoal_Structure_Pointer,Return_Skeleton) 		 

		  get_calls(Skeleton,Subgoal_Structure_Pointer,Return_Skeleton) 		 

		  get_calls_for_table(Skeleton,Call,Empty) 		  

		  get_resudual(Call, Return) 		   

		  get_returns(Skeleton,Delay_list) 		   

		  get_returns_for_call(Call, Return) 		   

		  halt 		     

		  hilog(Symbol) 		     

		  hilog_arg(Index, Term, Arg) 		    

		  hilog_functor(Term, Functor, Arity) 		   

		  hilog_op(Precedence, Type, Name) 		    

		  hilog_symbol(Symbol) 		     

		  import PredList from Module 		    

		  index(Predicate, ArgNo, HashSize) 		    

		  instance(Ref, Instance) 		     

		  integer(Term) 		     

		  is(Result, Expression) 		     

		  is_absolute_filename(Path) 		    

		  is_list(Term) 		     

		  is_charlist(Term) 		     

		  is_charlist(Term,Size) 		    

		  keysort(Input, Output) 		     

		  listing 		     

		  listing(Predicate) 		     

		  load_dyn(Module) 		     

		  load_dync(Module) 		     

		  ls 		     

		  module_property(Module, Property) 		    

		  name(Term, CharList) 		     

		  nl 		     

		  nl(Stream) 		     

		  nodebug 		     

		  nonvar(Term) 		     

		  nospy(Predicate_List) 		     

		  not(Goal) 		     

		  notrace 		     

		  number(Term) 		     

		  number_codes(Number,Character_list) 		  

		  once(Goal) 		     

		  op(Precedence, Format, Operator) 		    

		  open(Stream) 		     

		  otherwise 		     

		  phrase(Phrase, List) 		     

		  phrase(Phrase, List, Remains) 		    

		  predicate_property(Predicate, Property) 		   

		  print(Term) 		 Currently the same as  write/1. 

		  proper_hilog(Term) 		     

		  put(Char) 		     

		  read(Term) 		     

		  read(Stream,Term) 		    

		  read_canonical(Term) 		    

		  real(Term) 		     

		  reconsult(Module) 		     

		  reconsult(Module, Options) 		     

		  record(Key, Term, Ref) 		     

		  recorda(Key, Term, Ref) 		     

		  recorded(Key, Term, Ref) 		     

		  recordz(Key, Term, Ref) 		     

		  rename(OldName, NewName) 		     

		  repeat 		     

		  retract(Term) 		     

		  retractall(Predicate) 		     

		  see(File) 		     

		  seeing(File) 		     

		  seen 		     

		  set_global_compiler_options(OptionsList) 		  

		  setof(Elem, Goal, Set) 		     

		  skip(Char) 		     

		  sort(Input, Output) 		     

		  spy(Predicate_List) 		     

		  statistics 		     

		  statistics(Number) 		     

		  structure(Term) 		     

		  tab(Count) 		     

		  table_prop(Pred, Type, Value) 		    

		  table_prop(Pred, Type, OldValue, NewValue) 		  

		  table_state(Call, State) 		     

		  tbagof(Elem, Goal, List) 		     

		  tell(File) 		     

		  telling(File) 		     

		  tfindall(Elem, Goal, List) 		     

		  tilde_expand_filename(File_name,Expanded_Filename) 		 

		  tnot(Goal) 		     

		  told 		     

		  trace 		     

		  true 		     

		  tsetof(Elem, Goal, List) 		     

		  ttywrite(Term) 		 Same as  write but always writes to 


the standard output.   

		  ttywritenl(Terms) 		   Terms can be a comma list of terms. The predicate 


calls  ttywrite/1 to print all the terms in the list 


and then prints a new line symbol at the end.  

		  shell(Command) 		     

		  shell(Command, Result)		     

		  var(Term) 		     

		  write(Term) 		     

		  write(Stream,Term) 		     

		  writeln(Term) 		     

		  write_prolog(Term) 		     

		  write_prolog(Stream,Term) 		    

		  writeq(Term) 		     

		  write_canonical(Term) 		     

		  xsb_flag(Flag, Value) 		     

		  $\backslash$+ Query 		     

		  ! 		     

		  X =:= Y 		     

		  X =$\backslash$= Y 		     

		  X $<$ Y 		     

		  X $>$ Y 		     

		  X =$<$ Y 		     

		  X $>$= Y 		     

		  X = Y 		     

		  Term =.. List 		     

		  Term ^=.. List 		     

		  X == Y 		     

		  X $\backslash$== Y 		     

		  X @$<$ Y 		     

		  X @$>$ Y 		     

		  X @=$<$ Y 		     

		  X @$>$= Y 		     

		  [X$\vert$Y] 		     

		  X ; Y 		     

		  X , Y 		     

		  X -$>$ Y 		     

		  X ^ Goal