Anonymous user
Talk:Call a function: Difference between revisions
m
→What is using a function in a command context?: reduce indentation
(if an operator is a function, can it be redefined?) |
m (→What is using a function in a command context?: reduce indentation) |
||
| (7 intermediate revisions by 3 users not shown) | |||
Line 26:
:That is the point. In Perl 6 all operators <i>are</i> functions. They can be called in the same way as functions, can be used in the place of functions, and as such are needed to demonstrate a method of invoking a function. Just because operators are <i>generally</i> a separate concept in other languages doesn't make it specifically true in Perl 6. The true name of the binary addition operator is <tt>infix:<+></tt>, and that can be used anywhere any other function name can be used. The fact that the very same routine can also be called as an infix operator does not change the fact that it is fundamentally a function call. And the whole point of this task is to show all the ways you can call a function, not just one particular way that is already well documented in other tasks. So I will resist strongly the suggestion that we pretend one of Perl 6's fundamental unifying principles isn't there, when that is precisely one of the things that makes Perl 6 different from other languages, and should be documented right here. --[[User:TimToady|TimToady]] 00:48, 18 July 2011 (UTC)
::Ok, cheers Tim. If that is the case, then I agree it was right to document it here. Like I say I don't know the language. Out of interest, if an operator is a function, can it be redefined? Is there an example of say, a redefinition of an addition function that is used for the addition operator? I plan to learn Perl 6 in future, when the compiler rolls down into Debian stable. [[User:Markhobley|Markhobley]] 06:34, 18 July 2011 (UTC)
:::Hey, I found some notes entitled "Metaoperators", that explains this operator/function stuff. Cheers all. [[User:Markhobley|Markhobley]] 06:42, 18 July 2011 (UTC)
::Yes, that's one of the nice things about treating operators as functions: they end up lexically scoped just like functions, and obey the same shadowing and/or multiple-dispatch rules. So if you define your own <tt>infix:<+></tt> it can either override or cooperate with any outer definitions of that operator. And even the metaoperators are just calls to higher-order functions underneath. These translations happen very early in the compilation; in a sense, all operators in Perl 6 are just convenient macros that rewrite the AST to a purer FP and/or OO form, and then either the early-binding lexical rules or the late-binding inheritance rules control which function gets called. We're pretty happy with how simple this foundation turned out, given everything we're trying to build on top of it.
:::Wow! Excellent. I am looking forward to learning this. Cheers. [[User:Markhobley|Markhobley]] 16:50, 18 July 2011 (UTC)
== What is using a function in a command context?==
Maybe I haven't had enough coffee, but I'm not sure what this means or how it's different from normal calling. --[[User:Dgamey|Dgamey]] 16:37, 19 July 2011 (UTC)
: dosomething() or call dosomething(), as opposed to returnvalue=dosomething(). The function is used as an instruction (with a void context), rather than used within an expression. Does that make sense? [[User:Markhobley|Markhobley]] 17:17, 19 July 2011 (UTC)
: Okay, I thought it might just be wording, I had that form in another mental bucket. More like a procedure call to me. Thanks. --[[User:Dgamey|Dgamey]] 17:52, 19 July 2011 (UTC)
:: I've changed this to read "statement context". [[User:Markhobley|Markhobley]] 18:45, 19 July 2011 (UTC)
| |||