Topic variable: Difference between revisions
Content added Content deleted
m (→{{header|Phix}}: syntax coloured) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 13: | Line 13: | ||
AppleScript binds the name '''result''' to the value of the expression most recently evaluated in the current scope. |
AppleScript binds the name '''result''' to the value of the expression most recently evaluated in the current scope. |
||
< |
<syntaxhighlight lang="applescript">on run |
||
1 + 2 |
1 + 2 |
||
Line 59: | Line 59: | ||
end script |
end script |
||
end if |
end if |
||
end mReturn</ |
end mReturn</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>{9, 1.732050807569}</pre> |
<pre>{9, 1.732050807569}</pre> |
||
The name '''result''' is still bound in this way if the most recently evaluated expression is a script rather than a simple value: |
The name '''result''' is still bound in this way if the most recently evaluated expression is a script rather than a simple value: |
||
< |
<syntaxhighlight lang="applescript">on run |
||
script |
script |
||
-- The given function applied to the value 3 |
-- The given function applied to the value 3 |
||
Line 114: | Line 114: | ||
end script |
end script |
||
end if |
end if |
||
end mReturn</ |
end mReturn</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>{9, 1.732050807569}</pre> |
<pre>{9, 1.732050807569}</pre> |
||
Line 122: | Line 122: | ||
=={{header|Axe}}== |
=={{header|Axe}}== |
||
In Axe, evaluated expressions can be "remembered" until the next expression is evaluated. |
In Axe, evaluated expressions can be "remembered" until the next expression is evaluated. |
||
< |
<syntaxhighlight lang="axe">3 |
||
Disp *3▶Dec,i</ |
Disp *3▶Dec,i</syntaxhighlight> |
||
Prints: |
Prints: |
||
Line 133: | Line 133: | ||
=={{header|BASIC256}}== |
=={{header|BASIC256}}== |
||
< |
<syntaxhighlight lang="freebasic">function Sum (x, y) |
||
Sum = x + y # using name of function |
Sum = x + y # using name of function |
||
end function |
end function |
||
Line 142: | Line 142: | ||
print Sum (1, 2) |
print Sum (1, 2) |
||
print SumR(2, 3)</ |
print SumR(2, 3)</syntaxhighlight> |
||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
The Clojure REPL has '''*1''' (and also '''*2''' and '''*3''' for the 2nd or 3rd most recent) |
The Clojure REPL has '''*1''' (and also '''*2''' and '''*3''' for the 2nd or 3rd most recent) |
||
< |
<syntaxhighlight lang="clojure"> |
||
user=> 3 |
user=> 3 |
||
3 |
3 |
||
Line 153: | Line 153: | ||
user=> (Math/pow *2 0.5) |
user=> (Math/pow *2 0.5) |
||
1.7320508075688772 |
1.7320508075688772 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
Line 168: | Line 168: | ||
In a stack oriented language like Forth the definition of variables is minimized as much as possible. The closest thing to a topic variable is the use of '''R@'''. This gets the top item from the return stack, which by the way is also used for flow control. It is up to the programmer to keep the stack balanced. In some Forth dialects '''R@''' and '''I''' are identical. '''I''' is used as a loop index, e.g. |
In a stack oriented language like Forth the definition of variables is minimized as much as possible. The closest thing to a topic variable is the use of '''R@'''. This gets the top item from the return stack, which by the way is also used for flow control. It is up to the programmer to keep the stack balanced. In some Forth dialects '''R@''' and '''I''' are identical. '''I''' is used as a loop index, e.g. |
||
< |
<syntaxhighlight lang="forth">: myloop 11 1 do i . loop cr ; myloop</syntaxhighlight> |
||
Which will print all numbers from 1 to 10. A typical use of '''R@''' is illustrated here: |
Which will print all numbers from 1 to 10. A typical use of '''R@''' is illustrated here: |
||
< |
<syntaxhighlight lang="forth">: ^2 dup * ; |
||
: sqrt 0 tuck ?do 1+ dup 2* 1+ +loop ; |
: sqrt 0 tuck ?do 1+ dup 2* 1+ +loop ; |
||
: topic >r r@ ^2 . r@ sqrt . r> drop ; |
: topic >r r@ ^2 . r@ sqrt . r> drop ; |
||
23 topic</ |
23 topic</syntaxhighlight> |
||
The word '''>R''' places the item on the return stack and the word '''R>''' retrieves it from the return stack - an experienced Forth programmer would optimize this definition even further. Note that for technical reasons all words listed cannot be used outside definitions, so it may be argued that Forth doesn't have topic variables. |
The word '''>R''' places the item on the return stack and the word '''R>''' retrieves it from the return stack - an experienced Forth programmer would optimize this definition even further. Note that for technical reasons all words listed cannot be used outside definitions, so it may be argued that Forth doesn't have topic variables. |
||
Line 187: | Line 187: | ||
Alternatively, the keyword 'Function' can itself be used as an implicitly defined variable and behaves in exactly the same way as the function's name when used in this role. Similarly, the keywords 'Property' or 'Operator' can be used to return values from properties or operators respectively. |
Alternatively, the keyword 'Function' can itself be used as an implicitly defined variable and behaves in exactly the same way as the function's name when used in this role. Similarly, the keywords 'Property' or 'Operator' can be used to return values from properties or operators respectively. |
||
< |
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
||
' Three different ways of returning a value from a function |
' Three different ways of returning a value from a function |
||
Line 206: | Line 206: | ||
Print Sum2(2, 3) |
Print Sum2(2, 3) |
||
Print Sum3(3, 4) |
Print Sum3(3, 4) |
||
Sleep</ |
Sleep</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 217: | Line 217: | ||
=={{header|Go}}== |
=={{header|Go}}== |
||
Go has nothing like this in the bare language, but the template package of the standard library has a similar mechanism. Templates can have named variables, but they also have a cursor, represented by a period '.' and called "dot", that refers to a current value. |
Go has nothing like this in the bare language, but the template package of the standard library has a similar mechanism. Templates can have named variables, but they also have a cursor, represented by a period '.' and called "dot", that refers to a current value. |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 249: | Line 249: | ||
`)) |
`)) |
||
t.Execute(os.Stdout, "3") |
t.Execute(os.Stdout, "3") |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 259: | Line 259: | ||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
In Haskell terminal GHCi or WinGHCi, topic variable is called: it. |
In Haskell terminal GHCi or WinGHCi, topic variable is called: it. |
||
<syntaxhighlight lang="haskell"> |
|||
<lang Haskell> |
|||
Prelude> [1..10] |
Prelude> [1..10] |
||
[1,2,3,4,5,6,7,8,9,10] |
[1,2,3,4,5,6,7,8,9,10] |
||
Prelude> map (^2) it |
Prelude> map (^2) it |
||
[1,4,9,16,25,36,49,64,81,100] |
[1,4,9,16,25,36,49,64,81,100] |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Line 271: | Line 271: | ||
Thus, for example (entirely eliminating the variable representing the argument): |
Thus, for example (entirely eliminating the variable representing the argument): |
||
< |
<syntaxhighlight lang="j"> example=: *:, %: NB. *: is square, %: is square root |
||
example 3 |
example 3 |
||
9 1.73205</ |
9 1.73205</syntaxhighlight> |
||
Or, if we want to see the dummy variable in place (though still not declared, because there is no point to that): |
Or, if we want to see the dummy variable in place (though still not declared, because there is no point to that): |
||
< |
<syntaxhighlight lang="j"> Example=: verb def '(*: y), (%: y)' |
||
Example 3 |
Example 3 |
||
9 1.73205</ |
9 1.73205</syntaxhighlight> |
||
Or course, if it's crucial to the concept of topic variables that they not be constrained to definitions of things like functions, then it might be argued that J does not have them. |
Or course, if it's crucial to the concept of topic variables that they not be constrained to definitions of things like functions, then it might be argued that J does not have them. |
||
Line 285: | Line 285: | ||
On the third hand, note that "definitions of functions" do not actually need to be associated with names. At worst, some definitions might need to be enclosed in parenthesis: |
On the third hand, note that "definitions of functions" do not actually need to be associated with names. At worst, some definitions might need to be enclosed in parenthesis: |
||
< |
<syntaxhighlight lang="j"> (*:, %:) 3 |
||
9 1.73205</ |
9 1.73205</syntaxhighlight> |
||
And if we were to insist on leaving out functions, it's not clear that there would be much of anything left of the language to be doing anything with. See also Henry Rich's writeup on [http://www.jsoftware.com/docs/help701/jforc/tacit_programs.htm Tacit Programs]. |
And if we were to insist on leaving out functions, it's not clear that there would be much of anything left of the language to be doing anything with. See also Henry Rich's writeup on [http://www.jsoftware.com/docs/help701/jforc/tacit_programs.htm Tacit Programs]. |
||
Line 303: | Line 303: | ||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
Julia REPL has `ans` variable: |
Julia REPL has `ans` variable: |
||
< |
<syntaxhighlight lang="julia">julia> 3 |
||
3 |
3 |
||
julia> ans * ans, ans - 1 |
julia> ans * ans, ans - 1 |
||
(9, 2)</ |
(9, 2)</syntaxhighlight> |
||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
The closest thing Kotlin has to a topic variable is the identifier 'it' which implicitly refers to the parameter of a lambda expression when it only has one. As in the case of all other parameters in Kotlin, 'it' is read-only and is in scope until the end of the lambda expression. |
The closest thing Kotlin has to a topic variable is the identifier 'it' which implicitly refers to the parameter of a lambda expression when it only has one. As in the case of all other parameters in Kotlin, 'it' is read-only and is in scope until the end of the lambda expression. |
||
< |
<syntaxhighlight lang="scala">// version 1.1.2 |
||
fun main(args: Array<String>) { |
fun main(args: Array<String>) { |
||
Line 318: | Line 318: | ||
println(Math.sqrt(it.toDouble())) |
println(Math.sqrt(it.toDouble())) |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 359: | Line 359: | ||
In Nim, the special variable <code>_</code> may be considered as a topic variable. It is mainly used in loops when the value of the counter is not needed, for instance: |
In Nim, the special variable <code>_</code> may be considered as a topic variable. It is mainly used in loops when the value of the counter is not needed, for instance: |
||
< |
<syntaxhighlight lang="nim">for _ in 1..10: |
||
echo "Hello World!"</ |
echo "Hello World!"</syntaxhighlight> |
||
Another kind of topic variable is <code>it</code> which is used in expressions in some templates. For instance: |
Another kind of topic variable is <code>it</code> which is used in expressions in some templates. For instance: |
||
< |
<syntaxhighlight lang="nim">import sequtils |
||
let x = [1, 2, 3, 4, 5] |
let x = [1, 2, 3, 4, 5] |
||
let y = x.mapIt(it * it) |
let y = x.mapIt(it * it) |
||
echo y # @[1, 4, 9, 16, 25]</ |
echo y # @[1, 4, 9, 16, 25]</syntaxhighlight> |
||
=={{header|Oforth}}== |
=={{header|Oforth}}== |
||
Line 375: | Line 375: | ||
This will push 3 on the stack and compute sq and sqrt : |
This will push 3 on the stack and compute sq and sqrt : |
||
<lang |
<syntaxhighlight lang="oforth">3 dup sq swap sqrt</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
gp is a REPL for GP, within which <code>%</code> can be used to refer to the last result. |
gp is a REPL for GP, within which <code>%</code> can be used to refer to the last result. |
||
< |
<syntaxhighlight lang="parigp">3 |
||
[sqrt(%),%^2]</ |
[sqrt(%),%^2]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>%1 = 3 |
<pre>%1 = 3 |
||
Line 390: | Line 390: | ||
It is the default parameter for loops, and some functions e.g. 'sqrt': |
It is the default parameter for loops, and some functions e.g. 'sqrt': |
||
< |
<syntaxhighlight lang="perl">print sqrt . " " for (4, 16, 64)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>2 4 8</pre> |
<pre>2 4 8</pre> |
||
Line 398: | Line 398: | ||
and the 'local' keyword is needed to enable loops to nest. |
and the 'local' keyword is needed to enable loops to nest. |
||
< |
<syntaxhighlight lang="perl">for (1..2) { |
||
print "outer $_:\n"; |
print "outer $_:\n"; |
||
local $_; |
local $_; |
||
Line 405: | Line 405: | ||
} |
} |
||
print " fini\n"; |
print " fini\n"; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>outer 1: |
<pre>outer 1: |
||
Line 414: | Line 414: | ||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
The closest thing would be to declare a variable with just an underscore as its identifier. |
The closest thing would be to declare a variable with just an underscore as its identifier. |
||
<!--< |
<!--<syntaxhighlight lang="phix">(phixonline)--> |
||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
||
<span style="color: #004080;">object</span> <span style="color: #000000;">_</span> |
<span style="color: #004080;">object</span> <span style="color: #000000;">_</span> |
||
Line 420: | Line 420: | ||
<span style="color: #0000FF;">?</span><span style="color: #000000;">_</span> |
<span style="color: #0000FF;">?</span><span style="color: #000000;">_</span> |
||
<span style="color: #0000FF;">?</span><span style="color: #000000;">_</span><span style="color: #0000FF;">*</span><span style="color: #000000;">_</span> |
<span style="color: #0000FF;">?</span><span style="color: #000000;">_</span><span style="color: #0000FF;">*</span><span style="color: #000000;">_</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 428: | Line 428: | ||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">PicoLisp sets the value of the variable (symbol) '@' to the result of |
||
conditional and controlling expressions in flow- and logic-functions (cond, if, |
conditional and controlling expressions in flow- and logic-functions (cond, if, |
||
and, when, while, etc.). |
and, when, while, etc.). |
||
Line 436: | Line 436: | ||
For example, to read the current input channel until EOF, and print the square |
For example, to read the current input channel until EOF, and print the square |
||
of every item which is a number:</ |
of every item which is a number:</syntaxhighlight> |
||
Test: |
Test: |
||
< |
<syntaxhighlight lang="picolisp">(while (read) |
||
(when (num? @) |
(when (num? @) |
||
(println (* @ @)) ) ) |
(println (* @ @)) ) ) |
||
Line 446: | Line 446: | ||
xyz # Not a number |
xyz # Not a number |
||
3 # Number |
3 # Number |
||
9 # -> print square</ |
9 # -> print square</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
Line 455: | Line 455: | ||
The most common use is in the <code>ForEach-Object</code> cmdlet: |
The most common use is in the <code>ForEach-Object</code> cmdlet: |
||
<syntaxhighlight lang="powershell"> |
|||
<lang PowerShell> |
|||
65..67 | ForEach-Object {$_ * 2} # Multiply the numbers by 2 |
65..67 | ForEach-Object {$_ * 2} # Multiply the numbers by 2 |
||
65..67 | ForEach-Object {[char]$_ } # ASCII values of the numbers |
65..67 | ForEach-Object {[char]$_ } # ASCII values of the numbers |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre> |
<pre> |
||
Line 469: | Line 469: | ||
</pre> |
</pre> |
||
Using <code>Where-Object</code> to filter the odd numbers from an array: |
Using <code>Where-Object</code> to filter the odd numbers from an array: |
||
<syntaxhighlight lang="powershell"> |
|||
<lang PowerShell> |
|||
65..67 | Where-Object {$_ % 2} |
65..67 | Where-Object {$_ % 2} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre> |
<pre> |
||
Line 478: | Line 478: | ||
</pre> |
</pre> |
||
Using <code>Format-Wide</code> to force an array into columns: |
Using <code>Format-Wide</code> to force an array into columns: |
||
<syntaxhighlight lang="powershell"> |
|||
<lang PowerShell> |
|||
65..70 | Format-Wide {$_} -Column 3 -Force |
65..70 | Format-Wide {$_} -Column 3 -Force |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{Out}} |
{{Out}} |
||
<pre> |
<pre> |
||
Line 489: | Line 489: | ||
=={{header|Python}}== |
=={{header|Python}}== |
||
Pythons REPL has '''_'''. |
Pythons REPL has '''_'''. |
||
< |
<syntaxhighlight lang="python">>>> 3 |
||
3 |
3 |
||
>>> _*_, _**0.5 |
>>> _*_, _**0.5 |
||
(9, 1.7320508075688772) |
(9, 1.7320508075688772) |
||
>>> </ |
>>> </syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
Line 499: | Line 499: | ||
Racket doesn't have a "built-in" concept of a topic variable, but one is easy to add to the language with some macros. In fact, the subject of adding such a facility to a language using a hygienic macro facility is a very popular topic in some macro circles, and Racket can do it very well using syntax parameters. In the following there is a demonstration of two implementation approaches, the first uses a "parameter" -- a runtime value that is bound to a value in some dynamic extent, and the second uses a "syntax parameter" which is something that refers indirectly to a plain binding, and this binding can be adjusted by macros to point at an existing "real" binding. See the end of the code for usage samples. (Note that there is no point to talk about how these things behave wrt scope: since Racket is flexible enough to implement these with very different scopes...) |
Racket doesn't have a "built-in" concept of a topic variable, but one is easy to add to the language with some macros. In fact, the subject of adding such a facility to a language using a hygienic macro facility is a very popular topic in some macro circles, and Racket can do it very well using syntax parameters. In the following there is a demonstration of two implementation approaches, the first uses a "parameter" -- a runtime value that is bound to a value in some dynamic extent, and the second uses a "syntax parameter" which is something that refers indirectly to a plain binding, and this binding can be adjusted by macros to point at an existing "real" binding. See the end of the code for usage samples. (Note that there is no point to talk about how these things behave wrt scope: since Racket is flexible enough to implement these with very different scopes...) |
||
< |
<syntaxhighlight lang="racket"> |
||
#lang racket |
#lang racket |
||
Line 557: | Line 557: | ||
) |
) |
||
(require 'sample2) |
(require 'sample2) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
Line 564: | Line 564: | ||
As in Perl, in Raku the topic variable is $_. In addition to a direct assigment, it can be set with the 'given' or 'with' keywords, or by some iteration operator ('for', 'map' etc). A method can be called from it with an implicit call: |
As in Perl, in Raku the topic variable is $_. In addition to a direct assigment, it can be set with the 'given' or 'with' keywords, or by some iteration operator ('for', 'map' etc). A method can be called from it with an implicit call: |
||
<lang |
<syntaxhighlight lang="raku" line>$_ = 'Outside'; |
||
for <3 5 7 10> { |
for <3 5 7 10> { |
||
print $_; |
print $_; |
||
.³.map: { say join "\t", '', $_, .², .sqrt, .log(2), OUTER::<$_>, UNIT::<$_> } |
.³.map: { say join "\t", '', $_, .², .sqrt, .log(2), OUTER::<$_>, UNIT::<$_> } |
||
}</ |
}</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>3 27 729 5.196152422706632 4.754887502163469 3 Outside |
<pre>3 27 729 5.196152422706632 4.754887502163469 3 Outside |
||
Line 582: | Line 582: | ||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
With this new definition of topic variables, the closest thing REXX has to a topic variable is probably function/subroutine arguments being "passed" to the target function/subroutine/routine/procedure. |
With this new definition of topic variables, the closest thing REXX has to a topic variable is probably function/subroutine arguments being "passed" to the target function/subroutine/routine/procedure. |
||
< |
<syntaxhighlight lang="rexx">/*REXX program shows something close to a "topic variable" (for functions/subroutines).*/ |
||
parse arg N /*obtain a variable from the cmd line. */ |
parse arg N /*obtain a variable from the cmd line. */ |
||
call squareIt N /*invoke a function to square da number*/ |
call squareIt N /*invoke a function to square da number*/ |
||
Line 588: | Line 588: | ||
exit 0 /*stick a fork in it, we're all done. */ |
exit 0 /*stick a fork in it, we're all done. */ |
||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
||
squareIt: return arg(1) ** 2 /*return the square of passed argument.*/</ |
squareIt: return arg(1) ** 2 /*return the square of passed argument.*/</syntaxhighlight> |
||
{{out|output|text= when using the input of: <tt> 12 </tt>}} |
{{out|output|text= when using the input of: <tt> 12 </tt>}} |
||
<pre> |
<pre> |
||
Line 595: | Line 595: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
see "sum1 = " + sum1(1,2) + nl |
see "sum1 = " + sum1(1,2) + nl |
||
see "sum2 = " + sum2(2,3) + nl |
see "sum2 = " + sum2(2,3) + nl |
||
Line 605: | Line 605: | ||
func sum2 (x, y) |
func sum2 (x, y) |
||
return x + y |
return x + y |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 615: | Line 615: | ||
In Ruby the topic variable is $_ (same as Perl). |
In Ruby the topic variable is $_ (same as Perl). |
||
< |
<syntaxhighlight lang="ruby">while DATA.gets # assigns to $_ (local scope) |
||
print # If no arguments are given, prints $_ |
print # If no arguments are given, prints $_ |
||
end |
end |
||
Line 621: | Line 621: | ||
This is line one |
This is line one |
||
This is line two |
This is line two |
||
This is line three</ |
This is line three</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 630: | Line 630: | ||
</pre> |
</pre> |
||
'''example:''' |
'''example:''' |
||
< |
<syntaxhighlight lang="ruby">DATA.gets |
||
p [$_.to_i ** 2, Math.sqrt($_.to_i)] #=> [9, 1.7320508075688772] |
p [$_.to_i ** 2, Math.sqrt($_.to_i)] #=> [9, 1.7320508075688772] |
||
__END__ |
__END__ |
||
3</ |
3</syntaxhighlight> |
||
The style of programming using $_ as an implicit parameter is gradually losing favor in the Ruby community. |
The style of programming using $_ as an implicit parameter is gradually losing favor in the Ruby community. |
||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
< |
<syntaxhighlight lang="scala">object TopicVar extends App { |
||
class SuperString(val org: String){ |
class SuperString(val org: String){ |
||
def it(): Unit = println(org) |
def it(): Unit = println(org) |
||
Line 649: | Line 649: | ||
Seq(4).foreach { it => println(it)} |
Seq(4).foreach { it => println(it)} |
||
Seq(8).foreach { it => println(it + it)} |
Seq(8).foreach { it => println(it + it)} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
The underscore (''_'') topic variable is defined at compile-time in every block of a program. To call a method on it, we can just use the prefix dot (''.'') operator, followed by a method name, which is equivalent with ''_.method_name'' |
The underscore (''_'') topic variable is defined at compile-time in every block of a program. To call a method on it, we can just use the prefix dot (''.'') operator, followed by a method name, which is equivalent with ''_.method_name'' |
||
< |
<syntaxhighlight lang="ruby">say [9,16,25].map {.sqrt}; # prints: [3, 4, 5]</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
Line 660: | Line 660: | ||
expression in the REPL (as opposed to a declaration). |
expression in the REPL (as opposed to a declaration). |
||
< |
<syntaxhighlight lang="sml">- 3.0; |
||
val it = 3.0 : real |
val it = 3.0 : real |
||
- it * it; |
- it * it; |
||
Line 666: | Line 666: | ||
- Math.sqrt it; |
- Math.sqrt it; |
||
val it = 3.0 : real |
val it = 3.0 : real |
||
-</ |
-</syntaxhighlight> |
||
=={{header|Tailspin}}== |
=={{header|Tailspin}}== |
||
Line 672: | Line 672: | ||
The current value goes through a sequence of transformations and has the new transformed value at each stage of the chain. |
The current value goes through a sequence of transformations and has the new transformed value at each stage of the chain. |
||
To do more things with the same current value, a function/templates (here an inline function/templates) can be used to encapsulate several chains where the same current value is accessed at the start of each chain. |
To do more things with the same current value, a function/templates (here an inline function/templates) can be used to encapsulate several chains where the same current value is accessed at the start of each chain. |
||
< |
<syntaxhighlight lang="tailspin"> |
||
3 -> \($-1! $+1!\) -> $*$ -> [$-1..$+1] -> '$; |
3 -> \($-1! $+1!\) -> $*$ -> [$-1..$+1] -> '$; |
||
' -> !OUT::write |
' -> !OUT::write |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 686: | Line 686: | ||
The shell $? is a kind of limited topic variable that holds the return value of the last function called. However, using it in a function will change its value, so following the echo below, the dollarhook will now contain the return value of zero indicating a successful echo: |
The shell $? is a kind of limited topic variable that holds the return value of the last function called. However, using it in a function will change its value, so following the echo below, the dollarhook will now contain the return value of zero indicating a successful echo: |
||
< |
<syntaxhighlight lang="sh">multiply 3 4 # We assume this user defined function has been previously defined |
||
echo $? # This will output 12, but $? will now be zero indicating a successful echo</ |
echo $? # This will output 12, but $? will now be zero indicating a successful echo</syntaxhighlight> |
||
=={{header|VBA}}== |
=={{header|VBA}}== |
||
Line 696: | Line 696: | ||
Note that you can't use a single or double underscore as the variable name for this purpose as they always denote instance or static fields of a class. |
Note that you can't use a single or double underscore as the variable name for this purpose as they always denote instance or static fields of a class. |
||
< |
<syntaxhighlight lang="ecmascript">var T // global scope |
||
var doSomethingWithT = Fn.new { [T * T, T.sqrt] } |
var doSomethingWithT = Fn.new { [T * T, T.sqrt] } |
||
T = 3 |
T = 3 |
||
System.print(doSomethingWithT.call())</ |
System.print(doSomethingWithT.call())</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 710: | Line 710: | ||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
No topic variable pre se (a variable name can be a single character however), but underscore has a special meaning in some cases. Its use is scoped to the expression it is used in. |
No topic variable pre se (a variable name can be a single character however), but underscore has a special meaning in some cases. Its use is scoped to the expression it is used in. |
||
< |
<syntaxhighlight lang="zkl">a,_,c:=List(1,2,3,4,5,6) //-->a=1, c=3, here _ is used as "ignore" |
||
3.0 : _.sqrt() : println(_) //-->"1.73205", _ (and :) is used to "explode" a computation |
3.0 : _.sqrt() : println(_) //-->"1.73205", _ (and :) is used to "explode" a computation |
||
// as syntactic sugar |
// as syntactic sugar |
||
1.0 + 2 : _.sqrt() : _.pow(4) // no variables used, the compiler "implodes" the computation |
1.0 + 2 : _.sqrt() : _.pow(4) // no variables used, the compiler "implodes" the computation |
||
// --> 9 |
// --> 9 |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{omit from|BASIC}} |
{{omit from|BASIC}} |