Class: Enumerator::Lazy

Inherits:

Enumerator

• Object
• Enumerator
• Enumerator::Lazy

Defined in:

opal/opal/corelib/enumerator.rb

Defined Under Namespace

Classes: StopLazyError

Instance Method Summary

• #collect(&block) ⇒ Object (also: #map)
• #collect_concat(&block) ⇒ Object (also: #flat_map)
• #drop(n) ⇒ Object
• #drop_while(&block) ⇒ Object
• #enum_for(method = :each, *args, &block) ⇒ Object (also: #to_enum)
• #find_all(&block) ⇒ Object (also: #select)
• #grep(pattern, &block) ⇒ Object
• #initialize(object, size = nil, &block) ⇒ Lazy constructor

  A new instance of Lazy.

• #inspect ⇒ Object
• #lazy ⇒ Object
• #reject(&block) ⇒ Object
• #take(n) ⇒ Object
• #take_while(&block) ⇒ Object

Methods inherited from Enumerator

#each, for, #size, #with_index

Methods included from Enumerable

#all?, #any?, #chunk, #count, #cycle, #detect, #each_cons, #each_entry, #each_slice, #each_with_index, #each_with_object, #entries, #find_index, #first, #group_by, #include?, #inject, #max, #max_by, #min, #min_by, #minmax, #minmax_by, #none?, #one?, #partition, #reverse_each, #slice_before, #sort, #sort_by, #zip

Constructor Details

#initialize(object, size = nil, &block) ⇒ Lazy

Returns a new instance of Lazy

# File 'opal/opal/corelib/enumerator.rb', line 151

def initialize(object, size = nil, &block)
  unless block_given?
    raise ArgumentError, 'tried to call lazy new without a block'
  end

  @enumerator = object

  super size do |yielder, *each_args|
    begin
      object.each(*each_args) {|*args|
        %x{
          args.unshift(#{yielder});

          if ($opal.$yieldX(block, args) === $breaker) {
            return $breaker;
          }
        }
      }
    rescue Exception
      nil
    end
  end
end

Instance Method Details

#collect(&block) ⇒ Object Also known as: map

# File 'opal/opal/corelib/enumerator.rb', line 181

def collect(&block)
  unless block
    raise ArgumentError, 'tried to call lazy map without a block'
  end

  Lazy.new(self, enumerator_size) {|enum, *args|
    %x{
      var value = $opal.$yieldX(block, args);

      if (value === $breaker) {
        return $breaker;
      }

      #{enum.yield `value`};
    }
  }
end

#collect_concat(&block) ⇒ Object Also known as: flat_map

# File 'opal/opal/corelib/enumerator.rb', line 199

def collect_concat(&block)
  unless block
    raise ArgumentError, 'tried to call lazy map without a block'
  end

  Lazy.new(self, nil) {|enum, *args|
    %x{
      var value = $opal.$yieldX(block, args);

      if (value === $breaker) {
        return $breaker;
      }

      if (#{`value`.respond_to? :force} && #{`value`.respond_to? :each}) {
        #{`value`.each { |v| enum.yield v }}
      }
      else {
        var array = #{Opal.try_convert `value`, Array, :to_ary};

        if (array === nil) {
          #{enum.yield `value`};
        }
        else {
          #{`value`.each { |v| enum.yield v }};
        }
      }
    }
  }
end

#drop(n) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 229

def drop(n)
  n = Opal.coerce_to n, Integer, :to_int

  if n < 0
    raise ArgumentError, "attempt to drop negative size"
  end

  current_size = enumerator_size
  set_size     = if Integer === current_size
    n < current_size ? n : current_size
  else
    current_size
  end

  dropped = 0
  Lazy.new(self, set_size) {|enum, *args|
    if dropped < n
      dropped += 1
    else
      enum.yield(*args)
    end
  }
end

#drop_while(&block) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 253

def drop_while(&block)
  unless block
    raise ArgumentError, 'tried to call lazy drop_while without a block'
  end

  succeeding = true
  Lazy.new(self, nil) {|enum, *args|
    if succeeding
      %x{
        var value = $opal.$yieldX(block, args);

        if (value === $breaker) {
          return $breaker;
        }

        if (#{Opal.falsy?(`value`)}) {
          succeeding = false;

          #{enum.yield(*args)};
        }
      }
    else
      enum.yield(*args)
    end
  }
end

#enum_for(method = :each, *args, &block) ⇒ Object Also known as: to_enum

# File 'opal/opal/corelib/enumerator.rb', line 280

def enum_for(method = :each, *args, &block)
  self.class.for(self, method, *args, &block)
end

#find_all(&block) ⇒ Object Also known as: select

# File 'opal/opal/corelib/enumerator.rb', line 284

def find_all(&block)
  unless block
    raise ArgumentError, 'tried to call lazy select without a block'
  end

  Lazy.new(self, nil) {|enum, *args|
    %x{
      var value = $opal.$yieldX(block, args);

      if (value === $breaker) {
        return $breaker;
      }

      if (#{Opal.truthy?(`value`)}) {
        #{enum.yield(*args)};
      }
    }
  }
end

#grep(pattern, &block) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 306

def grep(pattern, &block)
  if block
    Lazy.new(self, nil) {|enum, *args|
      %x{
        var param = #{Opal.destructure(args)},
            value = #{pattern === `param`};

        if (#{Opal.truthy?(`value`)}) {
          value = $opal.$yield1(block, param);

          if (value === $breaker) {
            return $breaker;
          }

          #{enum.yield `$opal.$yield1(block, param)`};
        }
      }
    }
  else
    Lazy.new(self, nil) {|enum, *args|
      %x{
        var param = #{Opal.destructure(args)},
            value = #{pattern === `param`};

        if (#{Opal.truthy?(`value`)}) {
          #{enum.yield `param`};
        }
      }
    }
  end
end

#inspect ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 412

def inspect
  "#<#{self.class.name}: #{@enumerator.inspect}>"
end

#lazy ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 177

def lazy
  self
end

#reject(&block) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 342

def reject(&block)
  unless block
    raise ArgumentError, 'tried to call lazy reject without a block'
  end

  Lazy.new(self, nil) {|enum, *args|
    %x{
      var value = $opal.$yieldX(block, args);

      if (value === $breaker) {
        return $breaker;
      }

      if (#{Opal.falsy?(`value`)}) {
        #{enum.yield(*args)};
      }
    }
  }
end

#take(n) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 362

def take(n)
  n = Opal.coerce_to n, Integer, :to_int

  if n < 0
    raise ArgumentError, "attempt to take negative size"
  end

  current_size = enumerator_size
  set_size     = if Integer === current_size
    n < current_size ? n : current_size
  else
    current_size
  end

  taken = 0
  Lazy.new(self, set_size) {|enum, *args|
    if taken < n
      enum.yield(*args)
      taken += 1
    else
      raise StopLazyError
    end
  }
end

#take_while(&block) ⇒ Object

# File 'opal/opal/corelib/enumerator.rb', line 387

def take_while(&block)
  unless block
    raise ArgumentError, 'tried to call lazy take_while without a block'
  end

  Lazy.new(self, nil) {|enum, *args|
    %x{
      var value = $opal.$yieldX(block, args);

      if (value === $breaker) {
        return $breaker;
      }

      if (#{Opal.truthy?(`value`)}) {
        #{enum.yield(*args)};
      }
      else {
        #{raise StopLazyError};
      }
    }
  }
end