retrlines(self, cmd, callback=None) unbound ftplib.FTP method
    Retrieve data in line mode.  A new port is created for you.

    Args:
      cmd: A RETR, LIST, NLST, or MLSD command.
      callback: An optional single parameter callable that is called
                for each line with the trailing CRLF stripped.
                [default: print_line()]

    Returns:
      The response code.

def ftplines(ftp, filename):
    . . .
    callback = . . .
    ftp.retrlines("RETR " + filename, callback)

for l in ftplines(ftp, "/etc/shadow"):
    . . .

class footp:
    x = ['a', 'd', 'b', 'e', 'c']
    def __init__(self):
    self.it = iter(self.x)
    
    def retrlines(self, cable):
    try:
            cable(self.it.next())
    except StopIteration, e:
        return False
    return True

class ftplines:
    def __init__(self, f):
    self.f = f
    
    def __iter__(self):
    return self
    
    def __assign(self, x):
    self.x = x
    
    def next(self):
    if self.f.retrlines(self.__assign) == False:
        raise StopIteration
    return self.x

ftp = footp()
for l in ftplines(ftp):
    print 'sup /rsdn.dynamic/ ' + l

function linesLike( path, template )
{
  var stream = Stream.openFile(path, "rt");
  if( stream )
     return function() // returning function - generator of strings matching the template
     {
       while(true)
       {
         var line = stream.readln();
         if( typeof line != #string )
            break; // EOF, exit
         if( line like template )  
            return line; // return matching line
       }
       stream.close();
     }
}

for( var line in linesLike("/some/file", "ftp://*") )
   stdout << line << "\n";

function linesOfResponse( cmd )
{
  var lines = [];
  function receiver(line) { lines.push(line); }

  retrlines(cmd, receiver);

  return function() { while(lines.length) return lines.shift(); }
}

for( var line in linesOfResponse( "LIST" ) )
  stdout.printf("%s\n", line);

function linesOfResponse( cmd ) { var lines = []; 
                                  retrlines(cmd, :line: lines.push(line) ); 
                                  return lines; }

for( var line in linesOfResponse( "LIST" ) )
  stdout.printf("%s\n", line);

-- (* lines-like.lua *)
local co = coroutine

-- (* linesLike :: str, str, callback -> thunk *)
local function linesLike(fname,pat,callback)
  return function()
    for line in io.lines(fname) do
      if line:match(pat) then callback(line) end
    end
  end
end

-- (* используем *)
for line in co.wrap(linesLike('lines-like.lua','^loc',co.yield)) do
  print('!!',line)
end

!!    local co = coroutine
!!    local function linesLike(fname,pat,callback)

CS>>function linesOfResponse( cmd ) { var lines = []; 
CS>>                                  retrlines(cmd, :line: lines.push(line) ); 
CS>>                                  return lines; }

CS>>for( var line in linesOfResponse( "LIST" ) )
CS>>  stdout.printf("%s\n", line);
CS>>

retrlines("LIST", :line:{  .... = line;...  });

for( var line in responselines("LIST")) {  .... = line;...  }

for(var line in retrlines("LIST",@)) 
   { ... = line;... }

retrlines("LIST", 
   function(line) { .... = line;...  }
);

retrlines("LIST", :line:{  .... = line;...  });

retrlines("LIST", function(line){  .... = line;...  } );

retrlines(self, cmd, callback=None) unbound ftplib.FTP method
Retrieve data in line mode. A new port is created for you.

Args:
cmd: A RETR, LIST, NLST, or MLSD command.
callback: An optional single parameter callable that is called
for each line with the trailing CRLF stripped.
[default: print_line()]

Returns:
The response code.

retrlines("LIST", 
     function(line)
     {  .... = line;...  } 
  );

for( var line in retrlines("LIST", @ ))
  {  .... = line;...  }

iter = retrlines(ftp...)
l1 = iter.next()
if(l1 == 'a'):
  l2 = iter.next()
  l3 = iter.next()
  doSomething(l2, l3, iter)
else
  doSomething2(iter.next())

switch(iter.next())
...

iter1 = ...
iter2 = ...
try:
   doSomething(iter1.next(), iter2.next())
except StopIteration, e:
  ...