puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/pops/binder/injector.rb

@@ -205,7 +205,7 @@ class Puppet::Pops::Binder::Injector
   # @overload lookup(scope, type, name = '')
   #   (see #lookup_type)
   #   @param scope [Puppet::Parser::Scope] the scope to use for evaluation
-  #   @param type [Puppet::Pops::Types::PObjectType] the type of what to lookup
+  #   @param type [Puppet::Pops::Types::PAnyType] the type of what to lookup
   #   @param name [String] the name to use, defaults to empty string (for unnamed)
   #
   # @overload lookup(scope, name)
@@ -231,7 +231,7 @@ class Puppet::Pops::Binder::Injector
   # Creates a key for the type/name combination using a KeyFactory. Specialization of the Data type are transformed
   # to a Data key, and the result is type checked to conform with the given key.
   #
-  # @param type [Puppet::Pops::Types::PObjectType] the type to lookup as defined by Puppet::Pops::Types::TypeFactory
+  # @param type [Puppet::Pops::Types::PAnyType] the type to lookup as defined by Puppet::Pops::Types::TypeFactory
   # @param name [String] the (optional for non `Data` types) name of the entry to lookup.
   #   The name may be an empty String (the default), but not nil. The name is required for lookup for subtypes of
   #   `Data`.
@@ -275,7 +275,7 @@ class Puppet::Pops::Binder::Injector
   # @overload lookup_producer(scope, type, name = '')
   #   (see #lookup_type)
   #   @param scope [Puppet::Parser::Scope] the scope to use for evaluation
-  #   @param type [Puppet::Pops::Types::PObjectType], the type of what to lookup
+  #   @param type [Puppet::Pops::Types::PAnyType], the type of what to lookup
   #   @param name [String], the name to use, defaults to empty string (for unnamed)
   #
   # @overload lookup_producer(scope, name)
@@ -363,9 +363,9 @@ module Private
       if block
         case block.arity
         when 1
-          block.call(:undef)
+          block.call(nil)
         when 2
-          block.call(scope, :undef)
+          block.call(scope, nil)
         else
           raise ArgumentError, "The block should have arity 1 or 2"
         end
@@ -441,7 +441,7 @@ module Private
 
       val = case args[ 0 ]
 
-      when Puppet::Pops::Types::PObjectType
+      when Puppet::Pops::Types::PAnyType
         lookup_type(scope, *args)
 
       when String
@@ -562,7 +562,7 @@ module Private
     #
     def assistable_injected_class(key)
       kt = key_factory.get_type(key)
-      return nil unless kt.is_a?(Puppet::Pops::Types::PRubyType) && !key_factory.is_named?(key)
+      return nil unless kt.is_a?(Puppet::Pops::Types::PRuntimeType) && kt.runtime == :ruby && !key_factory.is_named?(key)
       type_calculator.injectable_class(kt)
     end
 
@@ -570,7 +570,7 @@ module Private
       raise ArgumentError, "lookup_producer should be called with two or three arguments, got: #{args.size()+1}" unless args.size <= 2
 
       p = case args[ 0 ]
-      when Puppet::Pops::Types::PObjectType
+      when Puppet::Pops::Types::PAnyType
         lookup_producer_type(scope, *args)
 
       when String
@@ -634,7 +634,7 @@ module Private
 
     # @api private
     def transform(producer_descriptor, scope, entry)
-      @@transform_visitor.visit_this(self, producer_descriptor, scope, entry)
+      @@transform_visitor.visit_this_2(self, producer_descriptor, scope, entry)
     end
 
     # Returns the produced instance

data/lib/puppet/pops/binder/key_factory.rb

@@ -48,13 +48,13 @@ class Puppet::Pops::Binder::KeyFactory
 
   # @api public
   def is_data?(key)
-    return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PObjectType)
+    return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PAnyType)
     type_calculator.assignable?(type_calculator.data(), key[0])
   end
 
   # @api public
   def is_ruby?(key)
-    return key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PRubyType)
+    key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PRuntimeType) && key[0].runtime == :ruby
   end
 
   # Returns the type of the key

data/lib/puppet/pops/binder/lookup.rb

@@ -78,7 +78,7 @@ class Puppet::Pops::Binder::Lookup
     end
 
     # unless a type is already given (future case), parse the type (or default 'Data'), fails if invalid type is given
-    unless options[:type].is_a?(Puppet::Pops::Types::PAbstractType)
+    unless options[:type].is_a?(Puppet::Pops::Types::PAnyType)
       options[:type] = type_parser.parse(options[:type] || 'Data')
     end
 
@@ -159,17 +159,21 @@ class Puppet::Pops::Binder::Lookup
       result_with_name[1]
     end
 
+    # If a block is given it is called with :undef passed as 'nil' since the lookup function
+    # is available from 3x with --binder turned on, and the evaluation is always 4x.
+    # TODO PUPPET4: Simply pass the value
+    #
     result = if pblock = options[:pblock]
       result2 = case pblock.parameter_count
       when 1
-        pblock.call(scope, nil_as_undef(result))
+        pblock.call(scope, undef_as_nil(result))
       when 2
-        pblock.call(scope, result_with_name[ 0 ], nil_as_undef(result))
+        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result))
       else
-        pblock.call(scope, result_with_name[ 0 ], nil_as_undef(result), nil_as_undef(options[ :default ]))
+        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result), undef_as_nil(options[ :default ]))
       end
 
-      # if the given result was returned, there is not need to type-check it again
+      # if the given result was returned, there is no need to type-check it again
       if !result2.equal?(result)
         t = type_calculator.infer(undef_as_nil(result2))
         if !type_calculator.assignable?(type, t)
@@ -185,7 +189,11 @@ class Puppet::Pops::Binder::Lookup
     if is_nil_or_undef?(result) && !options[:accept_undef]
       fail_lookup(names)
     else
-      nil_as_undef(result)
+      # Since the function may be used without future parser being in effect, nil is not handled in a good
+      # way, and should instead be turned into :undef.
+      # TODO PUPPET4: Simply return the result
+      #
+      Puppet[:parser] == 'future' ? result : nil_as_undef(result)
     end
   end
 end

data/lib/puppet/pops/binder/producers.rb

@@ -62,8 +62,7 @@ module Puppet::Pops::Binder::Producers
         else
           raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Puppet::Pops::Model::LambdaExpression)
           raise ArgumentError, "Transformer lambda must take one argument; value." unless transformer_lambda.parameters.size() == 1
-          # NOTE: This depends on Puppet 3 AST Lambda
-          @transformer = Puppet::Pops::Model::AstTransformer.new().transform(transformer_lambda)
+          @transformer = Puppet::Pops::Parser::EvaluatingParser.new.closure(transformer_lambda, scope)
         end
       end
     end
@@ -111,7 +110,6 @@ module Puppet::Pops::Binder::Producers
     #
     def do_transformation(scope, produced_value)
       return produced_value unless transformer
-      produced_value = :undef if produced_value.nil?
       transformer.call(scope, produced_value)
     end
   end
@@ -299,14 +297,13 @@ module Puppet::Pops::Binder::Producers
     #
     def initialize(injector, binding, scope, options)
       super
-      expr = options[:expression]
-      raise ArgumentError, "Option 'expression' must be given to an EvaluatingProducer." unless expr
-      @expression = Puppet::Pops::Model::AstTransformer.new().transform(expr)
+      @expression = options[:expression]
+      raise ArgumentError, "Option 'expression' must be given to an EvaluatingProducer." unless @expression
     end
 
     # @api private
     def internal_produce(scope)
-      expression.evaluate(scope)
+      Puppet::Pops::Parser::EvaluatingParser.new.evaluate(scope, expression)
     end
   end
 
@@ -323,7 +320,7 @@ module Puppet::Pops::Binder::Producers
     # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
     # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup
+    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
     # @option options [String] :name ('') The name to lookup
     # @api public
     #
@@ -352,9 +349,9 @@ module Puppet::Pops::Binder::Producers
     # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
     # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
     # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
-    # @option options [Puppet::Pops::Types::PObjectType] :type The type to lookup
+    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
     # @option options [String] :name ('') The name to lookup
-    # @option options [Puppet::Pops::Types::PObjectType] :key The key to lookup in the hash
+    # @option options [Puppet::Pops::Types::PAnyType] :key The key to lookup in the hash
     # @api public
     #
     def initialize(injector, binder, scope, options)
@@ -527,8 +524,8 @@ module Puppet::Pops::Binder::Producers
       @contributions_key = injector.key_factory.multibind_contributions(binding.id)
     end
 
-    # @param expected [Array<Puppet::Pops::Types::PObjectType>, Puppet::Pops::Types::PObjectType] expected type or types
-    # @param actual [Object, Puppet::Pops::Types::PObjectType> the actual value (or its type)
+    # @param expected [Array<Puppet::Pops::Types::PAnyType>, Puppet::Pops::Types::PAnyType] expected type or types
+    # @param actual [Object, Puppet::Pops::Types::PAnyType> the actual value (or its type)
     # @return [String] a formatted string for inclusion as detail in an error message
     # @api private
     #

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -9,6 +9,7 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   Issues = Puppet::Pops::Issues
   TYPEFACTORY = Puppet::Pops::Types::TypeFactory
+  EMPTY_STRING = ''.freeze
 
   attr_reader :semantic
 
@@ -44,7 +45,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
       # if k1 is outside, a length of 1 always produces an empty string
       if k1 < 0
-        ''
+        EMPTY_STRING
       else
         o[ k1, k2 ]
       end
@@ -65,7 +66,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
     # Specified as: an index outside of range, or empty result == empty string
-    (result.nil? || result.empty?) ? '' : result
+    (result.nil? || result.empty?) ? EMPTY_STRING : result
   end
 
   # Parameterizes a PRegexp Type with a pattern string or r ruby egexp
@@ -124,21 +125,10 @@ class Puppet::Pops::Evaluator::AccessOperator
   #   Does not flatten its keys to enable looking up with a structure
   #
   def access_Hash(o, scope, keys)
-    # Look up key in hash, if key is nil or :undef, try alternate form before giving up.
-    # This makes :undef and nil "be the same key". (The alternative is to always only write one or the other
-    # in all hashes - that is much harder to guarantee since the Hash is a regular Ruby hash.
-    #
+    # Look up key in hash, if key is nil, try alternate form (:undef) before giving up.
+    # This is done because the hash may have been produced by 3x logic and may thus contain :undef.
     result = keys.collect do |k|
-      o.fetch(k) do |key|
-        case key
-        when nil
-          o[:undef]
-        when :undef
-          o[:nil]
-        else
-          nil
-        end
-      end
+      o.fetch(k) { |key| key.nil? ? o[:undef] : nil }
     end
     case result.size
     when 0
@@ -163,7 +153,7 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAbstractType)
+    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAnyType)
     Puppet::Pops::Types::TypeFactory.variant(*keys)
   end
 
@@ -176,7 +166,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       size_type = TYPEFACTORY.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
-    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAbstractType)
+    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAnyType)
     t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
     # set size type, or nil for default (exactly 1)
     t.size_type = size_type
@@ -237,7 +227,7 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   def bad_key_type_name(actual)
     case actual
-    when nil, :undef
+    when nil
       'Undef'
     when :default
       'Default'
@@ -264,7 +254,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAbstractType)
+      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::POptionalType.new()
@@ -278,7 +268,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      unless keys[0].is_a?(Puppet::Pops::Types::PAbstractType)
+      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::PType.new()
@@ -289,11 +279,11 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
   end
 
-  def access_PRubyType(o, scope, keys)
+  def access_PRuntimeType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, 1, String)
-    # create ruby type based on name of class, not inference of key's type
-    Puppet::Pops::Types::TypeFactory.ruby_type(keys[0])
+    assert_keys(keys, o, 2, 2, String, String)
+    # create runtime type based on runtime and name of class, (not inference of key's type)
+    Puppet::Pops::Types::TypeFactory.runtime(*keys)
   end
 
   def access_PIntegerType(o, scope, keys)
@@ -335,7 +325,7 @@ class Puppet::Pops::Evaluator::AccessOperator
   def access_PHashType(o, scope, keys)
     keys.flatten!
     keys[0,2].each_with_index do |k, index|
-      unless k.is_a?(Puppet::Pops::Types::PAbstractType)
+      unless k.is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
@@ -403,7 +393,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
-    unless keys[0].is_a?(Puppet::Pops::Types::PAbstractType)
+    unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
     end
     result = Puppet::Pops::Types::PArrayType.new()
@@ -429,6 +419,17 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
   end
 
+  # A Puppet::Resource represents either just a type (no title), or is a fully qualified type/title.
+  #
+  def access_Resource(o, scope, keys)
+    # To access a Puppet::Resource as if it was a PResourceType, simply infer it, and take the type of
+    # the parameterized meta type (i.e. Type[Resource[the_resource_type, the_resource_title]])
+    t = Puppet::Pops::Types::TypeCalculator.infer(o).type
+    # must map "undefined title" from resource to nil
+    t.title = nil if t.title == EMPTY_STRING
+    access(t, scope, *keys)
+  end
+
   # A Resource can create a new more specific Resource type, and/or an array of resource types
   # If the given type has title set, it can not be specified further.
   # @example
@@ -464,6 +465,11 @@ class Puppet::Pops::Evaluator::AccessOperator
       fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => type_name.class})
     end
 
+    # type name must conform
+    if type_name !~ Puppet::Pops::Patterns::CLASSREF
+      fail(Puppet::Pops::Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
+    end
+
     # The result is an array if multiple titles are given, or if titles are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
@@ -503,7 +509,7 @@ class Puppet::Pops::Evaluator::AccessOperator
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         type_to_report = case t
-        when nil, :undef
+        when nil
           'Undef'
         when :default
           'Default'
@@ -569,7 +575,7 @@ class Puppet::Pops::Evaluator::AccessOperator
         if name =~ Puppet::Pops::Patterns::NAME
           ctype = Puppet::Pops::Types::PHostClassType.new()
           # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
-          ctype.class_name = name.sub(/^::/, '')
+          ctype.class_name = name.sub(/^::/, EMPTY_STRING)
           ctype
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})

data/lib/puppet/pops/evaluator/callable_mismatch_describer.rb

@@ -0,0 +1,175 @@
+# @api private
+module Puppet::Pops::Evaluator::CallableMismatchDescriber
+  # Produces a string with the difference between the given arguments and support signature(s).
+  #
+  # @param name [String] The name of the callable to describe
+  # @param args_type [Puppet::Pops::Types::Tuple] The tuple of argument types.
+  # @param supported_signatures [Array<Puppet::Pops::Types::Callable>] The available signatures that were available for calling.
+  #
+  # @api private
+  def self.diff_string(name, args_type, supported_signatures)
+    result = [ ]
+    if supported_signatures.size == 1
+      signature = supported_signatures[0]
+      params_type  = signature.type.param_types
+      block_type   = signature.type.block_type
+      params_names = signature.parameter_names
+      result << "expected:\n  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
+    else
+      result << "expected one of:\n"
+      result << supported_signatures.map do |signature|
+        params_type = signature.type.param_types
+        "  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
+      end.join("\n")
+    end
+
+    result << "\nactual:\n  #{name}(#{arg_types_string(args_type)}) - #{arg_count_string(args_type)}"
+
+    result.join('')
+  end
+
+  private
+
+  # Produces a string for the signature(s)
+  #
+  # @api private
+  def self.signature_string(signature)
+    param_types  = signature.type.param_types
+    block_type   = signature.type.block_type
+    param_names = signature.parameter_names
+
+    from, to = param_types.size_range
+    if from == 0 && to == 0
+      # No parameters function
+      return ''
+    end
+
+    required_count = from
+    # there may be more names than there are types, and count needs to be subtracted from the count
+    # to make it correct for the last named element
+    adjust = max(0, param_names.size() -1)
+    last_range = [max(0, (from - adjust)), (to - adjust)]
+
+    types =
+    case param_types
+    when Puppet::Pops::Types::PTupleType
+      param_types.types
+    when Puppet::Pops::Types::PArrayType
+      [ param_types.element_type ]
+    end
+    tc = Puppet::Pops::Types::TypeCalculator
+
+    # join type with names (types are always present, names are optional)
+    # separate entries with comma
+    #
+    result =
+    if param_names.empty?
+      types.each_with_index.map {|t, index| tc.string(t) + opt_value_indicator(index, required_count, 0) }
+    else
+      limit = param_names.size
+      result = param_names.each_with_index.map do |name, index|
+        [tc.string(types[index] || types[-1]), name].join(' ') + opt_value_indicator(index, required_count, limit)
+      end
+    end.join(', ')
+
+    # Add {from, to} for the last type
+    # This works for both Array and Tuple since it describes the allowed count of the "last" type element
+    # for both. It does not show anything when the range is {1,1}.
+    #
+    result += range_string(last_range)
+
+    # If there is a block, include it with its own optional count {0,1}
+    case signature.type.block_type
+    when Puppet::Pops::Types::POptionalType
+      result << ', ' unless result == ''
+      result << "#{tc.string(signature.type.block_type.optional_type)} #{signature.block_name} {0,1}"
+    when Puppet::Pops::Types::PCallableType
+      result << ', ' unless result == ''
+      result << "#{tc.string(signature.type.block_type)} #{signature.block_name}"
+    when NilClass
+      # nothing
+    end
+    result
+  end
+
+  # Why oh why Ruby do you not have a standard Math.max ?
+  # @api private
+  def self.max(a, b)
+    a >= b ? a : b
+  end
+
+  # @api private
+  def self.opt_value_indicator(index, required_count, limit)
+    count = index + 1
+    (count > required_count && count < limit) ? '?' : ''
+  end
+
+  # @api private
+  def self.arg_count_string(args_type)
+    if args_type.is_a?(Puppet::Pops::Types::PCallableType)
+      size_range = args_type.param_types.size_range # regular parameters
+      adjust_range=
+      case args_type.block_type
+      when Puppet::Pops::Types::POptionalType
+        size_range[1] += 1
+      when Puppet::Pops::Types::PCallableType
+        size_range[0] += 1
+        size_range[1] += 1
+      when NilClass
+        # nothing
+      else
+        raise ArgumentError, "Internal Error, only nil, Callable, and Optional[Callable] supported by Callable block type"
+      end
+    else
+      size_range = args_type.size_range
+    end
+    "arg count #{range_string(size_range, false)}"
+  end
+
+  # @api private
+  def self.arg_types_string(args_type)
+    types =
+    case args_type
+    when Puppet::Pops::Types::PTupleType
+      last_range = args_type.repeat_last_range
+      args_type.types
+    when Puppet::Pops::Types::PArrayType
+      last_range = args_type.size_range
+      [ args_type.element_type ]
+    end
+    # stringify generalized versions or it will display Integer[10,10] for "10", String['the content'] etc.
+    # note that type must be copied since generalize is a mutating operation
+    tc = Puppet::Pops::Types::TypeCalculator
+    result = types.map { |t| tc.string(tc.generalize!(t.copy)) }.join(', ')
+
+    # Add {from, to} for the last type
+    # This works for both Array and Tuple since it describes the allowed count of the "last" type element
+    # for both. It does not show anything when the range is {1,1}.
+    #
+    result += range_string(last_range)
+    result
+  end
+
+  # Formats a range into a string of the form: `{from, to}`
+  #
+  # The following cases are optimized:
+  #
+  #   * from and to are equal => `{from}`
+  #   * from and to are both and 1 and squelch_one == true => `''`
+  #   * from is 0 and to is 1 => `'?'`
+  #   * to is INFINITY => `{from, }`
+  #
+  # @api private
+  def self.range_string(size_range, squelch_one = true)
+    from, to = size_range
+    if from == to
+      (squelch_one && from == 1) ? '' : "{#{from}}"
+    elsif to == Puppet::Pops::Types::INFINITY
+      "{#{from},}"
+    elsif from == 0 && to == 1
+      '?'
+    else
+      "{#{from},#{to}}"
+    end
+  end
+end