Multiple distinct objects: Difference between revisions
m
syntax highlighting fixup automation
m (→{{header|Phix}}: added syntax colouring, made p2js compatible) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 17:
{{trans|Python}}
<
=={{header|Action!}}==
<
DEFINE OBJSIZE="4"
TYPE Record=[BYTE b CHAR c INT i]
Line 76:
LMARGIN=oldLMARGIN ;restore left margin on the screen
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiple_distinct_objects.png Screenshot from Atari 8-bit computer]
Line 96:
=={{header|Ada}}==
<
Here N can be unknown until run-time. T is any constrained type. In [[Ada]] all objects are always initialized, though some types may have null initialization. When T requires a non-null initialization, it is done for each array element. For example, when T is a [[task]] type, N tasks start upon initialization of A. Note that T can be a ''limited'' type like task. Limited types do not have predefined copy operation. Arrays of non-limited types can also be initialized by aggregates of:
<
Here V is some value or expression of the type T. As an expression V may have side effects, in that case it is evaluated exactly N times, though the order of evaluation is not defined. Also an aggregate itself can be considered as a solution of the task:
<
=={{header|Aime}}==
<
show_sublist(list l)
{
Line 160:
return 0;
}</
{{out}}
<pre> [4] [4] [4] [7] [4] [4] [4] [4]</pre>
Line 170:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
<
INT n := 26;
[n]FOO f;
Line 177:
FOR i TO UPB f DO f[i] := (REPR(ABS("A")-1+i), REPR(ABS("a")-1+i)) OD;
print((f, new line))</
Output:
<pre>
Line 184:
=={{header|ALGOL W}}==
<
record T ( integer n, m );
reference(T) singleT;
Line 207:
for i := 1 until numberOfElements do writeon( i_w := 1, s_w := 0, n(tArray( i )), ", ", m(tArray( i )), "; " )
end
end.</
{{out}}
<pre>
Line 215:
=={{header|AppleScript}}==
<
-- nObjects Constructor -> Int -> [Object]
Line 274:
end script
end if
end mReturn</
{{Out}}
<
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
<
Loop, %n%
a[A_Index] := new Foo()</
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
n% = RND(1000)
Line 302:
FOR i% = 0 TO DIM(objects%(),1)
objects%(i%) = object{}
NEXT</
=={{header|Brat}}==
The wrong way, which creates an array of ''n'' references to the same new ''foo'':
<syntaxhighlight lang
The right way, which calls the block ''n'' times and creates an array of new ''foo''s:
<
=={{header|C}}==
<
for (int i = 0; i < n; i++)
init_foo(&foos[i]);</
(Or if no particular initialization is needed, skip that part, or use <tt>calloc</tt>.)
Line 322:
=={{header|C sharp|C#}}==
<
using System.Linq;
using System.Collections.Generic;
List<Foo> foos = Enumerable.Range(1, n).Select(x => new Foo()).ToList();</
=={{header|C++}}==
Line 332:
Using only language primitives:
<
T* p = new T[n]; // if T is POD, the objects are uninitialized, otherwise they are default-initialized
Line 340:
// when you don't need the objects any more, get rid of them
delete[] p;</
Using the standard library
<
#include <algorithm>
#include <iterator>
Line 355:
// To initialise each value differently
std::generate_n(std::back_inserter(vec), n, makeT); //makeT is a function of type T(void)
</syntaxhighlight>
In C++ reference semantics are achieved by holding objects by pointer. Here is an example of the error, and a correct way of achieving distinctness.
Line 361:
These examples assume T has a public copy constructor, and that p is a pointer to T;
<
#include <tr1/memory>
using namespace std;
Line 384:
bvec2.push_back(TPtr_t(new T(*p));
</syntaxhighlight>
Of course, also in this case one can use the other sequence containers or plain new/delete instead of <tt>vector</tt>.
=={{header|Clojure}}==
An example using pseudo-random numbers:
<
(0.2787011365537204 0.2787011365537204 0.2787011365537204)
user> (take 3 (repeatedly rand)) ; creating three different random number
(0.8334795669220695 0.08405601245793926 0.5795448744634744)
user></
=={{header|Common Lisp}}==
The mistake is often written as one of these:
<
(make-array n :initial-element (make-the-distinct-thing))</
which are incorrect since the form <code>(make-the-distinct-thing)</code> is only evaluated once and the single object is put in every position of the sequence. A commonly used correct version is:
<
which evaluates <code>(make-the-distinct-thing)</code> <var>n</var> times and collects each result in a list.
It is also possible to use <code>[http://www.lispworks.com/documentation/HyperSpec/Body/f_map_in.htm map-into]</code>, the destructive map operation, to do this since it may take zero input sequences; this method can produce any sequence type, such as a vector (array) rather than a list, and takes a function rather than a form to specify the thing created:
<
(map-into (make-array n) #'make-the-distinct-thing)</
=={{header|D}}==
For reference types (classes):
<
foreach (ref item; fooArray)
item = new Foo();
</syntaxhighlight>
For value types:
<
barArray[] = initializerValue;</
=={{header|Delphi}}==
Same object accessed multiple times (bad)
<syntaxhighlight lang="delphi">var
i: Integer;
lObject: TMyObject;
Line 431:
for i := 1 to 10 do
lList.Add(lObject);
// ...</
Distinct objects (good)
<syntaxhighlight lang="delphi">var
i: Integer;
lList: TObjectList<TMyObject>;
Line 441:
for i := 1 to 10 do
lList.Add(TMyObject.Create);
// ...</
=={{header|E}}==
Line 447:
[[Category:E examples needing attention]] E needs development of better map/filter/stream facilities. The easiest way to do this so far is with the accumulator syntax, which is officially experimental because we're not satisfied with it as yet.
<
...
accum [] for _ in 1..n { _.with(makeWhatever()) }</
=={{header|EchoLisp}}==
<
;; wrong - make-vector is evaluated one time - same vector
Line 469:
L → (#(0 🔵 0 0) #(0 0 0 0) #(0 0 0 0)) ;; OK
</syntaxhighlight>
=={{header|Elena}}==
<
import extensions;
Line 484:
{
var foos := fill(10);
}</
=={{header|Elixir}}==
<
=={{header|Erlang}}==
Line 497:
=={{header|F_Sharp|F#}}==
The wrong way:
<
val it : Guid list =
[485632d7-1fd6-4d9e-8910-7949d7b2b485; 485632d7-1fd6-4d9e-8910-7949d7b2b485;
485632d7-1fd6-4d9e-8910-7949d7b2b485]</
The right way:
<
val it : Guid list =
[447acb0c-092e-4f85-9c3a-d369e4539dae; 5f41c04d-9bc0-4e96-8165-76b41fe8cd93;
1086400c-72ff-4763-9bb9-27e17bd4c7d2]</
=={{header|Factor}}==
clone is the important word here to have distinct objects. This creates an array of arrays.
<
=={{header|FreeBASIC}}==
The value of n can be determined at runtime, and the array is automatically initialized to zeroes.
<
=={{header|Forth}}==
Line 524:
Needs the FMS-SI (single inheritance) library code located here:
http://soton.mpeforth.com/flag/fms/index.html
<
include FMS-SILib.f
Line 547:
list each: drop . 1301600
list each: drop . 1301600
</syntaxhighlight>
=={{header|Fortran}}==
<
program multiple
! Define a simple type
Line 594:
end program multiple
</syntaxhighlight>
=={{header|Go}}==
Useful:
<
d2 := make([][]int, n)
for i := range d2 {
Line 604:
}
return d2
}</
Probably not what the programmer wanted:
<
d1 := make([]int, m)
d2 := make([][]int, n)
Line 613:
}
return d2
}</
=={{header|Groovy}}==
Correct Solution:
<
Incorrect Solution:
<
def createFoos2 = {n -> [new Foo()] * n }</
Test:
<
print "Objects distinct for n = "
(2..<20).each { n ->
Line 637:
}
println()
}</
Output:
Line 654:
Below, we are assuming that <tt>makeTheDistinctThing</tt> is a monadic expression (i.e. it has type <code>m a</code> where <code>m</code> is some monad, like <code>IO</code> or <code>ST</code>), and we are talking about distinctness in the context of the monad. Otherwise, this task is pretty meaningless in Haskell, because Haskell is referentially transparent (so two values that are equal to the same expression are necessarily not distinct) and all values are immutable.
<syntaxhighlight lang
in an appropriate do block. If it is distinguished by, say, a numeric label, one could write
<syntaxhighlight lang
An incorrect version:
<
return (replicate n x)</
=={{header|Icon}} and {{header|Unicon}}==
Line 666:
An incorrect approach uses, e.g., the list constructor procedure with an initial value:
<syntaxhighlight lang="icon">
items_wrong := list (10, [])
# prints '0' for size of each item
Line 674:
# now prints '1' for size of each item
every item := !items_wrong do write (*item)
</syntaxhighlight>
A correct approach initialises each element separately:
<syntaxhighlight lang="icon">
items := list(10)
every i := 1 to 10 do items[i] := []
</syntaxhighlight>
=={{header|J}}==
<syntaxhighlight lang
Example use:
<
0 1 2 3</
J almost always uses pass-by-value, so this topic is not very relevant to J.
Line 698:
{{works with|Java|1.5+}}
simple array:
<
for (int i = 0; i < foos.length; i++)
foos[i] = new Foo();
Line 704:
// incorrect version:
Foo[] foos_WRONG = new Foo[n];
Arrays.fill(foos, new Foo()); // new Foo() only evaluated once</
simple list:
<
for (int i = 0; i < n; i++)
foos.add(new Foo());
// incorrect:
List<Foo> foos_WRONG = Collections.nCopies(n, new Foo()); // new Foo() only evaluated once</
Generic version for class given at runtime:
It's not pretty but it gets the job done. The first method here is the one that does the work. The second method is a convenience method so that you can pass in a <tt>String</tt> of the class name. When using the second method, be sure to use the full class name (ex: "java.lang.String" for "String"). <tt>InstantiationException</tt>s will be thrown when instantiating classes that you would not normally be able to call <tt>new</tt> on (abstract classes, interfaces, etc.). Also, this only works on classes that have a no-argument constructor, since we are using <code>newInstance()</code>.
<
List<E> ans = new LinkedList<E>();
try {
Line 733:
throws ClassNotFoundException{
return getNNewObjects(n, Class.forName(className));
}</
=={{header|JavaScript}}==
Line 739:
===ES5===
<
for (var i = 0; i < n; i++)
a[i] = new Foo();</
===ES6===
<
let nObjects = n => Array.from({
Line 759:
return nObjects(6);
})(6);</
{{Out}}
<
{"index":4}, {"index":5}, {"index":6}]</
=={{header|jq}}==
jq does not have mutable data types, and therefore in the context of jq, the given task is probably of little interest. However, it is possible to fulfill the task requirements for jq types other than "null" and "boolean":<
def Array(atype; n):
if atype == "number" then [ range(0;n) ]
Line 786:
# Example:
Array("object"; 4)</
=={{header|Julia}}==
A potential mistake would be writing:
<syntaxhighlight lang="julia">
foo() = rand() # repeated calls change the result with each call
repeat([foo()], outer=5) # but this only calls foo() once, clones that first value
</syntaxhighlight>
If the effect of calling foo() with every iteration is desired, better to use:
<syntaxhighlight lang="julia">
[foo() for i in 1:5] # Code this to call the function within each iteration
</syntaxhighlight>
=={{header|Kotlin}}==
<
class Foo {
Line 825:
val fooList2 = List(n) { f }
for (foo in fooList2) println(foo.id)
}</
{{out}}
Line 841:
We construct an array of the appropriate length and then replace each element with a new object.
<
We can verify that these are in fact distinct objects by checking their ID.
<
arr visit {
Kernel id printObject.
}.</
=={{header|Logtalk}}==
Using prototypes, we first dynamically create a protocol to declare a predicate and then create ten prototypes implementing that protocol, which one with a different definition for the predicate:
<
| ?- create_protocol(statep, [], [public(state/1)]),
findall(
Line 861:
).
Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].
</syntaxhighlight>
Using classes, we first dynamically create a class (that is its own metaclass) to declare a predicate (and define a default value for it) and then create ten instances of the class, which one with a different definition for the predicate:
<
| ?- create_object(state, [instantiates(state)], [public(state/1)], [state(0)]),
findall(
Line 872:
).
Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].
</syntaxhighlight>
=={{header|Lua}}==
<
local table1 = {1,2,3}
Line 891:
-- Now we can create a table of independent copies of table1
local copyTab = {}
for i = 1, 10 do copyTab[i] = copy(table1) end</
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
Form 60, 40
Line 936:
}
Checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
The mistake is often written as:
<
Here Random[] can be any expression that returns a new value which is incorrect since Random[] is only evaluated once. e.g.
Line 947:
A correct version is:
<
which evaluates Random[] each time e.g.
Line 953:
=={{header|Maxima}}==
<
b: makelist(copy(a), 3);
Line 961:
b;
[[1,1000],[1,2],[1,2]]</
=={{header|Modula-3}}==
Similar to the [[Ada]] version above:
<
This creates an array of distinct elements of type <code>T</code>. A type may specify a default value for its fields, so long as the values are compile-time constants. Similarly, an array can initialize its entries to multiple different values, also compile-time constants. Naturally, a program may initialize this data at run-time using a <code>FOR</code> loop.
Line 971:
The example program below demonstrates each of these methods, including the mistaken way, so is a bit long.
<
IMPORT IO, Random;
Line 1,026:
IO.PutChar('\n');
END DistinctObjects.</
{{out}}
Each line interleaves the initial values of <code>a</code> and <code>b</code>. The first one has default values; the second replaces the values of <code>a</code> with random, "re-initialized" integers. Only <code>a[3]</code> starts with the default value for <code>T</code>; see the seventh number in the first line. On the other hand, the modification of "one" element of <code>c</code> actually modifies every element, precisely because it is a reference and not an object.
Line 1,037:
Incorrect, same object n times:
<
Correct:
<syntaxhighlight lang
=={{header|Nim}}==
Line 1,047:
We give some examples with sequences of sequences and sequences of references:
<
# Creating a sequence containing sequences of integers.
Line 1,076:
echo "s4 contains references to ", s4.mapIt(it[]).join(", ") # 1, 1, 1, 1, 1
s4[0][] = 2
echo "s4 contains references to ", s4.mapIt(it[]).join(", ") # 2, 2, 2, 2, 2</
=={{header|OCaml}}==
Line 1,082:
Incorrect:
<
(* here (new foo) can be any expression that returns a new object,
record, array, or string *)</
which is incorrect since <code>new foo</code> is only evaluated once. A correct version is:
<
=={{header|Oforth}}==
Line 1,092:
The right way : the block sent as parameter is performed n times :
<
{{out}}
Line 1,103:
The "wrong" way : the same value is stored n times into the list buffer
<
{{out}}
Line 1,113:
=={{header|ooRexx}}==
<
array = fillArrayWith(3, .directory)
say "each object will have a different identityHash"
Line 1,131:
end
return array</
{{out}}
<pre>each object will have a different identityHash
Line 1,141:
=={{header|Oz}}==
With lists, it is difficult to do wrong.
<
Xs = {MakeList 5} %% a list of 5 unbound variables
in
{ForAll Xs OS.rand} %% fill it with random numbers (CORRECT)
{Show Xs}</
With arrays on the other hand, it is easy to get wrong:
<
Arr = {Array.new 0 10 {OS.rand}} %% WRONG: contains ten times the same number
in
Line 1,154:
for I in {Array.low Arr}..{Array.high Arr} do
Arr.I := {OS.rand}
end</
=={{header|Pascal}}==
Line 1,161:
=={{header|Perl}}==
incorrect:
<
# here Foo->new can be any expression that returns a reference representing
# a new object</
which is incorrect since <code>Foo->new</code> is only evaluated once.
A correct version is:
<
which evaluates <tt>Foo->new</tt> <var>$n</var> times and collects each result in a list.
Line 1,175:
However, JavaScript uses pass-by-sharing semantics, so if (and only if) we specify "with javascript_semantics" (or just "with js" for short) the last line triggers a "p2js violation" error on desktop/Phix, indicating it must be changed (as shown).
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"x"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>
Line 1,182:
<span style="color: #000080;font-style:italic;">-- s[2] = s ?s</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>
<!--</
{{out}}
<pre>
Line 1,192:
Note that the last statement did not create a circular structure, something that is not possible in Phix, except (perhaps) via index-emulation.<br>
I suppose it is possible that someone could write
<!--<
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">my_func</span><span style="color: #0000FF;">(),</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<!--</
and expect my_func() to be invoked 5 times, but for that you need a loop
<!--<
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">my_func</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
There are in fact two "reference" types in phix: dictionaries and classes, which are created using the function calls new_dict() and new() respectively.<br>
In the same manner as above if you want five distinct dictionaries or classes, you must invoke new_dict()/new() five times.
Line 1,207:
=={{header|PicoLisp}}==
Create 5 distinct (empty) objects:
<
-> ($384717187 $384717189 $384717191 $384717193 $384717195)</
Create 5 anonymous symbols with the values 1 .. 5:
<
-> ($384721107 $384721109 $384721111 $384721113 $384721115)
: (val (car @))
-> 1
: (val (cadr @@))
-> 2</
=={{header|PowerShell}}==
Do some randomization that could easily return three equal values (but each value is a separate value in the array):
<syntaxhighlight lang="powershell">
1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |
Select-Object -Unique |
ForEach-Object {$_.ToString()}
</syntaxhighlight>
{{Out}}
<pre>
Line 1,231:
</pre>
Run the same commands a few times and the <code>Select-Object -Unique</code> command filters equal (but separate values):
<syntaxhighlight lang="powershell">
1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |
Select-Object -Unique |
ForEach-Object {$_.ToString()}
</syntaxhighlight>
{{Out}}
<pre>
Line 1,243:
=={{header|PureBasic}}==
<
Dim A.i(n)
; Creates a Array of n [25-75] elements depending on the outcome of Random().
Line 1,267:
Next
; Verify by sending each value of A() via *PointersToA()
; to the debugger's output.</
=={{header|Python}}==
The mistake is often written as:
<
which is incorrect since <tt>Foo()</tt> is only evaluated once. A common correct version is:
<
which evaluates <tt>Foo()</tt> <var>n</var> times and collects each result in a list. This last form is also discussed [[Two-dimensional array (runtime)#Python|here]], on the correct construction of a two dimensional array.
=={{header|R}}==
The mistake is often written as:
<
A common correct version is:
<syntaxhighlight lang
which evaluates foo() n times and collects each result in a list. (Using simplify=TRUE lets the function return an array, where possible.)
=={{header|Racket}}==
<
#lang racket
Line 1,293:
;; a list of 10 distinct vectors
(build-list 10 (λ (n) (make-vector 10 0)))
</syntaxhighlight>
=={{header|Raku}}==
Line 1,300:
Unlike in Perl 5, the list repetition operator evaluates the left argument thunk each time, so
<syntaxhighlight lang="raku"
produces <code>$n</code> distinct objects.
Line 1,307:
=={{header|REXX}}==
This entry is modeled after the '''Erlang''' entry.
<
parse arg n lim . /*obtain optional argument from the CL.*/
if n=='' | n=="," then n= 1000 /*Not specified? Then use the default.*/
Line 1,323:
end /*j*/
say words(randoms) ' unique numbers generated.' /*stick a fork in it, we're all done. */</
<br><br>
=={{header|Ruby}}==
The mistake is often written as one of these:
<
Array.new(n, Foo.new)</
which are incorrect since <code>Foo.new</code> is only evaluated once, and thus you now have <var>n</var> references to the ''same'' object. A common correct version is:
<
which evaluates <code>Foo.new</code> <var>n</var> times and collects each result in an Array. This last form is also discussed [[Two-dimensional array (runtime)#Ruby|here]], on the correct construction of a two dimensional array.
=={{header|Rust}}==
<
use std::cell::RefCell;
Line 1,355:
v[0].borrow_mut().push('a');
println!("{:?}", v);
}</
{{out}}
<pre>["a", "", ""]
Line 1,365:
if created with the same constructor arguments.
<
=={{header|Scheme}}==
Line 1,396:
The [http://seed7.sourceforge.net/libraries/array.htm#%28in_integer%29times%28in_baseType%29 times] operator creates a new array value with a specified size.
Finally multiple distinct objects are assigned to the array elements.
<
const func array file: openFiles (in array string: fileNames) is func
Line 1,415:
begin
files := openFiles([] ("abc.txt", "def.txt", "ghi.txt", "jkl.txt"));
end func;</
=={{header|Sidef}}==
<
<
=={{header|Smalltalk}}==
<
"Create an ordered collection that will grow while we add elements"
c := OrderedCollection new.
Line 1,435:
1 to: 9 do: [ :i | (c at: i) at: 4 put: i ].
"show it"
c do: [ :e | e printNl ].</
=={{header|Swift}}==
<
var foos = [Foo]()
Line 1,446:
// incorrect version:
var foos_WRONG = [Foo](count: n, repeatedValue: Foo()) // Foo() only evaluated once</
=={{header|Tcl}}==
Line 1,452:
{{works with|Tcl|8.6}} or {{libheader|TclOO}}
<
# The class that we want to make unique instances of
Line 1,464:
for {set i 0} {$i<$n} {incr i} {
lappend theList [$theClass new]
}</
=={{header|Wren}}==
<
static init() { __count = 0 } // set object counter to zero
Line 1,491:
// Show they're the same by printing out their object numbers
foos2.each { |f| System.write("%(f.number) ") }
System.print()</
{{out}}
Line 1,501:
=={{header|XPL0}}==
<
char A; int N, I;
[N:= IntIn(8); \get number of items from command line
Line 1,507:
for I:= 0 to N-1 do A(I):= I*3; \initialize items with different values
for I:= 0 to N-1 do A:= I*3; \error: "references to the same mutable object"
]</
=={{header|Yabasic}}==
<
print "Random number: " + str$(ran(100))
end sub
Line 1,529:
for i = 1 to n
execute(func$(i))
next i</
Line 1,535:
Variables in assembly languages don't work the same as they do in high-level languages, so the "n references to the same object mistake" isn't really a thing in your typical assembly language. This is as simple as creating an array of ascending values. Being an 8-bit computer, you're limited in how big <i>n</i> can be before the values repeat.
<
ld a,(foo) ;load the value of some memory location. "foo" is the label of a 16-bit address.
ld b,a ;use this as a loop counter.
Line 1,544:
inc a ;ensures each value is different.
inc hl ;next element of list
djnz loop</
=={{header|zkl}}==
The pump and partial application methods are useful tools for creating initialized lists.
<
n.pump(List) //-->L(0,1,2)
Line 1,565:
class C{ var n; fcn init(x){n=x} }
n.pump(List,C) //--> L(C,C,C)
n.pump(List,C).apply("n") //-->L(0,1,2) ie all classes distinct</
|