Ovid publiustemp-perl6language2-at-yahoo.com |Perl 6| wrote:
However, the CGI/CGI::Simple example I posted earlier doesn't fulfill
this.  CGI::Simple offers a subset of CGI.pm's functionality and it's
guaranteed to be identical (it doesn't have HTML generation
functionality and the procedural/OO interfaces are clearly split).  I
can usually use the latter in place of the former, but since semantic
meaning isn't attached, restricting me to roles doesn't work. Requiring others to use roles in this case is also too restrictive.

My take on it: If a Perl 6 program declares the function without typing the parameter, you can pass anything without complaint, like with Perl 5, Smalltalk, etc.

If the function were declared to take a CGI object, and you had a CGI::Simple object, and they were not updated to explain the relationship, you would get a type error.

Rather than needing to delete the type from the parameter, or go ahead and re-factor the classes, it is important that it be easy enough to proceed forward in the current situation and get the benefits of typing that have been added so far, without making the rest of the code useless. So, you explicitly say at the point of the call to "make it fit", thus getting the old (run-time method checking) effects without having to back out the type info added thus far.

      sub foo (CGI) { ... }    # you want to use
      my CGI::Simple $x .= new;
      foo($x);    # nope, compile-time error
      foo(shoehorn $x);  # OK, pretty much the same as if you took
# the type off foo's parameter declaration

A next step would be to declare once that it is OK to use CGI::Simple where a CGI is wanted, shoehorning automatically, within the scope of said instruction.
      I declare, CGI::Simple is an allomorph to CGI.
      foo($x);   # OK.

And a better later step in the evolution is for the author of CGI::Simple to explain the overlap in more detail, without having to touch the CGI class (someone else's code), that will improve upon the checking from the default match-them-all-by-name. Shoehorn sees what is missing, and adds adapters with range checks around changed parameter types, but assumes that bark==bark. The custom explanation can relax the checking, add little adapter wedges, and note when the method should not be considered a match.

Also, if you further update foo's declaration to

     sub foo (CGI ::T $p) { ... }

then you can get errors sooner rather than when the missing method is called on $p, and code within foo can incrementally change its own use of CGI to T to further the effect.

That is, there is always an easy way forward.


Reply via email to