On Wed, Apr 06, 2005 at 10:07:33AM -0600, Luke Palmer wrote:
: Thomas Sandla▀ writes:
: > Larry Wall wrote:
: > >Yes.  It should complain that = is not a valid type signature.
: > >Any &foo (or &foo:<...>) followed by <...> should be parsed as a single
: > >term selecting the function that MMD would dispatch to given that
: > >type signature.
: > 
: > And I guess it's not allowed to have interspersed whitespace unless
: > one uses the dot forms? And my interpretation as operator <=> needs
: > the whitespace OTOH.
: > 
: > &infix <=> <some words>  # my interpretation of the typo
: > 
: > &foo  .<signature>  # OK?
: 
: I'm beginning to think that angle brackets are too overloaded here.  The
: qw angles are really growing on me, and now whenever I see angles I see
: a quoting construct.  Putting something that's not quoted inside them
: seems like it will be visually confusing (and just thing what vim will
: have to do to tell the difference).

Yes, same here.  But it's not an expression either.  It's a signature,
and the only other delimiter we have prior art for is (Str $s, Int $i)
in sub declarations.  But we can't use bare parens for obvious reasons
that were not obvious enough to keep me from falling into the trap
in at least one Apocalypse.  :-)

: We could make it one, so that it's:
: 
:     &infix:<+>.<Complex Complex>
: 
: Instead of with commas, but then you can't attach anything special to
: the types, so I think it's best if we just ditch <> altogether for this
: purpose.
: 
: But then what replaces it?    The first thing that came to me was just
: to use a method:
: 
:     &infix:<+>.variant(Complex, Complex);
: 
: The method approach has some other advantages, like the ability to add
: another method:
: 
:     my $code = &infix:<+>.dispatch($a, $b);  # what code would we call
:                                              # with $a and $b?
: 
: Or we could use square brackets, since square bracketing types just
: selects a type, but doesn't do anything to it.  But especially because
: this only applies to multimethods, I like the method approach the best.

But a method *evaluates* its arguments, which you generally don't want
in this case.  Sometimes you do, so it's fine to have a method behind
whatever syntax we choose, but it can't very well be the default
without some kind of sig quoting.  I think it's time to break out
the colon again and use something like:

    &infix:<+>:(Complex, Complex);

or

    &foo:(Str,Int)

for ordinary functions.  If it gets really popular people might
even start writing:

    sub foo :(Str,Int) {...}

Larry

Reply via email to