4 ms·

"Higher Order Perl" is a very good book. I do not believe that any substantial fraction of the things it shows would take anywhere near 20x as many lines of cod

• deleted 13y ago
  [deleted]
• Mithaldu 13y ago
  Not a 20x example, but file handling is one that stems from the implementation of Python's garbage collection. Python does not guarantee garbage collection at scope end. Thus you need code like this: def controlled_execution(callback): set things up try: do something finally: tear things down Or alternatively, slightly obtuse incantations like this: class controlled_execution: def __enter__(self): set things up return thing def __exit__(self, type, value, traceback): tear things down with controlled_execution() as thing: some code Perl makes this much easier by guaranteeing garbage collection of objects that have left scope, even if the scope is left via die() and caught with eval(). If an object leaves scope, its DESTROY method is called immediately, and after that the object is dismantled. Thus objects can carry their teardown around in their class definition (which can be easily modified by overriding or wrapping the method in a new class), and user's need to do nothing whatsoever to ensure the teardown being executed. Thus, file opening and using code for example can look as simple as this and contain zero gotchas and no "you need to understand this to actually know what it does": sub do_a_thing { my $file = io->file(".bashrc"); print $file->slurp; }
  • lloeki 13y ago
    Honest questions since my perl-fu is weak. Since python's file class already implements the with protocol, I don't see how sub do_a_thing { my $file = io->file(".bashrc"); print $file->slurp; } is different from def do_a_thing: with open(".bashrc") as f: print(f.read()) Conversely I don't see how > Thus objects can carry their teardown around in their class definition (which can be easily modified by overriding or wrapping the method in a new class) is any different from implementing the with protocol in the class, which is strictly speaking "carry their teardown around in their class definition"
    • Mithaldu 13y ago
      You answered yourself. What about classes that don't implement the with protocol? In Perl an object is guaranteed to be garbage collected even if it doesn't have a DESTROY method and without requiring any special syntax.
      • lucian1900 13y ago
        All Python objects do get destructed at the end of the scope. The only exception are reference cycles, which get broken by a simple GC. Perl doesn't even have a cycle detector, so cyclic references will never get destructed. Python has a __del__ method that will be called on destruction, but is not guaranteed to be called in the case of cycles. That's what the with statement solves, guaranteeing destruction at the end of the block. It's common to have both __del__ and __exit__ call the same thing.
        • Mithaldu 13y ago
          They get destructed AFTER end of scope, not AT end of scope, regardless of the existence of cycles. See: http://eli.thegreenplace.net/2009/06/12/safely-using-destructors-in-python/ http://eli.thegreenplace.net/2009/06/12/safely-using-destruc...