def slice(arg, length = (missing_length = true))
      if missing_length
        if arg.is_a?(Range)
          from, to = arg.begin, arg.end
          from += @size if from < 0
          to   += @size if to < 0
          to   += 1     if !arg.exclude_end?
          length = to - from
          length = 0 if length < 0
          return subsequence(from, length)
        else
          return get(arg)
        end
      else
        arg += @size if arg < 0
        return subsequence(arg, length)
      end
    end
def slice(arg, length = (missing_length = true))
      if missing_length
        if arg.is_a?(Range)
          from, to = arg.begin, arg.end
          from += @size if from < 0
          to   += @size if to < 0
          to   += 1     if !arg.exclude_end?
          length = to - from
          length = 0 if length < 0
          return subsequence(from, length)
        else
          return get(arg)
        end
      else
        arg += @size if arg < 0
        return subsequence(arg, length)
      end
    end
Return specific objects from the `Tuple`. All overloads return `nil` if
 the starting index is out of range.

 @overload tuple.slice(index)
   Returns a single object at the given `index`. If `index` is negative,
   count backwards from the end.

   @param index [Integer] The index to retrieve. May be negative.
   @return [Object]
   @example
     t = Erlang::Tuple["A", "B", "C", "D", "E", "F"]
     t[2]  # => "C"
     t[-1] # => "F"
     t[6]  # => nil

 @overload tuple.slice(index, length)
   Return a subtuple starting at `index` and continuing for `length`
   elements or until the end of the `Tuple`, whichever occurs first.

   @param start [Integer] The index to start retrieving elements from. May be
                          negative.
   @param length [Integer] The number of elements to retrieve.
   @return [Tuple]
   @example
     t = Erlang::Tuple["A", "B", "C", "D", "E", "F"]
     t[2, 3]  # => Erlang::Tuple["C", "D", "E"]
     t[-2, 3] # => Erlang::Tuple["E", "F"]
     t[20, 1] # => nil

 @overload tuple.slice(index..end)
   Return a subtuple starting at `index` and continuing to index
   `end` or the end of the `Tuple`, whichever occurs first.

   @param range [Range] The range of indices to retrieve.
   @return [Tuple]
   @example
     t = Erlang::Tuple["A", "B", "C", "D", "E", "F"]
     t[2..3]    # => Erlang::Tuple["C", "D"]
     t[-2..100] # => Erlang::Tuple["E", "F"]
     t[20..21]  # => nil