Ruby vs. Python comes down to the for loop(softwaredoug.com)

    s = "Me too."

    print(s)

    class Stuff:
      def __init__(self):
        self.a = [1, 2, 3, 4]

      def __iter__(self):
        for item in self.a:
          yield item

    def Stuff():
      a = [1, 2, 3, 4]
      for item in a:
        yield item

    class Stuff:
      def __init__(self):
        self.a = [1, 2, 3, 4]

      def __iter__(self):
        for item in self.a:
          yield item

      def map(self, f):
        for item in self.a:
          yield f(item)

    print(Stuff().map(lambda item: item))

    class Stuff
      attr_reader :list

      def initialize
        @list = [1, 2, 3, 4]
      end
    end

    Stuff.new.list.each { |item| ... }
    Stuff.new.list.map { |item| ... }
    Stuff.new.list.select { |item| ... }

    delegate :each, :map, :select, to: :list

    for (var i : list) {...}

    list.forEach(i -> ...);

    list.forEach {
        ...
    }

  class Stuff
    def initialize
      @a_list = [1, 2, 3, 4]
    end

    def each
      for item in @a_list
        yield item
      end
    end
  end

  for x in y
    x.stuff
    more_stuff
  end

  y.each do |x|
    x.stuff
    more_stuff
  end

  $ txr stuff.tl 
  1
  2
  3
  4

  $ txr stuff-cons-like.tl
  1
  2
  3
  4

  $ cat stuff.tl 
  (defstruct stuff ()
    (vec (vec 1 2 3 4))
    (:method length (me) (len me.vec))
    (:method lambda (me index) [me.vec index])
    (:method set-lambda (me index val) (set [me.vec index] val)))

  (each ((x (new stuff)))
    (prinl x))

  $ cat stuff-cons-like.tl 
  (defstruct stuff ()
    (list (list 1 2 3 4))
    (:method nullify (me) me.list)
    (:method car (me) (car me.list))
    (:method cdr (me) (cdr me.list)))

  (each ((x (new stuff)))
    (prinl x))


  Quit with :quit or Ctrl-D on an empty line. Ctrl-X ? for cheatsheet.
  1> (disassemble (compile-toplevel '(each ((x (new stuff))) (prinl x))))
  ** expr-1:1: warning: new: stuff does not name a struct type
  data:
      0: stuff
  syms:
      0: struct-from-plist
      1: iter-begin
      2: iter-more
      3: iter-step
      4: iter-item
      5: prinl
  code:              ;; manually annotated!
      0: 2001000A gcall t10 0 d0  ;; t10 <- (struct-from-plist 'stuff)
      1: 04000000
      2: 20010009 gcall t9 1 t10  ;; t9 <- (iter-begin t10) ; t9 is iterator
      3: 000A0001
      4: 20010006 gcall t6 2 t9   ;; t6 <- (iter-more t9) ; more items?
      5: 00090002
      6: 3800000F if t6 15        ;; if t6 not nil continue, else goto 15.
      7: 00000006
      8: 2001000A gcall t10 4 t9  ;; t10 <- (iter-item t9) ; get item
      9: 00090004
     10: 20010006 gcall t6 5 t10  ;; t6 <- (prinl t10)
     11: 000A0005
     12: 20010009 gcall t9 3 t9   ;; t9 <- (iter-step t9) ; step iter
     13: 00090003
     14: 34000004 jmp 4           ;; repeat
     15: 10000000 end nil         ;; terminate, yielding nil
  instruction count:
      9
  #<sys:vm-desc: 14fcb80>

  def process
    collection.each do |element|
      return element if condition
    end
  end