sparql 3.2.1 → 3.2.3

data/lib/sparql/algebra/operator/path_range.rb

@@ -0,0 +1,178 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `pathRange` (NonCountingPath) operator.
+    #
+    # Property path ranges allow specific path lenghts to be queried. The minimum range describes the minimum path length that will yield solutions, and the maximum range the maximum path that will be returned. A minumum of zero is similar to the `path?` operator. The maximum range of `*` is similar to the `path*` or `path+` operators.
+    #
+    # For example, the two queries are functionally equivalent:
+    #
+    #     SELECT * WHERE {:a :p{1,2} :b}
+    #
+    #     SELECT * WHERE {:a (:p/:p?) :b}
+    #
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
+    #
+    # @example SPARQL Grammar range with fixed length
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{2} ?z
+    #   } 
+    #
+    # @example SSE range with fixed length only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 2 2 :p) ?z))
+    #
+    # @example SPARQL Grammar range with min only
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{1,} ?z
+    #   } 
+    #
+    # @example SSE range with min only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 1 * :p) ?z))
+    #
+    # @example SPARQL Grammar range with max only
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{,2} ?z
+    #   } 
+    #
+    # @example SSE range with max only
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 0 2 :p) ?z))
+    #
+    # @example SPARQL Grammar range with min and max
+    #   PREFIX : <http://example/> 
+    #   SELECT * WHERE {
+    #     :a :p{1,2} ?z
+    #   } 
+    #
+    # @example SSE range with min and max
+    #   (prefix ((: <http://example/>))
+    #    (path :a (pathRange 1 2 :p) ?z))
+    #
+    class PathRange < Operator::Ternary
+      include Query
+      
+      NAME = :"pathRange"
+
+      ##
+       # Initializes a new operator instance.
+       #
+       # @param  [RDF::Literal::Integer] max
+       #   the range minimum
+       # @param  [RDF::Literal::Integer, Symbol] min
+       #   the range maximum (may be `*`)
+       # @param  [SPARQL::Operator] path
+       #   the query
+       # @param  [Hash{Symbol => Object}] options
+       #   any additional options (see {Operator#initialize})
+       # @raise  [TypeError] if any operand is invalid
+       # @raise  [ArgumentError] range element is invalid
+      def initialize(min, max, path, **options)
+        raise ArgumentError, "expect min <= max {#{min},#{max}}" if
+          max.is_a?(RDF::Literal::Integer) && max < min
+        super
+      end
+
+      ##
+      # Path with lower and upper bounds on lenghts:
+      #
+      #    (path :a (pathRange 1 2 :p) :b)
+      #    => (path)
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param [RDF::Query::Solutions] accumulator (RDF::Query::Solutions.new)
+      #   For previous solutions to avoid duplicates.
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable,
+                  accumulator: RDF::Query::Solutions.new,
+                  index: RDF::Literal(0),
+                  **options,
+                  &block)
+
+        min, max, op = *operands
+        subject, object = options[:subject], options[:object]
+        debug(options) {"Path{#{min},#{max}} #{[subject, op, object].to_sse}"}
+
+        path_mm = if min.zero? && max.is_a?(RDF::Literal::Integer) && max.zero?
+          PathZero.new(op, **options)
+        else
+          # Build up a sequence
+          path_opt = nil
+          seq_len = min.to_i
+          if max.is_a?(RDF::Literal::Integer)
+            # min to max is a sequence of optional sequences
+            opt_len = (max - min).to_i
+            while opt_len > 0 do
+              path_opt = PathOpt.new(path_opt ? Seq.new(op, path_opt, **options) : op, **options)
+              opt_len -= 1
+            end
+          elsif seq_len > 0
+            path_opt = PathPlus.new(op, **options)
+            seq_len -= 1
+          else
+            path_opt = PathStar.new(op, **options)
+          end
+
+          # sequence ending in op, op+, op*, or path_opt
+          path_seq = nil
+          while seq_len > 0 do
+            path_seq = if path_opt
+              opt, path_opt = path_opt, nil
+              Seq.new(op, opt, **options)
+            elsif path_seq
+              Seq.new(op, path_seq, **options)
+            else
+              op
+            end
+            seq_len -= 1
+          end
+          path_seq || path_opt || op
+        end
+        debug(options) {"=> #{path_mm.to_sse}"}
+
+        # After this, path_mm may just be the original op, which can be a term, not an operator.
+        if path_mm.is_a?(RDF::Term)
+          path_mm = RDF::Query.new do |q|
+            q.pattern [subject, path_mm, object]
+          end
+        end
+
+        solutions = path_mm.execute(queryable, **options.merge(depth: options[:depth].to_i + 1)).uniq
+        debug(options) {"(path{#{min},#{max}})=> #{solutions.to_sxp}"}
+        solutions.each(&block) if block_given?
+        solutions
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        min, max, path = operands
+        "(#{path.to_sparql(**options)})" +
+        if max == :*
+          "{#{min},}"
+        elsif min == max
+          "{#{min}}"
+        else
+          "{#{min},#{max}}"
+        end
+      end
+    end # PathStar
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/path_star.rb

@@ -3,8 +3,8 @@ module SPARQL; module Algebra
     ##
     # The SPARQL Property Path `path*` (ZeroOrMorePath) operator.
     #
-    # [91]  PathElt                 ::= PathPrimary PathMod?
-    # [93]  PathMod                 ::= '*' | '?' | '+'
+    # [91]  PathElt ::= PathPrimary PathMod?
+    # [93]  PathMod ::= '*' | '?' | '+' | '{' INTEGER? (',' INTEGER?)? '}'
     
     # @example SPARQL Grammar
     #   PREFIX : <http://example/> 
@@ -23,10 +23,13 @@ module SPARQL; module Algebra
       NAME = :"path*"
 
       ##
-      # Path including zero length:
+      # Path including at zero length:
       #
       #    (path :a (path* :p) :b)
-      #    => (path :a (path? (path+ :p)) :b)
+      #
+      # into
+      #
+      #    (path :a (path? (path+ :p)) :b)
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query

data/lib/sparql/algebra/operator/path_zero.rb

@@ -0,0 +1,110 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL Property Path `path0` (ZeroLengthPath) operator.
+    #
+    # A zero length path matches all subjects and objects in the graph, and also any RDF terms explicitly given as endpoints of the path pattern.
+    #
+    # @see https://www.w3.org/TR/sparql11-query/#defn_evalPP_ZeroOrOnePath
+    class PathZero < Operator::Unary
+      include Query
+      
+      NAME = :path0
+
+      ##
+      # Zero length path:
+      #
+      #    (path x (path0 :p) y)
+      #     => (filter (x = y) (solution x y))
+      #
+      # @param  [RDF::Queryable] queryable
+      #   the graph or repository to query
+      # @param  [Hash{Symbol => Object}] options
+      #   any additional keyword options
+      # @option options [RDF::Term, RDF::Variable] :subject
+      # @option options [RDF::Term, RDF::Variable] :object
+      # @yield  [solution]
+      #   each matching solution
+      # @yieldparam  [RDF::Query::Solution] solution
+      # @yieldreturn [void] ignored
+      # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
+      def execute(queryable, **options, &block)
+        subject, object = options[:subject], options[:object]
+        debug(options) {"PathZero #{[subject, operands, object].to_sse}"}
+
+        solutions = RDF::Query::Solutions.new
+        # The zero-length case implies subject == object.
+        case
+        when subject.variable? && object.variable?
+          # Nodes is the set of all subjects and objects in queryable
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => solution[subject])
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => solution[object])
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        when subject.variable?
+          # All subjects which are `object`
+          query = RDF::Query.new {|q| q.pattern({subject: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `object`
+          query = RDF::Query.new {|q| q.pattern({object: object})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(subject.to_sym => object)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        when object.variable?
+          # All subjects which are `subject`
+          query = RDF::Query.new {|q| q.pattern({subject: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-s0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+
+          # All objects which are `subject`
+          query = RDF::Query.new {|q| q.pattern({object: subject})}
+          query.execute(queryable, **options) do |solution|
+            solution.merge!(object.to_sym => subject)
+            unless solutions.include?(solution)
+              #debug(options) {"(solution-o0)-> #{solution.to_h.to_sse}"}
+              solutions << solution
+            end
+          end if query.valid?
+        else
+          # Otherwise, if subject == object, an empty solution
+          solutions << RDF::Query::Solution.new if subject == object
+        end
+
+        solutions.uniq!
+        debug(options) {"(path0)=> #{solutions.to_sxp}"}
+        solutions.each(&block) if block_given?
+        solutions
+      end
+    end # PathZero
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/plus.rb

@@ -47,19 +47,21 @@ module SPARQL; module Algebra
       ##
       # Returns the arithmetic sum of the operands, unless there is no `right`.
       #
-      # @param  [RDF::Literal::Numeric] left
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal] left
       #   a numeric literal
-      # @param  [RDF::Literal::Numeric] right
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Duration] right
       #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if either operand is not a numeric literal
+      # @return [RDF::Literal::Numeric, RDF::Literal::Temporal]
+      # @raise  [TypeError] if either operand is neither a numeric nor a temporal literal
       def apply(left, right = nil, **options)
         case
         when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
           left + right
         when left.is_a?(RDF::Literal::Numeric) && right.nil?
           left
-        else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
+        when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Duration)
+          left + right
+        else raise TypeError, "expected two RDF::Literal::Numeric operands or a Temporal and a Duration, but got #{left.inspect} and #{right.inspect}"
         end
       end
 

data/lib/sparql/algebra/operator/project.rb

@@ -57,10 +57,38 @@ module SPARQL; module Algebra
       
       NAME = [:project]
 
+      ##
+      # Can only project in-scope variables.
+      #
+      # @return (see Algebra::Operator#initialize)
+      def validate!
+        if (group = descendants.detect {|o| o.is_a?(Group)})
+          raise ArgumentError, "project * on group is illegal" if operands.first.empty?
+          query_vars = operands.last.variables
+          variables.keys.each do |v|
+            raise ArgumentError,
+              "projecting #{v.to_sse} not projected from group" unless
+              query_vars.key?(v.to_sym)
+          end
+        end
+
+        super
+      end
+
+      ##
+      # The projected variables.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        operands(1).inject({}) {|hash, o| hash.merge(o.variables)}
+      end
+
       ##
       # Executes this query on the given `queryable` graph or repository.
       # Reduces the result set to the variables listed in the first operand
       #
+      # If the first operand is empty, this indicates a `SPARQL *`, and all in-scope variables are projected.
+      #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
       # @param  [Hash{Symbol => Object}] options
@@ -74,10 +102,23 @@ module SPARQL; module Algebra
       # @see    https://www.w3.org/TR/sparql11-query/#sparqlAlgebra
       def execute(queryable, **options, &block)
         @solutions = queryable.query(operands.last, depth: options[:depth].to_i + 1, **options)
-        @solutions = @solutions.project(*(operands.first))
+        @solutions.variable_names = self.variables.keys
+        @solutions = @solutions.project(*(operands.first)) unless operands.first.empty?
         @solutions.each(&block) if block_given?
         @solutions
       end
+    
+      ##
+      # In-scope variables for a select are limited to those projected.
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        in_scope = operands.first.empty? ?
+          operands.last.variables.values :
+          operands.first
+
+        in_scope.inject({}) {|memo, v| memo.merge(v.variables)}
+      end
 
       ##
       #

data/lib/sparql/algebra/operator/seconds.rb

@@ -31,10 +31,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.second)
       end
 

data/lib/sparql/algebra/operator/seq.rb

@@ -59,10 +59,10 @@ module SPARQL; module Algebra
         end
 
         left = queryable.query(q1, **options.merge(object: v, depth: options[:depth].to_i + 1))
-        debug(options) {"(seq)=>(left) #{left.map(&:to_h).to_sse}"}
+        #debug(options) {"(seq)=>(left) #{left.map(&:to_h).to_sse}"}
 
         right = queryable.query(q2, **options.merge(subject: v, depth: options[:depth].to_i + 1))
-        debug(options) {"(seq)=>(right) #{right.map(&:to_h).to_sse}"}
+        #debug(options) {"(seq)=>(right) #{right.map(&:to_h).to_sse}"}
 
         @solutions = RDF::Query::Solutions(left.map do |s1|
           right.map do |s2|
@@ -72,7 +72,7 @@ module SPARQL; module Algebra
           solution.bindings.delete(v.to_sym)
           solution
         end
-        debug(options) {"(seq)=> #{@solutions.map(&:to_h).to_sse}"}
+        debug(options) {"(seq)=> #{@solutions.to_sxp}"}
         @solutions.each(&block) if block_given?
         @solutions
       end

data/lib/sparql/algebra/operator/sequence.rb

@@ -51,6 +51,16 @@ module SPARQL; module Algebra
         @solutions.each(&block) if block_given?
         @solutions
       end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        str = "{\n" + operands.to_sparql(top_level: false, **options) + "\n}"
+        Operator.to_sparql(str, **options)
+      end
     end # Sequence
   end # Operator
 end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/subtract.rb

@@ -31,17 +31,21 @@ module SPARQL; module Algebra
       ##
       # Returns the arithmetic difference of the operands.
       #
-      # @param  [RDF::Literal::Numeric] left
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal] left
       #   a numeric literal
-      # @param  [RDF::Literal::Numeric] right
+      # @param  [RDF::Literal::Numeric, RDF::Literal::Temporal, RDF::Literal::Duration] right
       #   a numeric literal
-      # @return [RDF::Literal::Numeric]
-      # @raise  [TypeError] if either operand is not a numeric literal
+      # @return [RDF::Literal::Numeric, RDF::Literal::Temporal, RDF::Literal::Duration]
+      # @raise  [TypeError] if either operand is neither a numeric nor a temporal literal
       def apply(left, right, **options)
         case
           when left.is_a?(RDF::Literal::Numeric) && right.is_a?(RDF::Literal::Numeric)
             left - right
-          else raise TypeError, "expected two RDF::Literal::Numeric operands, but got #{left.inspect} and #{right.inspect}"
+          when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Temporal)
+            left - right
+          when left.is_a?(RDF::Literal::Temporal) && right.is_a?(RDF::Literal::Duration)
+            left - right
+          else raise TypeError, "expected two RDF::Literal::Numeric, Temporal operands, or a Temporal and a Duration, but got #{left.inspect} and #{right.inspect}"
         end
       end
 

data/lib/sparql/algebra/operator/table.rb

@@ -89,9 +89,19 @@ module SPARQL; module Algebra
           end
           @solutions << RDF::Query::Solution.new(bindings)
         end
+        @solutions.variable_names = self.variables.keys
         @solutions.each(&block) if block_given?
         @solutions
       end
+    
+      ##
+      # In-scope variables for a table are the variables operand
+      #
+      # @return [Hash{Symbol => RDF::Query::Variable}]
+      def variables
+        in_scope = operands.first.is_a?(Array) ? operands.first[1..-1] : []
+        in_scope.inject({}) {|memo, v| memo.merge(v.variables)}
+      end
 
       ##
       #
@@ -105,8 +115,7 @@ module SPARQL; module Algebra
         operands[1..-1].each do |row|
           line = '('
           row[1..-1].each do |col|
-            v = col[1].to_sparql(as_statement: true, **options)
-            v = "<< #{v} >>" if col[1].is_a?(RDF::Statement)
+            v = col[1].to_sparql(**options)
             line << v + ' '
           end
           line = line.chomp(' ')

data/lib/sparql/algebra/operator/timezone.rb

@@ -33,10 +33,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         raise TypeError, "literal has no timezone" unless res = operand.timezone
         res
       end

data/lib/sparql/algebra/operator/triple.rb

@@ -0,0 +1,51 @@
+module SPARQL; module Algebra
+  class Operator
+    ##
+    # The SPARQL `triple` operator.
+    #
+    # If the 3-tuple (term1, term2, term3) is an RDF-star triple, the function returns this triple. If the 3-tuple is not an RDF-star triple, then the function raises an error.
+    #
+    # [121] BuiltInCall ::= ... | 'TRIPLE' '(' Expression ',' Expression ',' Expression ')' 
+    #
+    # @example SPARQL Grammar
+    #   PREFIX : <http://example.com/ns#>
+    #   SELECT * {
+    #     ?s ?p ?o .
+    #     BIND(TRIPLE(?s, ?p, ?o) AS ?t1)
+    #   }
+    #
+    # @example SSE
+    #   (prefix ((: <http://example.com/ns#>))
+    #    (extend ((?t1 (triple ?s ?p ?o)))
+    #     (bgp (triple ?s ?p ?o))))
+    #
+    # @note This operator overlaps with RDF::Query::Pattern as used as an operand to a BGP.
+    # @see https://w3c.github.io/rdf-star/rdf-star-cg-spec.html#triple
+    class Triple < Operator::Ternary
+      include Evaluatable
+
+      NAME = :triple
+
+      ##
+      # @param  [RDF::Term] subject
+      # @param  [RDF::Term] predicate
+      # @param  [RDF::Term] object
+      # @return [RDF::URI]
+      # @raise  [TypeError] if the operand is not a simple literal
+      def apply(subject, predicate, object, **options)
+        triple = RDF::Statement(subject, predicate, object)
+        raise TypeError, "valid components, but got #{triple.inspect}" unless triple.valid?
+        triple
+      end
+
+      ##
+      #
+      # Returns a partial SPARQL grammar for this operator.
+      #
+      # @return [String]
+      def to_sparql(**options)
+        "TRIPLE(#{operands.to_sparql(delimiter: ', ', **options)})"
+      end
+    end # Triple
+  end # Operator
+end; end # SPARQL::Algebra

data/lib/sparql/algebra/operator/tz.rb

@@ -29,12 +29,12 @@ module SPARQL; module Algebra
       ##
       # Returns the timezone part of arg as a simple literal. Returns the empty string if there is no timezone.
       #
-      # @param  [RDF::Literal] operand
+      # @param  [RDF::Literal::Temporal] operand
       #   the operand
       # @return [RDF::Literal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         operand.tz
       end
       ##

data/lib/sparql/algebra/operator/using.rb

@@ -39,8 +39,8 @@ module SPARQL; module Algebra
     # @example SSE (multiple clauses)
     #   (prefix ((: <http://example.org/>))
     #    (update
-    #     (modify (using (:g1 :g2)
-    #      (bgp (triple ?s ?p ?o)))
+    #     (modify
+    #      (using (:g1 :g2) (bgp (triple ?s ?p ?o)))
     #      (insert ((triple ?s ?p "q"))))))
     #
     # @see https://www.w3.org/TR/sparql11-update/#add

data/lib/sparql/algebra/operator/year.rb

@@ -31,10 +31,10 @@ module SPARQL; module Algebra
       #
       # @param  [RDF::Literal] operand
       #   the operand
-      # @return [RDF::Literal]
+      # @return [RDF::Literal::Temporal]
       # @raise  [TypeError] if the operand is not a simple literal
       def apply(operand, **options)
-        raise TypeError, "expected an RDF::Literal::DateTime, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::DateTime)
+        raise TypeError, "expected an RDF::Literal::Temporal, but got #{operand.inspect}" unless operand.is_a?(RDF::Literal::Temporal)
         RDF::Literal(operand.object.year)
       end