Only literal sameValue can be extended

Author: afs

spec/index.html

@@ -5672,19 +5672,19 @@ NOT IN
           Functions on RDF Terms
 
           
-            SameTerm
+            sameTerm
              xsd:boolean  sameTerm (RDF term term1, RDF term term2)
             Returns TRUE if term1 and term2 are the same RDF term as
               defined in [[[RDF12-CONCEPTS]]] [[RDF12-CONCEPTS]]; returns FALSE otherwise.
             
-              |term1| and |term2| are 
-              equal RDF terms
+              |term1| and |term2| are the
+              same RDF terms
               if one of the following is true:
             
             
               term1 and term2 are 
-                IRIs that are 
-                equal as IRIs.
+                IRIs that are the
+                same as IRIs.
               
               term1 and term2 are 
                 literals that are 
@@ -5729,7 +5729,7 @@ SameTerm
                   
                   
                     
-                    
+                    
                   
                   
                     
@@ -5749,7 +5749,7 @@ SameTerm
           
           
             
-            SameValue
+            sameValue
             
               xsd:boolean sameValue (RDF term term1, RDF term term2)
             
@@ -5761,31 +5761,37 @@ SameValue
               .
             
 
+            
+              Revise for triple terms.
+              
+              Consider adding non-literal `=` to operator mapping table.
+            
+
+            The result of this function is determined by going through the following steps.
             
-              If one or both arguments are known to be ill-typed, 
+              If term1 and term2 are
+                equal RDF terms,
+                the return TRUE.
+              
+              If both arguments are literals,
+                literals
+                and one or both arguments are known to be ill-typed, 
                 then produce a type error.
               
-              Returns TRUE if term1 and term2 are
-                equal RDF terms.
+              If term1 and term2 both 
+                literals
+                and the SPARQL processor can determine the values are equal,
+                then return TRUE.
               
-              If the SPARQL processor can determine the values of both terms
-                and it can determine the values are equal, then return TRUE.
+              If term1 and term2 both 
+                literals
+                and the SPARQL processor can determine the values can not be equal,
+                then return FALSE.
               
-              If the SPARQL processor can determine that the values of the terms
-                can not be equal, the return FALSE.
+              Otherwise, return FALSE.
               
             
-
-
-              If the function is to become callable as 
-                `sameValue(term1, term2)`, add a rule 
-                that if there is an
-                operation mapping for "="
-                for the arguments, an implementation MUST return the same boolean value
-                from `sameValue(term1, term2)`.
-              
-            
-
+
               
                 The treatment of `NaN` can not be consistent with both "same term means same value" 
                 and "`fn:numeric-equal(NaN, NaN)` is false". So it is an arbitrary choice with
@@ -5824,23 +5830,23 @@ SameValue
 
               A literal is 
                 ill-typed
-                if the datatype is one handled by the SPARQL processor and
-                the lexical form is not in
-                the lexical space
+                if its datatype is handled by the SPARQL processor and
+                its lexical form is not in the
+                lexical space
                 of the datatype.
               
               
-                The function `sameValue` returns true or false in cases where
-                the SPARQL processor can determine that the values of the
-                arguments are equal or are not equal. If the SPARQL processor
-                can not be sure, it returns `error`.
+                If the two arguments are literals, the function `sameValue` 
+                returns `true` or `false` in cases where the SPARQL processor
+                can determine that the values of these literals are equal or are not equal. 
+                If the SPARQL processor can not be sure, it returns `error`.
               
             
 
               
-                The Operator Mapping for "`=`""
+                The Operator Mapping for "`=`"
                 is the function
-                fn:numeric-equal`
+                `fn:numeric-equal`
                 which returns `false` when comparing arguments involving `NaN`.
                 However, `sameTerm("NaN"^^xsd:double, "NaN"^^xsd:double)` is true;
                 `sameValue` treats "NaN" as the "same value".
@@ -12257,7 +12263,7 @@ Changes between SPARQL 1.1 Query Language and SPARQL 1.2 Query Language
         
             Editorial changes:
             
-                Give a actual function signature to 
+                Give an actual function signature to 
                 Improve wording of blank nodes in 
                 Improve display on mobile
                 Move `sameValue` (was `RDFterm-equal`) and `sameTerm` to