Topic variable: Difference between revisions

{{task}}

 

Demonstrate the utilization and behaviour of the topic variable within the language and explain or demonstrate how the topic variable behaves under different levels of nesting or scope, if this applies, within the language.

 

For instance you can (but you don't have to) show how the topic variable can be used by assigning the number <math>3</math> to it and then computing its square and square root.

 

=={{header|AppleScript}}==

AppleScript binds the name '''result''' to the value of the expression most recently evaluated in the current scope.

 

1 + 2

end script

end if

{{Out}}

<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:

script

-- The given function applied to the value 3

end script

end if

{{Out}}

<pre>{9, 1.732050807569}</pre>

=={{header|Axe}}==

In Axe, evaluated expressions can be "remembered" until the next expression is evaluated.

 

Prints:

 

However, attempting to use the result now would result in garbage due to the ▶Dec and Disp commands overwriting the previous result.

 

=={{header|Clojure}}==

The Clojure REPL has '''*1''' (and also '''*2''' and '''*3''' for the 2nd or 3rd most recent)

user=> 3

3

user=> (Math/pow *2 0.5)

1.7320508075688772

 

=={{header|Erlang}}==

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.

 

 

Which will print all numbers from 1 to 10. A typical use of '''R@''' is illustrated here:

 

: sqrt 0 tuck ?do 1+ dup 2* 1+ +loop ;

: topic >r r@ ^2 . r@ sqrt . r> drop ;

 

 

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.

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.

 

 

' Three different ways of returning a value from a function

Print Sum2(2, 3)

Print Sum3(3, 4)

 

{{out}}

=={{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.

 

import (

`))

t.Execute(os.Stdout, "3")

{{out}}

<pre>

=={{header|Haskell}}==

In Haskell terminal GHCi or WinGHCi, topic variable is called: it.

Prelude> [1..10]

[1,2,3,4,5,6,7,8,9,10]

Prelude> map (^2) it

[1,4,9,16,25,36,49,64,81,100]

 

=={{header|J}}==

Thus, for example (entirely eliminating the variable representing the argument):

 

example 3

 

Or, if we want to see the dummy variable in place (though still not declared, because there is no point to that):

 

Example 3

 

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.

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:

 

 

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].

 

=={{header|jq}}==

 

 

There are some special character combinations involving ".":

=={{header|Julia}}==

Julia REPL has `ans` variable:

3

julia> ans * ans, ans - 1

 

=={{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.

 

fun main(args: Array<String>) {

println(Math.sqrt(it.toDouble()))

}

 

{{out}}

</pre>

 

This depends on the Mathematica REPL. For the examples, I will use the textual format that Mathematica provides. Here's some basic examples:

<pre>In[1]:= 3

Out[1]= 3

 

In[2]:= %1^2

Out[2]= 9

 

In[3]:= Sqrt[%%]

Out[3]= Sqrt[3]

 

In[4]:= N[Out[-1]] (* for floating point *)

Out[4]= 1.73205</pre>

In this, I use 3 different forms. Here's a list of them:

When an input is reevaluated, it also reassigns all relative Ins and Outs. Look at this for an example of its strange effects:

<pre>In[1]:= In[2]

Out[1]= In[2]

 

In[2]:= In[1]

$IterationLimit::itlim: Iteration limit of 4096 exceeded.

Out[2]= Hold[In[1]]</pre>

In it, it gets stuck in an infinite loop between In[1] and In[2], which evaluate to each other.

 

=={{header|Oforth}}==

Oforth does not have global variables, topic or not.

 

 

 

=={{header|PARI/GP}}==

 

gp is a REPL for GP, within which <code>%</code> can be used to refer to the last result.

{{out}}

<pre>%1 = 3

It is the default parameter for loops, and some functions e.g. 'sqrt':

 

{{out}}

<pre>2 4 8</pre>

and the 'local' keyword is needed to enable loops to nest.

 

print "outer $_:\n";

local $_;

}

print " fini\n";

{{out}}

<pre>outer 1:

=={{header|Phix}}==

The closest thing would be to declare a variable with just an underscore as its identifier.

{{out}}

<pre>

 

=={{header|PicoLisp}}==

conditional and controlling expressions in flow- and logic-functions (cond, if,

and, when, while, etc.).

 

For example, to read the current input channel until EOF, and print the square

Test:

(when (num? @)

(println (* @ @)) ) )

xyz # Not a number

3 # Number

 

=={{header|PowerShell}}==

 

The most common use is in the <code>ForEach-Object</code> cmdlet:

65..67 | ForEach-Object {$_ * 2} # Multiply the numbers by 2

65..67 | ForEach-Object {[char]$_ } # ASCII values of the numbers

{{Out}}

<pre>

</pre>

Using <code>Where-Object</code> to filter the odd numbers from an array:

65..67 | Where-Object {$_ % 2}

{{Out}}

<pre>

</pre>

Using <code>Format-Wide</code> to force an array into columns:

65..70 | Format-Wide {$_} -Column 3 -Force

{{Out}}

<pre>

=={{header|Python}}==

Pythons REPL has '''_'''.

3

>>> _*_, _**0.5

(9, 1.7320508075688772)

 

=={{header|Racket}}==

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...)

 

#lang racket

 

)

(require 'sample2)

 

=={{header|Raku}}==

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:

 

for <3 5 7 10> {

print $_;

.³.map: { say join "\t", '', $_, .², .sqrt, .log(2), OUTER::<$_>, UNIT::<$_> }

{{Out}}

<pre>3 27 729 5.196152422706632 4.754887502163469 3 Outside

=={{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.

<pre>

</pre>

 

=={{header|Ring}}==

see "sum1 = " + sum1(1,2) + nl

see "sum2 = " + sum2(2,3) + nl

func sum2 (x, y)

return x + y

Output:

<pre>

In Ruby the topic variable is $_ (same as Perl).

 

print # If no arguments are given, prints $_

end

This is line one

This is line two

 

{{out}}

</pre>

'''example:'''

p [$_.to_i ** 2, Math.sqrt($_.to_i)] #=> [9, 1.7320508075688772]

__END__

The style of programming using $_ as an implicit parameter is gradually losing favor in the Ruby community.

 

=={{header|Scala}}==

class SuperString(val org: String){

def it(): Unit = println(org)

Seq(4).foreach { it => println(it)}

Seq(8).foreach { it => println(it + it)}

 

=={{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''

 

=={{header|Standard ML}}==

The SML language itself does not define a topic variable, but interactive implementations may define their own.

For example the SML/NJ REPL defines a topic variable named <tt>it</tt> which is bound any time the user types an

 

val it = 3.0 : real

- it * it;

- Math.sqrt it;

val it = 3.0 : real

 

=={{header|Tailspin}}==

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.

3 -> \($-1! $+1!\) -> $*$ -> [$-1..$+1] -> '$;

' -> !OUT::write

{{out}}

<pre>

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:

 

 

=={{header|VBA}}==

 

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.

 

var doSomethingWithT = Fn.new { [T * T, T.sqrt] }

 

T = 3

 

{{out}}

=={{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.

3.0 : _.sqrt() : println(_) //-->"1.73205", _ (and :) is used to "explode" a computation

// as syntactic sugar

1.0 + 2 : _.sqrt() : _.pow(4) // no variables used, the compiler "implodes" the computation

// --> 9

 

{{omit from|BASIC}}

{{omit from|C}}

{{omit from|D}}

{{omit from|GUISS|Does not have any variables}}

{{omit from|Python|Against language philosophy of "Explicit is better than implicit"}}

{{omit from|Rust}}

{{omit from|VBA}}

{{omit from|ZX Spectrum Basic}}

[[Category:Basic language learning]]