Method subsequence has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def subsequence(from, length)
      return nil if from > @node.size || from < 0 || length < 0
      length = @node.size - from if @node.size < from + length
      if length == 0
        if @node.natural_order?

• Read up
  Read up

Method to_ruby has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def to_ruby(obj)
      case obj
      when Hamster::Hash, ::Hash
        obj.each_with_object({}) { |keyval, hash| hash[to_ruby(keyval[0])] = to_ruby(keyval[1]) }
      when Hamster::Vector, ::Array

• Read up
  Read up

Avoid too many return statements within this method.

Open

          return nil if list.empty?

Avoid too many return statements within this method.

Open

        return false unless other.head.eql?(list.head)

Avoid too many return statements within this method.

Open

          return result if bump_counters[]

Method update_root has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def update_root(index, item)
      root, levels = @root, @levels
      while index >= (1 << (BITS_PER_LEVEL * (levels + 1)))
        root = [root].freeze
        levels += 1

• Read up
  Read up

Method union has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def union(other, items = ::Set.new)
      LazyList.new do
        next other._uniq(items) if empty?
        next tail.union(other, items) if items.include?(head)
        Cons.new(head, tail.union(other, items.add(head)))

• Read up
  Read up

Method <=> has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def <=>(other)
      return 0 if self.equal?(other)
      enum1, enum2 = self.to_enum, other.to_enum
      loop do
        item1 = enum1.next

• Read up
  Read up

Method initialize has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def initialize(items=[].freeze)
      items = items.to_a
      if items.size <= 32
        items = items.dup.freeze if !items.frozen?
        @root, @size, @levels = items, items.size, 0

• Read up
  Read up

Method bulk_delete has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

      def bulk_delete(items)
        return self if items.empty?
        if items.size == 1
          catch :not_present do
            return delete(items.first)

• Read up
  Read up

Method insert has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def insert(index, *items)
      if index == 0
        return List.from_enum(items).append(self)
      elsif index > 0
        LazyList.new do

• Read up
  Read up

Method delete_at has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def delete_at(index = @entries.index { |e| e })
      yield(@entries[index]) if block_given?
      if size > 1
        entries = @entries.dup
        child = @children[index]

• Read up
  Read up

Method pop has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def pop
      LazyList.new do
        next self if empty?
        new_size = size - 1
        next Cons.new(head, tail.take(new_size - 1)) if new_size >= 1

• Read up
  Read up

Method take has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def take(number)
      LazyList.new do
        next self if empty?
        next Cons.new(head, tail.take(number - 1)) if number > 0
        EmptyList

• Read up
  Read up

Method permutation has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def permutation(length = size, &block)
      return enum_for(:permutation, length) if not block_given?
      if length == 0
        yield EmptyList
      elsif length == 1

• Read up
  Read up

Method fill has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def fill(object, index = 0, length = nil)
      raise IndexError if index < -@size
      index += @size if index < 0
      length ||= @size - index # to the end of the array, if no length given

• Read up
  Read up

Method flatten has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def flatten
      LazyList.new do
        next self if empty?
        next head.append(tail.flatten) if head.is_a?(List)
        Cons.new(head, tail.flatten)

• Read up
  Read up

Method merge has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def merge(other)
      trie = if block_given?
        other.reduce(@trie) do |trie, (key, value)|
          if entry = trie.get(key)
            trie.put(key, yield(key, entry[1], value))

• Read up
  Read up

Method derive_new_hash has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def derive_new_hash(trie)
      if trie.equal?(@trie)
        self
      elsif trie.empty?
        if @default

• Read up
  Read up

Method initialize has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def initialize(items=[], &block)
      items = items.to_a
      if block
        if block.arity == 1 || block.arity == -1
          comparator = lambda { |a,b| block.call(a) <=> block.call(b) }

• Read up
  Read up