Multiple distinct objects: Difference between revisions

{{trans|Python}}

=={{header|Action!}}==

DEFINE OBJSIZE="4"

TYPE Record=[BYTE b CHAR c INT i]

LMARGIN=oldLMARGIN ;restore left margin on the screen

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Multiple_distinct_objects.png Screenshot from Atari 8-bit computer]

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

{

return 0;

{{out}}

<pre> [4] [4] [4] [7] [4] [4] [4] [4]</pre>

{{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;

FOR i TO UPB f DO f[i] := (REPR(ABS("A")-1+i), REPR(ABS("a")-1+i)) OD;

Output:

<pre>

=={{header|ALGOL W}}==

record T ( integer n, m );

reference(T) singleT;

for i := 1 until numberOfElements do writeon( i_w := 1, s_w := 0, n(tArray( i )), ", ", m(tArray( i )), "; " )

end

{{out}}

<pre>

=={{header|AppleScript}}==

-- nObjects Constructor -> Int -> [Object]

end script

end if

{{Out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

Loop, %n%

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

n% = RND(1000)

FOR i% = 0 TO DIM(objects%(),1)

objects%(i%) = object{}

=={{header|Brat}}==

The wrong way, which creates an array of ''n'' references to the same new ''foo'':

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

(Or if no particular initialization is needed, skip that part, or use <tt>calloc</tt>.)

=={{header|C sharp|C#}}==

using System.Linq;

using System.Collections.Generic;

=={{header|C++}}==

Using only language primitives:

T* p = new T[n]; // if T is POD, the objects are uninitialized, otherwise they are default-initialized

// when you don't need the objects any more, get rid of them

Using the standard library

#include <algorithm>

#include <iterator>

// To initialise each value differently

std::generate_n(std::back_inserter(vec), n, makeT); //makeT is a function of type T(void)

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.

These examples assume T has a public copy constructor, and that p is a pointer to T;

#include <tr1/memory>

using namespace std;

bvec2.push_back(TPtr_t(new T(*p));

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)

=={{header|Common Lisp}}==

The mistake is often written as one of these:

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:

=={{header|D}}==

For reference types (classes):

foreach (ref item; fooArray)

item = new Foo();

For value types:

=={{header|Delphi}}==

Same object accessed multiple times (bad)

i: Integer;

lObject: TMyObject;

for i := 1 to 10 do

lList.Add(lObject);

Distinct objects (good)

i: Integer;

lList: TObjectList<TMyObject>;

for i := 1 to 10 do

lList.Add(TMyObject.Create);

=={{header|E}}==

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

...

=={{header|EchoLisp}}==

;; wrong - make-vector is evaluated one time - same vector

L → (#(0 🔵 0 0) #(0 0 0 0) #(0 0 0 0)) ;; OK

=={{header|Elena}}==

import extensions;

{

var foos := fill(10);

=={{header|Elixir}}==

=={{header|Erlang}}==

=={{header|F_Sharp|F#}}==

The wrong way:

val it : Guid list =

[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;

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

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

list each: drop . 1301600

list each: drop . 1301600

=={{header|Fortran}}==

program multiple

! Define a simple type

end program multiple

=={{header|Go}}==

Useful:

d2 := make([][]int, n)

for i := range d2 {

}

return d2

Probably not what the programmer wanted:

d1 := make([]int, m)

d2 := make([][]int, n)

}

return d2

=={{header|Groovy}}==

Correct Solution:

Incorrect Solution:

Test:

print "Objects distinct for n = "

(2..<20).each { n ->

}

println()

Output:

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.

in an appropriate do block. If it is distinguished by, say, a numeric label, one could write

An incorrect version:

=={{header|Icon}} and {{header|Unicon}}==

An incorrect approach uses, e.g., the list constructor procedure with an initial value:

items_wrong := list (10, [])

# prints '0' for size of each item

# now prints '1' for size of each item

every item := !items_wrong do write (*item)

A correct approach initialises each element separately:

items := list(10)

every i := 1 to 10 do items[i] := []

=={{header|J}}==

Example use:

J almost always uses pass-by-value, so this topic is not very relevant to J.

{{works with|Java|1.5+}}

simple array:

for (int i = 0; i < foos.length; i++)

foos[i] = new Foo();

// incorrect version:

Foo[] foos_WRONG = new Foo[n];

simple list:

for (int i = 0; i < n; i++)

foos.add(new Foo());

// incorrect:

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 {

throws ClassNotFoundException{

return getNNewObjects(n, Class.forName(className));

=={{header|JavaScript}}==

===ES5===

for (var i = 0; i < n; i++)

===ES6===

let nObjects = n => Array.from({

return nObjects(6);

{{Out}}

=={{header|jq}}==

def Array(atype; n):

if atype == "number" then [ range(0;n) ]

# Example:

=={{header|Julia}}==

A potential mistake would be writing:

foo() = rand() # repeated calls change the result with each call

repeat([foo()], outer=5) # but this only calls foo() once, clones that first value

If the effect of calling foo() with every iteration is desired, better to use:

[foo() for i in 1:5] # Code this to call the function within each iteration

=={{header|Kotlin}}==

class Foo {

val fooList2 = List(n) { f }

for (foo in fooList2) println(foo.id)

{{out}}

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(

).

Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].

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(

).

Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10].

=={{header|Lua}}==

local table1 = {1,2,3}

-- Now we can create a table of independent copies of table1

local copyTab = {}

=={{header|M2000 Interpreter}}==

Module CheckIt {

Form 60, 40

}

Checkit

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

A correct version is:

which evaluates Random[] each time e.g.

=={{header|Maxima}}==

b: makelist(copy(a), 3);

b;

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

The example program below demonstrates each of these methods, including the mistaken way, so is a bit long.

IMPORT IO, Random;

IO.PutChar('\n');

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

Incorrect, same object n times:

Correct:

=={{header|Nim}}==

We give some examples with sequences of sequences and sequences of references:

# Creating a sequence containing sequences of integers.

echo "s4 contains references to ", s4.mapIt(it[]).join(", ") # 1, 1, 1, 1, 1

s4[0][] = 2

=={{header|OCaml}}==

Incorrect:

(* here (new foo) can be any expression that returns a new object,

which is incorrect since <code>new foo</code> is only evaluated once. A correct version is:

=={{header|Oforth}}==

The right way : the block sent as parameter is performed n times :

{{out}}

The "wrong" way : the same value is stored n times into the list buffer

{{out}}

=={{header|ooRexx}}==

array = fillArrayWith(3, .directory)

say "each object will have a different identityHash"

end

{{out}}

<pre>each object will have a different identityHash

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

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

for I in {Array.low Arr}..{Array.high Arr} do

Arr.I := {OS.rand}

=={{header|Pascal}}==

=={{header|Perl}}==

incorrect:

# here Foo->new can be any expression that returns a reference representing

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.

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>

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

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.

=={{header|PicoLisp}}==

Create 5 distinct (empty) objects:

Create 5 anonymous symbols with the values 1 .. 5:

-> ($384721107 $384721109 $384721111 $384721113 $384721115)

: (val (car @))

-> 1

: (val (cadr @@))

=={{header|PowerShell}}==

Do some randomization that could easily return three equal values (but each value is a separate value in the array):

1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |

Select-Object -Unique |

ForEach-Object {$_.ToString()}

{{Out}}

<pre>

</pre>

Run the same commands a few times and the <code>Select-Object -Unique</code> command filters equal (but separate values):

1..3 | ForEach-Object {((Get-Date -Hour ($_ + (1..4 | Get-Random))).AddDays($_ + (1..4 | Get-Random)))} |

Select-Object -Unique |

ForEach-Object {$_.ToString()}

{{Out}}

<pre>

=={{header|PureBasic}}==

Dim A.i(n)

; Creates a Array of n [25-75] elements depending on the outcome of Random().

Next

; Verify by sending each value of A() via *PointersToA()

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

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

;; a list of 10 distinct vectors

(build-list 10 (λ (n) (make-vector 10 0)))

=={{header|Raku}}==

Unlike in Perl 5, the list repetition operator evaluates the left argument thunk each time, so

produces <code>$n</code> distinct objects.

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

end /*j*/

<br><br>

=={{header|Ruby}}==

The mistake is often written as one of these:

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;

v[0].borrow_mut().push('a');

println!("{:?}", v);

{{out}}

<pre>["a", "", ""]

if created with the same constructor arguments.

=={{header|Scheme}}==

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

begin

files := openFiles([] ("abc.txt", "def.txt", "ghi.txt", "jkl.txt"));

=={{header|Sidef}}==

=={{header|Smalltalk}}==

"Create an ordered collection that will grow while we add elements"

c := OrderedCollection new.

1 to: 9 do: [ :i | (c at: i) at: 4 put: i ].

"show it"

=={{header|Swift}}==

var foos = [Foo]()

// incorrect version:

=={{header|Tcl}}==

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

# The class that we want to make unique instances of

for {set i 0} {$i<$n} {incr i} {

lappend theList [$theClass new]

=={{header|Wren}}==

static init() { __count = 0 } // set object counter to zero

// Show they're the same by printing out their object numbers

foos2.each { |f| System.write("%(f.number) ") }

{{out}}

=={{header|XPL0}}==

char A; int N, I;

[N:= IntIn(8); \get number of items from command line

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

for i = 1 to n

execute(func$(i))

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.

inc a ;ensures each value is different.

inc hl ;next element of list

=={{header|zkl}}==

The pump and partial application methods are useful tools for creating initialized lists.

n.pump(List) //-->L(0,1,2)

class C{ var n; fcn init(x){n=x} }

n.pump(List,C) //--> L(C,C,C)