bel_parser 1.0.0.alpha.1

data/lib/bel_parser/expression/parser.rb

@@ -0,0 +1,42 @@
+require_relative '../ast_filter'
+require_relative '../ast_generator'
+require_relative '../parsers/common'
+require_relative '../parsers/expression'
+require_relative '../mixin/line_mapping'
+
+module BELParser
+  module Expression
+    # Parser for BEL Expression.
+    class Parser
+      include BELParser::Parsers::Common
+      include BELParser::Parsers::Expression
+
+      FILTER = BELParser::ASTFilter.new(
+        :statement_simple,
+        :observed_term,
+        :nested_statement
+      )
+
+      def each(io)
+        if block_given?
+          filtered_ast = FILTER.each(BELParser::ASTGenerator.new.each(io))
+          filtered_ast.each do |results|
+            yield results
+          end
+        else
+          enum_for(:each, io)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::Expression::Parser.new.each($stdin) do |line_result|
+    line_number, line, ast_results = line_result
+    puts "#{line_number}: #{line}"
+    ast_results.each do |ast|
+      puts ast.to_s(1)
+    end
+  end
+end

data/lib/bel_parser/expression/term_semantics.rb

@@ -0,0 +1,36 @@
+require_relative '../ast_filter'
+require_relative '../ast_generator'
+require_relative '../parsers/expression'
+require_relative '../language/version2'
+require_relative '../language/semantics/analyzer'
+
+module BELParser
+  module Expression
+    # Parser for BEL Expression.
+    class TermSemanticsParser
+      include BELParser::Parsers::Common
+      include BELParser::Parsers::Expression
+
+      FILTER = BELParser::ASTFilter.new(:term)
+
+      def each(io)
+        if block_given?
+          v2           = BELParser::Language::Version2::Specification.new
+          filtered_ast = FILTER.each(BELParser::ASTGenerator.new.each(io))
+          filtered_ast.each do |results|
+            term = results.last.first
+            yield BELParser::Language::Semantics.check_term(term, v2)
+          end
+        else
+          enum_for(:each, io)
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::Expression::TermSemanticsParser.new.each($stdin) do |semantics|
+    puts semantics.join(", ")
+  end
+end

data/lib/bel_parser/language.rb

@@ -0,0 +1,7 @@
+require_relative 'language/function'
+require_relative 'language/quoting'
+require_relative 'language/semantic_ast'
+require_relative 'language/signature'
+require_relative 'language/specification'
+
+# BEL language/version1 and language/version2 files are loaded when needed.

data/lib/bel_parser/language/function.rb

@@ -0,0 +1,59 @@
+module BELParser
+  module Language
+    # Function allows you to describe the type of BEL Term.
+    #
+    # BEL Terms are composed of BEL Functions and entity definitions
+    # referenced using BEL Namespace identifiers. Each BEL Term represents
+    # either an abundance of a biological entity, the abundance of human AKT1
+    # for example, or a biological process such as cardiomyopathy.
+    module Function
+      def short
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def long
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def return_type
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def description
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def signatures
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def ===(other)
+        return false if other.nil?
+        short == other || long == other
+      end
+
+      def to_sym(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      def to_s(form = :short)
+        value = _form_value(form)
+        return nil unless value
+        value.to_s
+      end
+
+      private
+
+      def _form_value(form = :short)
+        case form
+        when :short
+          short
+        when :long
+          long
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/language/quoting.rb

@@ -0,0 +1,236 @@
+module BELParser
+
+  # The Quoting module implements quoting rules consistent with BEL
+  # and BEL Script. Double quotes are used to group a string together
+  # which may contain whitespace or special characters.
+  #
+  # A value can either be an identifier or a string value. An
+  # identifier can only include the characters +[0-9A-Za-z_]+. A string
+  # value is necessary when at least one of +[^0-9A-Za-z_]+ exists in
+  # the value.
+  #
+  # Uses:
+  #
+  # BEL: The BEL parameters must be an identifier or string value.
+  #
+  # BEL Script: BEL parameters, document property values, and annotation
+  # values must be an identifier or string value.
+  module Quoting
+
+    # Declares BEL Script keywords that cause problems with the OpenBEL
+    # Framework parser.
+    Keywords               = %w(SET DEFINE a g p r m)
+
+    # Regular expression that matches one of {Quoting::Keywords}.
+    KeywordMatcher         = Regexp.compile(/^(#{Keywords.join('|')})$/)
+
+    # Regular expression that matches on any non-word character.
+    NonWordMatcher         = Regexp.compile(/[^0-9a-zA-Z_]/)
+
+    # Regular expression that matches a value surrounded by unescaped
+    # double quotes.
+    StrictQuotedMatcher    = Regexp.compile(/\A".*?(?<!\\)"\Z/m)
+
+    # Regular expression that matches a value surrounded by double quotes
+    # that may be escaped.
+    LenientQuotedMatcher   = Regexp.compile(/\A".*?"\Z/m)
+
+    # Regular expression that matches double quotes that are not escaped.
+    QuoteNotEscapedMatcher = Regexp.compile(/(?<!\\)"/m)
+
+    # Returns +value+ surrounded by double quotes. This method is idempotent
+    # so +value+ will only be quoted once regardless of how may times the
+    # method is called on it.
+    #
+    # @example Quoting a BEL parameter.
+    #    quote("apoptotic process")
+    #    # => "\"apoptotic process\""
+    # @example Escaping quotes within a value.
+    #    quote("vesicle fusion with \"Golgi apparatus\"")
+    #    # => "\"vesicle fusion with \\\"Golgi apparatus\\\"\""
+    #
+    # @parameter [#to_s] value a value to be quoted
+    # @return    [String] value surrounded by double quotes
+    def quote(value)
+      string   = value.to_s
+      unquoted = unquote(string)
+      escaped  = unquoted.gsub(QuoteNotEscapedMatcher, "\\\"")
+      %Q{"#{escaped}"}
+    end
+
+    # Returns +value+ with surrounded quotes removed.
+    #
+    # @example Unquoting a BEL parameter.
+    #    unquote("\"apoptotic process\"")
+    #    # => "apoptotic process"
+    # @example Escaped quotes are preserved.
+    #    unquote("\"vesicle fusion with \"Golgi apparatus\"\"")
+    #
+    # @parameter [#to_s]  value a value to be unquoted
+    # @return    [String] value with surrounding double quotes removed
+    def unquote(value)
+      string = value.to_s
+      if string =~ StrictQuotedMatcher
+        string[1...-1]
+      else
+        string
+      end
+    end
+
+    # Returns +value+ with quoting applied only if necessary. A +value+
+    # consisting of only word character (e.g. [0-9A-Za-z_]) does not need
+    # quoting. A +value+ consisting of at least one non-word character
+    # (e.g. [^0-9A-Za-z_]) will requiring quoting.
+    #
+    # @example Quotes added when value includes spaces.
+    #    quote_if_needed("apoptotic process")
+    #    # => "\"apoptotic process\""
+    # @example Quotes added when value includes double quote.
+    #    quote_if_needed("vesicle fusion with \"Golgi apparatus\"")
+    #    # => "\"vesicle fusion with \\\"Golgi apparatus\\\"\""
+    # @example No quotes necessary for identifier.
+    #    quote_if_needed("AKT1_HUMAN")
+    #    # => "AKT1_HUMAN"
+    #
+    # @parameter [#to_s]  value that may be quoted
+    # @return    [String] original value or quoted value
+    def quote_if_needed(value)
+      if string_value?(value)
+        quote(value)
+      else
+        value.to_s
+      end
+    end
+
+    # Returns whether the +value+ is surrounded by double quotes.
+    #
+    # @example Returns +true+ when value is quoted.
+    #    quoted?("\"vesicle fusion with \"Golgi apparatus\"")
+    #    # => true
+    # @example Returns +false+ when value is not quoted.
+    #    quoted?("apoptotic process")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is quoted, +false+ if
+    #            +value+ is not quoted
+    def quoted?(value)
+      string = value.to_s
+      (string =~ LenientQuotedMatcher) != nil
+    end
+
+    # Returns whether the +value+ is not surrounded by double quotes.
+    #
+    # @example Returns +true+ when value is not quoted.
+    #    unquoted?("apoptotic process")
+    #    # => true
+    # @example Returns +false+ when value is quoted.
+    #    unquoted?("\"vesicle fusion with \"Golgi apparatus\"")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is not quoted, +false+ if
+    #            +value+ is quoted
+    def unquoted?(value)
+      !quoted?(value)
+    end
+
+    # Returns whether the +value+ represents an identifier. An
+    # identifier consists of only word characters (e.g. [0-9A-Za-z_]).
+    #
+    # @example Returns +true+ when representing an identifier.
+    #    identifier_value?("AKT1_HUMAN")
+    #    # => true
+    # @example Returns +false+ when not representing an identifier.
+    #    identifier_value?("apoptotic process")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is an identifier,
+    #            +false+ if +value+ is not an identifier
+    def identifier_value?(value)
+      string = value.to_s
+      [NonWordMatcher, KeywordMatcher].none? { |matcher|
+        matcher.match string
+      }
+    end
+
+    # Returns whether the +value+ represents a string value. A string
+    # value consists of at least one non-word character
+    # (e.g. [^0-9A-Za-z_]).
+    #
+    # @example Returns +true+ when representing a string value.
+    #    string_value?("apoptotic process")
+    #    # => true
+    # @example Returns +false+ when not representing a string value.
+    #    string_value?("AKT1_HUMAN")
+    #    # => false
+    #
+    # @parameter [#to_s]   value to test
+    # @return    [Boolean] +true+ if +value+ is a string value,
+    #            +false+ if +value+ is not a string value
+    def string_value?(value)
+      string = value.to_s
+      [NonWordMatcher, KeywordMatcher].any? { |matcher|
+        matcher.match string
+      }
+    end
+
+    ## Deprecated, remove in [0.6.0].
+
+    # @deprecated Use {#quote_if_needed} instead. Will be removed in a
+    #             future release.
+    def ensure_quotes identifier
+      warn <<-DOC.gsub(/^\s+/, '')
+        Deprecation Warning
+        -------------------
+        The BEL::Quoting::ensure_quotes method is deprecated and
+        will be removed in a future relase.
+        Call module method BEL::Quoting.quote_if_needed instead.
+      DOC
+      quote_if_needed(identifier)
+    end
+
+    # @deprecated Use {#unquote} instead. Will be removed in a
+    #             future release.
+    def remove_quotes identifier
+      warn <<-DOC.gsub(/^\s+/, '')
+        Deprecation Warning
+        -------------------
+        The BEL::Quoting::remove_quotes method is deprecated and
+        will be removed in a future relase.
+        Call module method BEL::Quoting.unquote instead.
+      DOC
+      unquote(identifier)
+    end
+
+    # @deprecated Use {#quote} instead. Will be removed in a
+    #             future release.
+    def always_quote identifier
+      warn <<-DOC.gsub(/^\s+/, '')
+        Deprecation Warning
+        -------------------
+        The BEL::Quoting::always_quote method is deprecated and
+        will be removed in a future relase.
+        Call module method BEL::Quoting.quote instead.
+      DOC
+      quote(identifier)
+    end
+
+    # @deprecated Use {#quoted?} or {#unquoted?} instead. Will be removed
+    #             in a future release.
+    def quotes_required? identifier
+      warn <<-DOC.gsub(/^\s+/, '')
+        Deprecation Warning
+        -------------------
+        The BEL::Quoting::quotes_required? method is deprecated and 
+        will be removed in a future relase.
+        You can use BEL::Quoting.quoted? and BEL::Quoting.unquoted?
+        going forward.
+      DOC
+      [NonWordMatcher, KeywordMatcher].any? { |m|
+        m.match identifier.to_s
+      }
+    end
+  end
+end

data/lib/bel_parser/language/semantic_ast.rb

@@ -0,0 +1,604 @@
+require_relative 'quoting'
+require_relative '../parsers/ast/node'
+
+module BELParser
+  module Language
+    # Semantics capture BEL version-independent semantics for terms and
+    # statements.
+    module Semantics
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+      def self.match(input_ast, semantic_ast, spec, match_results = [])
+        res = semantic_ast.match(input_ast, spec)
+        match_results.concat(res)
+        if res.flatten.all?(&:success?) && !semantic_ast.terminal?
+          return match_results if semantic_ast.children.empty?
+
+          var_test = semantic_ast.children.any? { |x| x.is_a?(SemanticVariadicArguments) }
+          if var_test
+            test_pairs = input_ast.children.zip(semantic_ast.children).select do |pair|
+              !pair.include?(nil)
+            end
+
+            test_pairs.each do |(input_child, semantic_child)|
+              if semantic_child.is_a?(SemanticVariadicArguments)
+                input_children   = input_ast.children
+                input_arguments  = input_children[input_children.index(input_child)..-1]
+                argument_pattern = semantic_child.children.first
+                input_arguments.each do |argument_child|
+                  res = semantic_child.match(argument_child, spec)
+                  match_results << res
+                  if res.all?(&:success?)
+                    param_or_term = argument_child.children.first
+                    match(param_or_term, argument_pattern, spec, match_results)
+                  end
+                end
+              else
+                match(input_child, semantic_child, spec, match_results)
+              end
+            end
+          else
+            semantic_ast
+              .children
+              .zip(input_ast.children)
+              .each do |semantic_child, input_child|
+                match(input_child, semantic_child, spec, match_results)
+              end
+          end
+        end
+        match_results.flatten
+      end
+
+      # MatchResult holds the results of an input AST to semantic AST match.
+      class MatchResult
+        attr_reader :input_node, :semantic_node
+
+        def initialize(success, input_node, semantic_node)
+          @success       = success
+          @input_node    = input_node
+          @semantic_node = semantic_node
+        end
+
+        def success?
+          @success
+        end
+
+        def failure?
+          !@success
+        end
+
+        def to_s
+          msg
+        end
+      end
+
+      # Builder contains methods to build semantic AST nodes.
+      # A convenient {Builder.build} method allows you to use these
+      # methods within a block scope.
+      #
+      # see Builder.build
+      module Builder
+        def self.build(&block)
+          raise ArgumentError, 'expecting block' unless block_given?
+
+          builder = _builder_class.new
+          builder.instance_eval(&block)
+          builder.result
+        end
+
+        def self._builder_class
+          Class.new do
+            include Builder
+
+            attr_reader :result
+
+            def term(function, *arguments, **properties)
+              @result = super
+            end
+          end
+        end
+        private_class_method :_builder_class
+
+        def term(function, *arguments, **properties)
+          SemanticTerm.new([function, *arguments], **properties)
+        end
+
+        def function(identifier, **properties)
+          SemanticFunction.new([identifier], **properties)
+        end
+
+        def argument(param_or_term, **properties)
+          cls = param_or_term.class
+          if cls != SemanticParameter && cls != SemanticTerm
+            raise ArgumentError, 'expected SemanticParameter or SemanticTerm'
+          end
+
+          SemanticArgument.new([param_or_term], **properties)
+        end
+
+        def parameter(prefix, value, **properties)
+          SemanticParameter.new([prefix, value], **properties)
+        end
+
+        def identifier(*value_patterns, **properties)
+          SemanticIdentifier.new(value_patterns, **properties)
+        end
+
+        def prefix(has_namespace, **properties)
+          SemanticPrefix.new([has_namespace], **properties)
+        end
+
+        def value(value_type, **properties)
+          SemanticValue.new([value_type], **properties)
+        end
+
+        def value_type(*value_patterns, **properties)
+          SemanticValueType.new(value_patterns, **properties)
+        end
+
+        def any(**properties)
+          SemanticAny.new(**properties)
+        end
+
+        # rubocop:disable Style/PredicateName
+        def is_nil(**properties)
+          SemanticIsNil.new(**properties)
+        end
+
+        def has_namespace(**properties)
+          SemanticHasNamespace.new(**properties)
+        end
+
+        def has_encoding(**properties)
+          SemanticHasEncoding.new(**properties)
+        end
+
+        def function_of(*functions, **properties)
+          SemanticFunctionOf.new(functions, **properties)
+        end
+
+        def return_type_of(*return_types, **properties)
+          SemanticReturnTypeOf.new(return_types, **properties)
+        end
+
+        def namespace_of(*namespaces, **properties)
+          SemanticNamespaceOf.new(namespaces, **properties)
+        end
+
+        def encoding_of(*encoding_types, **properties)
+          SemanticEncodingOf.new(encoding_types, **properties)
+        end
+
+        def covalent_modification_of(*covalent_mod_types, **properties)
+          SemanticCovalentModificationOf.new(covalent_mod_types, **properties)
+        end
+
+        def amino_acid_of(*amino_acids, **properties)
+          SemanticAminoAcidOf.new(amino_acids, **properties)
+        end
+
+        def is_amino_acid_range_pattern(**properties)
+          SemanticIsAminoAcidRange.new(**properties)
+        end
+
+        def variadic_arguments(*params_or_terms, **properties)
+          SemanticVariadicArguments.new(params_or_terms, **properties)
+        end
+      end
+
+      # SemanticASTNode represents a node in the semantic tree structure.
+      class SemanticASTNode < AST::Node
+        def initialize(type, children = [], **properties)
+          super(type, children, properties)
+        end
+
+        def terminal?
+          false
+        end
+
+        protected
+
+        def updated(_ = nil, children = nil, properties = nil)
+          new_children   = children   || @children
+          new_properties = properties || {}
+
+          if @children == new_children && properties.nil?
+            self
+          else
+            # Maybe change call?
+            original_dup.send :initialize, new_children, new_properties
+          end
+        end
+
+        def success(node)
+          [MatchResult.new(true, node, self)]
+        end
+
+        def failure(node)
+          [MatchResult.new(false, node, self)]
+        end
+      end
+
+      # AST node for Term is a semantic AST.
+      class SemanticTerm < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:term, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Statement is a semantic AST.
+      class SemanticStatement < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:statement, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Parameter is a semantic AST.
+      class SemanticParameter < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:parameter, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Function is a semantic AST.
+      class SemanticFunction < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:function, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Argument is a semantic AST.
+      class SemanticArgument < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:argument, children, properties)
+        end
+
+        def match(parse_node, _)
+          return failure(nil) if parse_node.nil?
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for VariadicArguments is a semantic AST.
+      class SemanticVariadicArguments < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:variadic_arguments, children, properties)
+        end
+
+        def match(parse_node, _)
+          if parse_node.type == BELParser::Parsers::AST::Argument.ast_type
+            success(parse_node)
+          else
+            failure(parse_node)
+          end
+        end
+      end
+
+      # AST node for Prefix is a semantic AST.
+      class SemanticPrefix < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:prefix, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Value is a semantic AST.
+      class SemanticValue < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:value, children, properties)
+        end
+
+        def match(parse_node, _)
+          type == parse_node.type ? success(parse_node) : failure(parse_node)
+        end
+      end
+
+      # AST node for Nil is a semantic AST.
+      class SemanticIsNil < SemanticASTNode
+        def initialize(**properties)
+          super(:is_nil, [], properties)
+        end
+
+        def terminal?
+          true
+        end
+
+        def match(parse_node, _)
+          parse_node.nil? ? success(parse_node) : failure(nil)
+        end
+      end
+
+      # AST node for Identifier is a semantic AST.
+      class SemanticIdentifier < SemanticASTNode
+        def initialize(children = [], **properties)
+          super(:identifier, children, properties)
+        end
+
+        def terminal?
+          true
+        end
+
+        def value_patterns
+          children
+        end
+
+        def match(identifier, spec)
+          return failure(nil) if identifier.nil?
+          return failure(identifier) if type != identifier.type
+
+          value_results = value_patterns.map do |pattern|
+            pattern.match(identifier, spec)
+          end
+
+          failure_result = value_results.flatten.find(&:failure?)
+
+          if failure_result
+            [failure(identifier), failure_result]
+          else
+            value_results.unshift(success(identifier))
+          end
+        end
+      end
+
+      # AST node for Any is a semantic AST.
+      class SemanticAny < SemanticASTNode
+        def initialize(**properties)
+          super(:any, [], properties)
+        end
+
+        def match(parse_node, _)
+          success(parse_node)
+        end
+      end
+
+      # AST node for HasNamespace is a semantic AST.
+      class SemanticHasNamespace < SemanticASTNode
+        def initialize(**properties)
+          super(:has_namespace, [], properties)
+        end
+
+        def match(identifier, _)
+          # FIXME: Implement :namespace property assignment to AST.
+          return success(identifier)
+          if identifier.respond_to?(:namespace)
+            success(identifier)
+          else
+            failure(identifier)
+          end
+        end
+      end
+
+      # AST node for NamespaceOf is a semantic AST.
+      class SemanticNamespaceOf < SemanticASTNode
+        def initialize(namespaces, **properties)
+          super(:namespace_of, namespaces, properties)
+        end
+
+        def match(identifier, _)
+          # FIXME: Implement :namespace property assignment to AST.
+          return success(identifier)
+          return failure(identifier) unless identifier.respond_to?(:namespace)
+          input_namespace = identifier.namespace
+          return failure(identifier) if input_namespace.nil?
+
+          namespace_set = children
+          if namespace_set.any? { |i| i == :* || i == input_namespace }
+            success(identifier)
+          else
+            failure(identifier)
+          end
+        end
+      end
+
+      # AST node for HasEncoding is a semantic AST.
+      class SemanticHasEncoding < SemanticASTNode
+        def initialize(**properties)
+          super(:has_encoding, [], properties)
+        end
+
+        def match(value_type, _)
+          # FIXME: Implement :encoding property assignment to AST.
+          return success(value_type)
+          if value_type.respond_to?(:encoding)
+            success(value_type)
+          else
+            failure(value_type)
+          end
+        end
+      end
+
+      # AST node for EncodingOf is a semantic AST.
+      class SemanticEncodingOf < SemanticASTNode
+        def initialize(encodings, **properties)
+          super(:encoding_of, encodings, properties)
+        end
+
+        def match(value_type, _)
+          # FIXME: Implement :encoding property assignment to AST.
+          return success(value_type)
+          encoding_set = children
+          return success(value_type) if encoding_set.include?(:*)
+
+          return failure(value_type) unless value_type.respond_to?(:encoding)
+
+          input_encoding = value_type.encoding
+          return failure(value_type) if input_encoding.nil?
+
+          if encoding_set.include?(input_encoding)
+            success(value_type)
+          else
+            failure(value_type)
+          end
+        end
+      end
+
+      # AST node for FunctionOf is a semantic AST.
+      class SemanticFunctionOf < SemanticASTNode
+        def initialize(functions, **properties)
+          super(:function_of, functions, properties)
+        end
+
+        def functions
+          children
+        end
+
+        def match(identifier, spec)
+          return success(identifier) if functions.include?(:*)
+
+          function = spec.function(identifier.children[0].to_sym)
+          if functions.include?(function)
+            success(identifier)
+          else
+            failure(identifier)
+          end
+        end
+      end
+
+      # AST node for ReturnTypeOf is a semantic AST.
+      class SemanticReturnTypeOf < SemanticASTNode
+        def initialize(return_types, **properties)
+          super(:return_type_of, return_types, properties)
+        end
+
+        def return_types
+          children
+        end
+
+        def match(identifier, spec)
+          return success(identifier) if return_types.include?(:*)
+
+          fx_return = spec.function(identifier.children[0].to_sym).return_type
+          if return_types.any? { |rt| fx_return <= rt }
+            success(identifier)
+          else
+            failure(identifier)
+          end
+        end
+      end
+
+      # AST node for ValueType is a semantic AST.
+      class SemanticValueType < SemanticASTNode
+        TYPES = [
+          BELParser::Parsers::AST::Identifier.ast_type,
+          BELParser::Parsers::AST::String.ast_type
+        ].freeze
+
+        def initialize(children = [], **properties)
+          super(:value_type, children, properties)
+        end
+
+        def terminal?
+          true
+        end
+
+        def value_patterns
+          children
+        end
+
+        def match(value_type, spec)
+          return failure(value_type) unless TYPES.include?(value_type.type)
+
+          value_results = value_patterns.map do |pattern|
+            pattern.match(value_type, spec)
+          end
+
+          failure_result = value_results.flatten.find(&:failure?)
+
+          if failure_result
+            [failure(value_type), failure_result]
+          else
+            value_results.unshift(success(value_type))
+          end
+        end
+      end
+
+      # AST node for CovalentModificationOf is a semantic AST.
+      class SemanticCovalentModificationOf < SemanticASTNode
+        def initialize(covalent_mod_types, **properties)
+          properties[:hashed] = Hash[covalent_mod_types.map { |t| [t, true] }]
+          super(:covalent_modification_of, covalent_mod_types, properties)
+        end
+
+        def covalent_mod_types
+          children
+        end
+
+        def match(value_type, _)
+          string_literal_sym = value_type.children[0].to_sym
+          return success(value_type) if @hashed[:*]
+
+          if @hashed.key?(string_literal_sym)
+            success(value_type)
+          else
+            failure(value_type)
+          end
+        end
+      end
+
+      # AST node for AminoAcidOf is a semantic AST.
+      class SemanticAminoAcidOf < SemanticASTNode
+        def initialize(amino_acids, **properties)
+          properties[:hashed] = Hash[amino_acids.map { |t| [t, true] }]
+          super(:amino_acid_of, amino_acids, properties)
+        end
+
+        def amino_acids
+          children
+        end
+
+        def match(value_type, _)
+          string_literal_sym = value_type.children[0].to_sym
+          return success(value_type) if @hashed[:*]
+
+          if @hashed.key?(string_literal_sym)
+            success(value_type)
+          else
+            failure(value_type)
+          end
+        end
+      end
+
+      # AST node for IsAminoAcidRange is a semantic AST.
+      class SemanticIsAminoAcidRange < SemanticASTNode
+        START_STOP         = /[1-9][0-9]*_[1-9][0-9]*/
+        UNDETERMINED       = /[1?]_[?*]/
+        UNKNOWN_START_STOP = "?"
+
+        include BELParser::Quoting
+
+        def initialize(**properties)
+          super(:is_amino_acid_range, [], properties)
+        end
+
+        def match(value_type, _)
+          string_literal = unquote(value_type.children[0])
+          case string_literal
+          when START_STOP, UNDETERMINED, UNKNOWN_START_STOP
+            success(value_type)
+          else
+            failure(value_type)
+          end
+        end
+      end
+    end
+  end
+end