kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/ext/semweb/semweb/rdf_prefixes.pl

@@ -0,0 +1,681 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2018-2022, VU University Amsterdam
+			      CWI, Amsterdam
+                              SWI-Prolog Solutions b.v.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(rdf_prefixes,
+          [ rdf_prefix/2,               % :Alias, +URI
+            rdf_current_prefix/2,       % :Alias, ?URI
+            rdf_register_prefix/2,      % +Alias, +URI
+            rdf_register_prefix/3,      % +Alias, +URI, +Options
+            rdf_unregister_prefix/1,    % +Alias
+            register_file_prefixes/1,   % +Pairs
+
+            rdf_current_ns/2,           % :Alias, ?URI
+            rdf_register_ns/2,          % +Alias, +URI
+            rdf_register_ns/3,          % +Alias, +URI, +Options
+            rdf_global_id/2,            % ?NS:Name, :Global
+            rdf_global_object/2,        % +Object, :NSExpandedObject
+            rdf_global_term/2,          % +Term, :WithExpandedNS
+
+            (rdf_meta)/1,               % +Heads
+            op(1150, fx, (rdf_meta))
+          ]).
+:- autoload(library(error),[must_be/2,existence_error/2]).
+:- autoload(library(lists),[member/2]).
+:- autoload(library(option),[option/3]).
+:- autoload(library(pairs),[map_list_to_pairs/3,pairs_values/2]).
+
+:- meta_predicate
+    rdf_current_prefix(:, -),
+    rdf_current_ns(:, -),
+    rdf_global_id(?, :),
+    rdf_global_term(+, :),
+    rdf_global_object(+, :).
+
+/** <module> RDF prefixes management
+
+This module defines the expansion of  `Prefix:Local` terms to full IRIs.
+This library is typically not  intended  for   the  end-user.  It may be
+included into other RDF and XML  libraries   and  relevant  parts may be
+re-exported.
+*/
+
+:- predicate_options(rdf_register_ns/3, 3,
+                     [ force(boolean),
+                       keep(boolean)
+                     ]).
+:- predicate_options(rdf_register_prefix/3, 3,
+                     [ force(boolean),
+                       keep(boolean)
+                     ]).
+
+
+		 /*******************************
+		 *            HOOKS		*
+		 *******************************/
+
+%!  rdf_empty_prefix_cache(+Alias, +URI)
+%
+%   Multifile hook called if the binding Alias   -> URI is modified. May
+%   be used to update derived caches.
+
+:- multifile
+    rdf_empty_prefix_cache/2.
+
+% the ns/2 predicate is historically  defined   in  `rdf_db`. We'll keep
+% that for compatibility reasons.
+:- multifile rdf_db:ns/2.
+:- dynamic   rdf_db:ns/2.               % ID, URL
+
+%!  rdf_current_prefix(:Alias, ?URI) is nondet.
+%
+%   Query   predefined   prefixes   and    prefixes   defined   with
+%   rdf_register_prefix/2   and   local   prefixes    defined   with
+%   rdf_prefix/2. If Alias is unbound and one   URI is the prefix of
+%   another, the longest is returned first.   This  allows turning a
+%   resource into a prefix/local couple using the simple enumeration
+%   below. See rdf_global_id/2.
+%
+%     ==
+%     rdf_current_prefix(Prefix, Expansion),
+%     atom_concat(Expansion, Local, URI),
+%     ==
+
+rdf_current_prefix(Module:Alias, URI) :-
+    nonvar(Alias),
+    !,
+    rdf_current_prefix(Module, Alias, URI),
+    !.
+rdf_current_prefix(Module:Alias, URI) :-
+    rdf_current_prefix(Module, Alias, URI).
+
+rdf_current_prefix(system, Alias, URI) :-
+    !,
+    rdf_db:ns(Alias, URI).
+rdf_current_prefix(Module, Alias, URI) :-
+    default_module(Module, M),
+    (   M == system
+    ->  rdf_db:ns(Alias, URI)
+    ;   '$flushed_predicate'(M:'rdf prefix'(_,_)),
+        call(M:'rdf prefix'(Alias,URI))
+    ).
+
+%!  rdf_prefix(:Alias, +URI) is det.
+%
+%   Register a _local_ prefix.  This   declaration  takes precedence
+%   over globally defined prefixes   using  rdf_register_prefix/2,3.
+%   Module local prefixes are notably required   to deal with SWISH,
+%   where users need to  be  able   to  have  independent  namespace
+%   declarations.
+
+rdf_prefix(Alias, URI) :-
+    throw(error(context_error(nodirective, rdf_prefix(Alias, URI)), _)).
+
+system:term_expansion((:- rdf_prefix(AliasSpec, URI)), Clauses) :-
+    prolog_load_context(module, Module),
+    strip_module(Module:AliasSpec, TM, Alias),
+    must_be(atom, Alias),
+    must_be(atom, URI),
+    (   rdf_current_prefix(TM:Alias, URI)
+    ->  Clauses = []
+    ;   TM == Module
+    ->  Clauses = 'rdf prefix'(Alias, URI)
+    ;   Clauses = TM:'rdf prefix'(Alias, URI)
+    ).
+
+%!  rdf_db:ns(?Alias, ?URI) is nondet.
+%
+%   Dynamic and multifile predicate that   maintains  the registered
+%   namespace aliases.
+%
+%   @deprecated New code  must  modify   the  namespace  table using
+%   rdf_register_ns/3 and query using rdf_current_ns/2.
+
+rdf_db:ns(dc,      'http://purl.org/dc/elements/1.1/').
+rdf_db:ns(dcterms, 'http://purl.org/dc/terms/').
+rdf_db:ns(eor,     'http://dublincore.org/2000/03/13/eor#').
+rdf_db:ns(foaf,    'http://xmlns.com/foaf/0.1/').
+rdf_db:ns(owl,     'http://www.w3.org/2002/07/owl#').
+rdf_db:ns(rdf,     'http://www.w3.org/1999/02/22-rdf-syntax-ns#').
+rdf_db:ns(rdfs,    'http://www.w3.org/2000/01/rdf-schema#').
+rdf_db:ns(serql,   'http://www.openrdf.org/schema/serql#').
+rdf_db:ns(skos,    'http://www.w3.org/2004/02/skos/core#').
+rdf_db:ns(void,    'http://rdfs.org/ns/void#').
+rdf_db:ns(xsd,     'http://www.w3.org/2001/XMLSchema#').
+
+%!  rdf_register_prefix(+Prefix, +URI) is det.
+%!  rdf_register_prefix(+Prefix, +URI, +Options) is det.
+%
+%   Register Prefix as an abbreviation for URI. Options:
+%
+%           * force(Boolean)
+%           If =true=, replace existing namespace alias. Please note
+%           that replacing a namespace is dangerous as namespaces
+%           affect preprocessing. Make sure all code that depends on
+%           a namespace is compiled after changing the registration.
+%
+%           * keep(Boolean)
+%           If =true= and Alias is already defined, keep the
+%           original binding for Prefix and succeed silently.
+%
+%   Without options, an attempt  to  redefine   an  alias  raises  a
+%   permission error.
+%
+%   Predefined prefixes are:
+%
+%   | **Alias** | **IRI prefix**                              |
+%   | dc        | http://purl.org/dc/elements/1.1/            |
+%   | dcterms   | http://purl.org/dc/terms/                   |
+%   | eor       | http://dublincore.org/2000/03/13/eor#       |
+%   | foaf      | http://xmlns.com/foaf/0.1/                  |
+%   | owl       | http://www.w3.org/2002/07/owl#              |
+%   | rdf       | http://www.w3.org/1999/02/22-rdf-syntax-ns# |
+%   | rdfs      | http://www.w3.org/2000/01/rdf-schema#       |
+%   | serql     | http://www.openrdf.org/schema/serql#        |
+%   | skos      | http://www.w3.org/2004/02/skos/core#        |
+%   | void      | http://rdfs.org/ns/void#                    |
+%   | xsd       | http://www.w3.org/2001/XMLSchema#           |
+
+
+rdf_register_prefix(Alias, URI) :-
+    rdf_register_prefix(Alias, URI, []).
+
+rdf_register_prefix(Alias, URI, Options) :-
+    must_be(atom, Alias),
+    must_be(atom, URI),
+    (   rdf_current_prefix(system:Alias, URI)
+    ->  true
+    ;   register_global_prefix(Alias, URI, Options)
+    ).
+
+%!  register_global_prefix(+Alias, +URI, +Options)
+%
+%   Register a global prefix.
+
+register_global_prefix(Alias, URI, Options) :-
+    rdf_db:ns(Alias, _),
+    !,
+    (   option(force(true), Options, false)
+    ->  retractall(rdf_db:ns(Alias, _)),
+        rdf_register_prefix(Alias, URI, Options),
+        forall(rdf_empty_prefix_cache(Alias, URI), true)
+    ;   option(keep(true), Options, false)
+    ->  true
+    ;   throw(error(permission_error(register, namespace, Alias),
+                    context(_, 'Already defined')))
+    ).
+register_global_prefix(Alias, URI, _) :-
+    findall(P-U, prefix_conflict(URI, P, U), Pairs),
+    order_prefixes([Alias-URI|Pairs], Ordered),
+    forall(member(P-U, Pairs), retract(rdf_db:ns(P,U))),
+    forall(member(P-U, Ordered), assert(rdf_db:ns(P,U))).
+
+prefix_conflict(URI, P, U) :-
+    rdf_db:ns(P,U),
+    (   sub_atom(URI, 0, _, _, U)
+    ->  true
+    ;   sub_atom(U, 0, _, _, URI)
+    ).
+
+order_prefixes(Pairs, Sorted) :-
+    map_list_to_pairs(prefix_uri_length, Pairs, ByLen),
+    sort(1, >=, ByLen, SortedByLen),
+    pairs_values(SortedByLen, Sorted).
+
+prefix_uri_length(_-URI, Len) :-
+    atom_length(URI, Len).
+
+%!  rdf_unregister_prefix(+Alias) is det.
+%
+%   Delete a prefix global registration.
+
+rdf_unregister_prefix(Alias) :-
+    must_be(atom, Alias),
+    retractall(rdf_db:ns(Alias, _)).
+
+
+%!  rdf_current_ns(:Prefix, ?URI) is nondet.
+%
+%   @deprecated  Use rdf_current_prefix/2.
+
+rdf_current_ns(Prefix, URI) :-
+    rdf_current_prefix(Prefix, URI).
+
+%!  rdf_register_ns(:Prefix, ?URI) is det.
+%!  rdf_register_ns(:Prefix, ?URI, +Options) is det.
+%
+%   Register an RDF prefix.
+%
+%   @deprecated  Use rdf_register_prefix/2 or rdf_register_prefix/3.
+
+rdf_register_ns(Prefix, URI) :-
+    rdf_register_prefix(Prefix, URI).
+rdf_register_ns(Prefix, URI, Options) :-
+    rdf_register_prefix(Prefix, URI, Options).
+
+
+%!  register_file_prefixes(+Map:list(pair)) is det.
+%
+%   Register a namespace as encountered in the  namespace list of an
+%   RDF document. We only register if  both the abbreviation and URL
+%   are not already known. Is there a   better  way? This code could
+%   also do checks on the consistency   of  RDF and other well-known
+%   namespaces.
+%
+%   @tbd    Better error handling
+
+register_file_prefixes([]) :- !.
+register_file_prefixes([Decl|T]) :-
+    !,
+    register_file_prefixes(Decl),
+    register_file_prefixes(T).
+register_file_prefixes([]=_) :- !.      % xmlns= (overall default)
+register_file_prefixes(NS=URL) :-       % compatibility
+    !,
+    register_file_prefixes(NS-URL).
+register_file_prefixes(NS-URL) :-
+    (   rdf_db:ns(NS, URL)
+    ->  true
+    ;   rdf_db:ns(NS, _)
+    ->  true                            % redefined abbreviation
+    ;   rdf_db:ns(_, URL)
+    ->  true                            % redefined URL
+    ;   rdf_register_prefix(NS, URL)
+    ).
+
+
+%!  rdf_global_id(?IRISpec, :IRI) is semidet.
+%
+%   Convert between Prefix:Local and full IRI   (an atom). If IRISpec is
+%   an atom, it  is  simply  unified   with  IRI.  This  predicate fails
+%   silently if IRI is an RDF literal.
+%
+%   Note that this predicate is a meta-predicate on its output argument.
+%   This is necessary to get the module context while the first argument
+%   may be of the form (:)/2. The above mode description is correct, but
+%   should be interpreted as (?,?).
+%
+%   @error existence_error(rdf_prefix, Prefix)
+%   @see   rdf_equal/2 provides a compile time alternative
+%   @see   The rdf_meta/1 directive asks for compile time expansion
+%          of arguments.
+%   @bug   Error handling is incomplete.  In its current implementation
+%	   the same code is used for compile-time expansion and to
+%	   facilitate runtime conversion and checking.  These use cases
+%	   have different requirements.
+
+rdf_global_id(Id, Module:Global) :-
+    rdf_global_id(Id, Global, Module).
+
+rdf_global_id(NS:Local, Global, Module) :-
+    global(NS, Local, Global, Module),
+    !.
+rdf_global_id(Global, Global, _).
+
+
+%!  rdf_global_object(+Object, :GlobalObject) is semidet.
+%!  rdf_global_object(-Object, :GlobalObject) is semidet.
+%
+%   Same as rdf_global_id/2,  but  intended   for  dealing  with the
+%   object part of a  triple,  in   particular  the  type  for typed
+%   literals. Note that the predicate  is   a  meta-predicate on the
+%   output argument. This is necessary  to   get  the module context
+%   while the first argument may be of the form (:)/2.
+%
+%   @error  existence_error(rdf_prefix, Prefix)
+
+rdf_global_object(Object, Module:GlobalObject) :-
+    rdf_global_object(Object, GlobalObject, Module).
+
+rdf_global_object(Var, Global, _M) :-
+    var(Var),
+    !,
+    Global = Var.
+rdf_global_object(Prefix:Local, Global, M) :-
+    global(Prefix, Local, Global, M),
+    !.
+rdf_global_object(literal(type(Prefix:Local, Value)),
+                  literal(type(Global, Value)), M) :-
+    global(Prefix, Local, Global, M),
+    !.
+rdf_global_object(^^(Value,Prefix:Local),
+                  ^^(Value,Global), M) :-
+    global(Prefix, Local, Global, M),
+    !.
+rdf_global_object(literal(Query0, type(Prefix:Local, Value)),
+                  literal(Query1, type(Global, Value)), M) :-
+    global(Prefix, Local, Global, M),
+    !,
+    rdf_global_term(Query0, Query1, M).
+rdf_global_object(literal(Query0, Value),
+                  literal(Query1, Value), M) :-
+    !,
+    rdf_global_term(Query0, Query1, M).
+rdf_global_object(Global, Global, _).
+
+global(Prefix, Local, Global, Module) :-
+    (   atom(Global)
+    ->  rdf_current_prefix(Module:Prefix, Full),
+        atom_concat(Full, Local, Global)
+    ;   atom(Prefix), atom(Local), var(Global)
+    ->  (   rdf_current_prefix(Module:Prefix, Full)
+        *-> atom_concat(Full, Local, Global)
+        ;   current_prolog_flag(xref, true)
+        ->  Global = Prefix:Local
+        ;   existence_error(rdf_prefix, Prefix)
+        )
+    ).
+
+
+%!  rdf_global_term(+TermIn, :GlobalTerm) is det.
+%
+%   Performs rdf_global_id/2 on prefixed IRIs and rdf_global_object/2 on
+%   RDF literals, by recursively  analysing  the   term.  Note  that the
+%   predicate is a meta-predicate  on  the   output  argument.  This  is
+%   necessary to get the module context while  the first argument may be
+%   of the form (:)/2.
+%
+%   Terms of the form `Prefix:Local`  that   appear  in TermIn for which
+%   `Prefix` is not defined are not replaced. Unlike rdf_global_id/2 and
+%   rdf_global_object/2, no error is raised.
+
+rdf_global_term(TermIn, Module:TermOut) :-
+    rdf_global_term(TermIn, TermOut, Module).
+
+rdf_global_term(Var, Var, _M) :-
+    var(Var),
+    !.
+rdf_global_term(Prefix:Local, Global, Module) :-
+    atom(Prefix), atom(Local),
+    rdf_current_prefix(Module:Prefix, Full),
+    !,
+    atom_concat(Full, Local, Global).
+rdf_global_term([H0|T0], [H|T], M) :-
+    !,
+    rdf_global_term(H0, H, M),
+    rdf_global_term(T0, T, M).
+rdf_global_term(Term0, Term, M) :-
+    compound(Term0),
+    !,
+    compound_name_arguments(Term0, Name, L0),
+    rdf_global_term(L0, L, M),
+    compound_name_arguments(Term, Name, L).
+rdf_global_term(Term, Term, _).
+
+%!  rdf_global_graph(+TermIn, -GlobalTerm, +Module) is det.
+%
+%   Preforms rdf_global_id/2 on rdf/4, etc graph arguments
+
+rdf_global_graph(Prefix:Local, Global, Module) :-
+    atom(Prefix), atom(Local),
+    !,
+    global(Prefix, Local, Global, Module).
+rdf_global_graph(G, G, _).
+
+
+                 /*******************************
+                 *            EXPANSION         *
+                 *******************************/
+
+:- multifile
+    system:term_expansion/2,
+    system:goal_expansion/2.
+
+system:term_expansion((:- rdf_meta(Heads)), Clauses) :-
+    prolog_load_context(module, M),
+    phrase(mk_clauses(Heads, M), Clauses).
+
+mk_clauses((A,B), M) -->
+    mk_clause(A, M),
+    mk_clauses(B, M).
+mk_clauses(A, M) -->
+    mk_clause(A, M).
+
+mk_clause(Head0, M0) -->
+    { strip_module(M0:Head0, Module, Head),
+      valid_rdf_meta_head(Head),
+      functor(Head, Name, Arity),
+      functor(Unbound, Name, Arity),
+      qualify(Module, 'rdf meta specification'/2, Decl)
+    },
+    [ (:- multifile(Decl)),
+      Module:'rdf meta specification'(Unbound, Head)
+    ].
+
+qualify(Module, Decl, Decl) :-
+    prolog_load_context(module, Module),
+    !.
+qualify(Module, Decl, Module:Decl).
+
+
+valid_rdf_meta_head(Head) :-
+    callable(Head),
+    !,
+    Head =.. [_|Args],
+    valid_args(Args).
+valid_rdf_meta_head(Head) :-
+    throw(error(type_error(callable, Head), _)).
+
+valid_args([]).
+valid_args([H|T]) :-
+    valid_arg(H),
+    !,
+    valid_args(T).
+
+valid_arg(:).                           % meta argument
+valid_arg(+).                           % non-var
+valid_arg(-).                           % var
+valid_arg(?).                           % either var or non-var
+valid_arg(@).                           % not modified
+valid_arg(r).                           % RDF resource
+valid_arg(o).                           % RDF object
+valid_arg(t).                           % term with RDF resources
+valid_arg(g).                           % graph argument
+valid_arg(A) :-
+    throw(error(type_error(rdf_meta_argument, A), _)).
+
+%!  rdf_meta(+Heads)
+%
+%   This  directive  defines  the  argument    types  of  the  named
+%   predicates, which will force compile   time  namespace expansion
+%   for these predicates. Heads is a coma-separated list of callable
+%   terms. Defined argument properties are:
+%
+%     $ : :
+%     Argument is a goal. The goal is processed using expand_goal/2,
+%     recursively applying goal transformation on the argument.
+%
+%     $ + :
+%     The argument is instantiated at entry. Nothing is changed.
+%
+%     $ - :
+%     The argument is not instantiated at entry. Nothing is changed.
+%
+%     $ ? :
+%     The argument is unbound or instantiated at entry. Nothing is
+%     changed.
+%
+%     $ @ :
+%     The argument is not changed.
+%
+%     $ r :
+%     The argument must be a resource. If it is a term
+%     _prefix_:_local_ it is translated.
+%
+%     $ o :
+%     The argument is an object or resource. See
+%     rdf_global_object/2.
+%
+%     $ t :
+%     The argument is a term that must be translated. Expansion will
+%     translate all occurrences of _prefix_:_local_ appearing
+%     anywhere in the term. See rdf_global_term/2.
+%
+%   As it is subject to term_expansion/2, the rdf_meta/1 declaration
+%   can only be used as a directive. The directive must be processed
+%   before the definition of  the  predicates   as  well  as  before
+%   compiling code that  uses  the   rdf  meta-predicates.  The atom
+%   =rdf_meta=  is  declared   as   an    operator   exported   from
+%   library(semweb/rdf_db). Files using rdf_meta/1  must explicitly
+%   load this library.
+%
+%   Beginning with SWI-Prolog 7.3.17, the   low-level  RDF interface
+%   (rdf/3,  rdf_assert/3,  etc.)  perform    runtime  expansion  of
+%   `Prefix:Local` terms. This eliminates the   need  for rdf_meta/1
+%   for  simple  cases.  However,  runtime   expansion  comes  at  a
+%   significant overhead and having two  representations for IRIs (a
+%   plain atom and  a  term   `Prefix:Local`)  implies  that  simple
+%   operations such as comparison of IRIs   no  longer map to native
+%   Prolog operations such as `IRI1 == IRI2`.
+
+rdf_meta(Heads) :-
+    throw(error(context_error(nodirective, rdf_meta(Heads)), _)).
+
+%!  rdf_meta_specification(+General, +Module, -Spec) is semidet.
+%
+%   True when Spec is the RDF meta specification for Module:General.
+%
+%   @arg    General is the term Spec with all arguments replaced with
+%           variables.
+
+rdf_meta_specification(Unbounded, Module, Spec) :-
+    '$flushed_predicate'(Module:'rdf meta specification'(_,_)),
+    call(Module:'rdf meta specification'(Unbounded, Spec)).
+
+split_rule((Module:Head :- Body), (Module:Expanded :- Body),
+           Module, Head, Expanded) :-
+    atom(Module),
+    !.
+split_rule((Head :- Body), (Expanded :- Body),
+           Module, Head, Expanded) :-
+    callable(Head),
+    prolog_load_context(module, Module),
+    !.
+split_rule((Module:Head,Guard => Body), (Module:Expanded,Guard => Body),
+           Module, Head, Expanded) :-
+    callable(Head),
+    atom(Module),
+    !.
+split_rule((Module:Head => Body), (Module:Expanded => Body),
+           Module, Head, Expanded) :-
+    callable(Head),
+    atom(Module),
+    !.
+split_rule((Head,Guard => Body), (Expanded,Guard => Body),
+           Module, Head, Expanded) :-
+    callable(Head),
+    prolog_load_context(module, Module),
+    !.
+split_rule((Head => Body), (Expanded => Body),
+           Module, Head, Expanded) :-
+    callable(Head),
+    prolog_load_context(module, Module).
+
+system:goal_expansion(G, Expanded) :-
+    \+ predicate_property(G, iso),
+    prolog_load_context(module, LM),
+    predicate_property(LM:G, implementation_module(IM)),
+    rdf_meta_specification(G, IM, Spec),
+    rdf_expand(G, Spec, Expanded, LM).
+
+system:term_expansion(Module:Fact, Expanded) :-
+    atom(Module),
+    rdf_meta_specification(Fact, Module, Spec),
+    rdf_expand(Fact, Spec, ExpandedFact, Module),
+    Fact \== ExpandedFact,
+    Expanded = (Module:ExpandedFact).
+system:term_expansion(Fact, Expanded) :-
+    prolog_load_context(module, Module),
+    rdf_meta_specification(Fact, Module, Spec),
+    rdf_expand(Fact, Spec, Expanded, Module),
+    Fact \== Expanded.
+system:term_expansion(Clause0, Clause) :-
+    split_rule(Clause0, Clause, Module, Head, Expanded),
+    rdf_meta_specification(Head, Module, Spec),
+    rdf_expand(Head, Spec, Expanded, Module),
+    Head \== Expanded.
+
+rdf_expand(G, Spec, Expanded, M) :-
+    functor(G, Name, Arity),
+    functor(Expanded, Name, Arity),
+    rdf_expand_args(0, Arity, G, Spec, Expanded, M).
+
+rdf_expand_args(Arity, Arity, _, _, _, _) :- !.
+rdf_expand_args(I0, Arity, Goal, Spec, Expanded, M) :-
+    I is I0 + 1,
+    arg(I, Goal, GA),
+    arg(I, Spec, SA),
+    arg(I, Expanded, EA),
+    rdf_expand_arg(SA, GA, EA, M),
+    rdf_expand_args(I, Arity, Goal, Spec, Expanded, M).
+
+rdf_expand_arg(r, A, E, M) :-
+    mk_global(A, E, M),
+    !.
+rdf_expand_arg(o, A, E, M) :-
+    rdf_global_object(A, E, M),
+    !.
+rdf_expand_arg(t, A, E, M) :-
+    rdf_global_term(A, E, M),
+    !.
+rdf_expand_arg(g, A, E, M) :-
+    rdf_global_graph(A, E, M),
+    !.
+rdf_expand_arg(:, A, E, _M) :-
+    !,
+    expand_goal(A, E).
+rdf_expand_arg(_, A, A, _M).
+
+%!  mk_global(+Src, -Resource, +Module)
+%
+%   Realised rdf_global_id(+, -), but adds compiletime checking,
+%   notably to see whether a namespace is not yet defined.
+
+mk_global(X, X, _) :-
+    var(X),
+    !.
+mk_global(X, X, _) :-
+    atom(X),
+    !.
+mk_global(Prefix:Local, Global, Module) :-
+    must_be(atom, Prefix),
+    must_be(atom, Local),
+    (   rdf_current_prefix(Module:Prefix, Full)
+    ->  atom_concat(Full, Local, Global)
+    ;   current_prolog_flag(xref, true)
+    ->  Global = Prefix:Local
+    ;   existence_error(rdf_prefix, Prefix)
+    ).
+