Joe Gottman writes: > I just reread the section of A6 about currying, and I have several > questions about it. > > 1) Suppose I have a function like the following: > sub foo($param, @param) {...} > where the parameter names differ only by their sigils. Is it legal > for me to type > &foo.assuming('$param' => 1) > in order to disambiguate the parameter names?
Yeah, but I think the scalar would get it anyway. This is the same way $0 works. So 'foo' and '$foo' refer to the same thing, and '@foo' and '%foo' disambiguate. Though, if $param weren't there, 'param' => [1] would assign to @param... which is not, IIRC, how $0 works. I think it'd be a good idea to unify the two behaviors, probably in favor of the named parameter style (where it will pick the defined one, and the scalar only if it's ambiguous). > 2) Often, if you are working with a code reference instead of an actual > sub, you might not know the names of all the parameters. In this case, > would it be legal to curry by parameter position instead of parameter name? > > sub setFirstToOne(&block) { > &block.assuming( 0 => 1); #I am assuming 0-based parameter lists > } That would definitely be a nice feature. > Another advantage of currying by position is that it might allow you to set > the first few elements of a slurpy array. > > sub foo(* @params) {...} > my $bar = foo.assuming(0 => "hello"); > $bar.("world"); # Calls foo("hello", "world") That would require a bit more under-the-hood work, but I think that's okay. > 3) Currying binds a function parameter to a value? Is there any way to > bind a function parameter to a variable? Consider the following code: > > sub printNum(int $x) {print "$x\n";} > my $foo = 0; > my $vindaloo = &printNum(int).assuming(x => $foo); #currying > ++$foo; > $vindaloo.(); > > This code prints 0, not 1, because the currying binds the parameter to > the value $foo had when the currying occurred, not the value it had when the > curried function was called. It would be nice if there were some way to > curry so that a parameter is bound to a variable reference. There is. Best not to worry .assuming with details of references. Do it with a scratchpad: sub printNum($x) { print "$x\n" } my $foo = 0; my $vindaloo = { printNum($foo) }; ++$foo; $vindaloo(); # Prints 1 There's still those issues of getting $vindaloo's signature exactly right for complex cases. In any case, I don't think .bind would be hard to write. Luke > This would probably have to be a different method than assuming. > Maybe something like &printNum(int).bind(x => \$foo) > > > Joe Gottman > > >