Làm thế nào tôi có thể nhận được một mảng lười biếng trong Ruby?

Question

Làm thế nào tôi có thể nhận được một mảng lười biếng trong Ruby?

Trong Haskell, tôi có thể nói về [1..], đây là danh sách vô hạn, được tạo ra khi cần thiết. Tôi cũng có thể làm những việc như iterate (+2) 0, áp dụng bất kỳ chức năng nào mà tôi cung cấp để tạo danh sách lười biếng. Trong trường hợp này, nó sẽ cho tôi tất cả các số chẵn.

Tôi chắc rằng tôi có thể làm những việc như vậy trong Ruby, nhưng dường như không thể giải quyết được.

Answer 1

Với Ruby 1.9, bạn có thể sử dụng lớp Enumerator. Đây là một ví dụ từ các tài liệu:

fib = Enumerator.new { |y| 
    a = b = 1 
    loop { 
     y << a 
     a, b = b, a + b 
    } 
    } 

    p fib.take(10) #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 

Ngoài ra, đây là một thủ thuật rất hay:

Infinity = 1.0/0 

    range = 5..Infinity 
    p range.take(10) #=> [5, 6, 7, 8, 9, 10, 11, 12, 13, 14] 

Cái này chỉ có tác dụng cho các giá trị liên tiếp mặc dù.

Answer 2

Mảng Ruby tự động mở rộng khi cần. Bạn có thể áp dụng các khối cho họ để trả về những thứ như số chẵn.

array = [] 
array.size # => 0 
array[0] # => nil 
array[9999] # => nil 
array << 1 
array.size # => 1 
array << 2 << 3 << 4 
array.size # => 4 

array = (0..9).to_a 
array.select do |e| 
    e % 2 == 0 
end 

# => [0,2,4,6,8] 

Điều này có hữu ích không?

Answer 3

phạm vi Lazy (số tự nhiên):

Inf = 1.0/0.0 
(1..Inf).take(3) #=> [1, 2, 3] 

phạm vi Lazy (số chẵn):

(0..Inf).step(2).take(5) #=> [0, 2, 4, 6, 8] 

Lưu ý, bạn cũng có thể mở rộng Enumerable với một số phương pháp để làm việc với các dãy lười biếng (và vv) thuận tiện hơn:

module Enumerable 
    def lazy_select 
    Enumerator.new do |yielder| 
     each do |obj| 
     yielder.yield(obj) if yield(obj) 
     end 
    end 
    end 
end 

# first 4 even numbers 
(1..Inf).lazy_select { |v| v.even? }.take(4) 

output: 
[2, 4, 6, 8] 

Thông tin thêm tại đây: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

Ngoài ra còn có triển khai của lazy_map, và lazy_select cho lớp Enumerator có thể được tìm thấy ở đây: http://www.michaelharrison.ws/weblog/?p=163

Answer 4

Như tôi đã nói trong ý kiến ​​của tôi, thực hiện một điều như mảng lười biếng sẽ không được hợp lý.

Sử dụng số đếm thay vào đó có thể hoạt động tốt trong một số trường hợp, nhưng khác với danh sách lười biếng ở một số điểm: các phương pháp như bản đồ và bộ lọc sẽ không được đánh giá một cách lười biếng (vì vậy chúng sẽ không hoạt động trên bảng kê vô hạn) được tính một lần không được lưu trữ, vì vậy nếu bạn truy cập một phần tử hai lần, nó được tính hai lần.

Nếu bạn muốn chính xác hành vi của danh sách lười biếng của haskell trong ruby, có một lazylist gem thực hiện danh sách lười biếng.

Answer 5

Gần đây có thể đếm được :: Lười biếng đã được thêm vào thân cây hồng ngọc. Chúng ta sẽ thấy nó trong ruby ​​2.0. Cụ thể:

a = data.lazy.map(&:split).map(&:reverse) 

sẽ không được đánh giá ngay lập tức.
Kết quả là ví dụ của Enumerable :: Lazy, có thể được lười biếng xích thêm nữa.Nếu bạn muốn để có được một kết quả thực tế - sử dụng #to_a, #take(n) (#take bây giờ lười quá, sử dụng #to_a hoặc #force) vv
Nếu bạn muốn biết thêm về chủ đề này và vá C của tôi - xem bài viết trên blog của tôi Ruby 2.0 Enumerable::Lazy

Answer 6

Trong Ruby 2.0.0, chúng đã được giới thiệu phương thức mới "Lười biếng" trong lớp Enumerable.

Bạn có thể kiểm tra các chức năng lười biếng lõi và sử dụng ở đây ..

http://www.ruby-doc.org/core-2.0/Enumerator/Lazy.html
https://github.com/yhara/enumerable-lazy
http://shugomaeda.blogspot.in/2012/03/enumerablelazy-and-its-benefits.html

Answer 7

Điều này sẽ lặp đến vô cùng:

0.step{|i| puts i} 

Điều này sẽ lặp đến vô cùng gấp đôi nhanh:

0.step(nil, 2){|i| puts i} 

Điều này sẽ chuyển đến vô cùng, chỉ khi bạn muốn (kết quả trong một điều tra viên).

table_of_3 = 0.step(nil, 3)