Multiple distinct objects
You are encouraged to solve this task according to the task description, using any language you may know.
Create a sequence (array, list, whatever) consisting of n distinct, initialized items of the same type. n should be determined at runtime.
By distinct we mean that if they are mutable, changes to one do not affect all others; if there is an appropriate equality operator they are considered unequal; etc. The code need not specify a particular kind of distinction, but do not use e.g. a numeric-range generator which does not generalize.
By initialized we mean that each item must be in a well-defined state appropriate for its type, rather than e.g. arbitrary previous memory contents in an array allocation. Do not show only an initialization technique which initializes only to "zero" values (e.g. calloc() or int a[n] = {}; in C), unless user-defined types can provide definitions of "zero" for that type.
This task was inspired by the common error of intending to do this, but instead creating a sequence of n references to the same mutable object; it might be informative to show the way to do that as well, both as a negative example and as how to do it when that's all that's actually necessary.
This task is most relevant to languages operating in the pass-references-by-value style (most object-oriented, garbage-collected, and/or 'dynamic' languages).
Ada
<lang ada>A : array (1..N) of T;</lang> 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: <lang ada>A : array (1..N) of T := (others => V);</lang> 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: <lang ada>(1..N => V)</lang>
Aime
<lang aime>void show_sublist(list l) {
integer i;
i = 0;
while (i < l_length(l)) {
if (i) {
o_space(1);
}
o_integer(l_q_integer(l, i));
i += 1;
}
}
void show_list(list l) {
integer i;
i = 0;
while (i < l_length(l)) {
o_text(" [");
show_sublist(l_q_list(l, i));
o_text("]");
i += 1;
}
o_byte('\n');
}
list multiple_distinct(integer n, object o) {
list l;
while (n) {
l_append(l, o);
n -= 1;
}
return l;
}
integer main(void) {
list l, z;
# create a list of integers - `3' will serve as initializer l = multiple_distinct(8, 3);
l_clear(l);
# create a list of distinct lists - `z' will serve as initializer l_append(z, 4); l = multiple_distinct(8, z);
# modify one of the sublists l_r_integer(l_q_list(l, 3), 0, 7);
# display the list of lists show_list(l);
return 0;
}</lang>
- Output:
[4] [4] [4] [7] [4] [4] [4] [4]
ALGOL 68
<lang algol68>MODE FOO = STRUCT(CHAR u,l); INT n := 26; [n]FOO f;
- Additionally each item can be initialised #
FOR i TO UPB f DO f[i] := (REPR(ABS("A")-1+i), REPR(ABS("a")-1+i)) OD;
print((f, new line))</lang> Output:
AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz
AutoHotkey
<lang AutoHotkey>a := [] Loop, %n%
a[A_Index] := new Foo()</lang>
BBC BASIC
<lang bbcbasic> REM Determine object count at runtime:
n% = RND(1000)
REM Declare an array of structures; all members are initialised to zero:
DIM objects{(n%) a%, b$}
REM Initialise the objects to distinct values:
FOR i% = 0 TO DIM(objects{()},1)
objects{(i%)}.a% = i%
objects{(i%)}.b$ = STR$(i%)
NEXT
REM This is how to create an array of pointers to the same object:
DIM objects%(n%), object{a%, b$}
FOR i% = 0 TO DIM(objects%(),1)
objects%(i%) = object{}
NEXT</lang>
Brat
The wrong way, which creates an array of n references to the same new foo:
<lang brat>n.of foo.new</lang>
The right way, which calls the block n times and creates an array of new foos:
<lang brat>n.of { foo.new }</lang>
C
<lang c>foo *foos = malloc(n * sizeof(*foos)); for (int i = 0; i < n; i++)
init_foo(&foos[i]);</lang>
(Or if no particular initialization is needed, skip that part, or use calloc.)
C++
By default C++ has value semantics, so this problem does not present itself unless the programmer deliberately choses to refer to objects though a pointer. Examples are given for both cases.
Using only language primitives: <lang cpp>// this assumes T is a default-constructible type (all built-in types are) T* p = new T[n]; // if T is POD, the objects are uninitialized, otherwise they are default-initialized
//If default initialisation is not what you want, or if T is a POD type which will be uninitialized for(size_t i = 0; i != n; ++i)
p[i] = make_a_T(); //or some other expression of type T
// when you don't need the objects any more, get rid of them delete[] p;</lang>
Using the standard library <lang cpp>#include <vector>
- include <algorithm>
- include <iterator>
// this assumes T is default-constructible std::vector<T> vec1(n); // all n objects are default-initialized
// this assumes t is a value of type T (or a type which implicitly converts to T) std::vector<T> vec2(n, t); // all n objects are copy-initialized with t
// To initialise each value differently std::generate_n(std::back_inserter(vec), n, makeT); //makeT is a function of type T(void) </lang>
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;
<lang cpp>#include <vector>
- include <tr1/memory>
using namespace std; using namespace std::tr1;
typedef shared_ptr<T> TPtr_t; // the following is NOT correct: std::vector<TPtr_t > bvec_WRONG(n, p); // create n copies of p, which all point to the same opject p points to.
// nor is this: std::vector<TPtr_t> bvec_ALSO_WRONG(n, TPtr_t(new T(*p)) ); // create n pointers to a single copy of *p
// the correct solution std::vector<TPtr_t > bvec(n); for (int i = 0; i < n; ++i)
bvec[i] = TPtr_t(new T(*p); //or any other call to T's constructor
// another correct solution // this solution avoids uninitialized pointers at any point std::vector<TPtr_t> bvec2; for (int i = 0; i < n; ++i)
bvec2.push_back(TPtr_t(new T(*p));
</lang> Of course, also in this case one can use the other sequence containers or plain new/delete instead of vector.
C#
<lang csharp>using System; using System.Linq; using System.Collections.Generic;
List<Foo> foos = Enumerable.Range(1, n).Select(x => new Foo()).ToList();</lang>
Clojure
An example using pseudo-random numbers: <lang clojure>user> (take 3 (repeat (rand))) ; repeating the same random number three times (0.2787011365537204 0.2787011365537204 0.2787011365537204) user> (take 3 (repeatedly rand)) ; creating three different random number (0.8334795669220695 0.08405601245793926 0.5795448744634744) user></lang>
Common Lisp
The mistake is often written as one of these:
<lang lisp>(make-list n :initial-element (make-the-distinct-thing))
(make-array n :initial-element (make-the-distinct-thing))</lang>
which are incorrect since the form (make-the-distinct-thing) is only evaluated once and the single object is put in every position of the sequence. A commonly used correct version is:
<lang lisp>(loop repeat n collect (make-the-distinct-thing))</lang>
which evaluates (make-the-distinct-thing) n times and collects each result in a list.
It is also possible to use map-into, 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:
<lang lisp>(map-into (make-list n) #'make-the-distinct-thing) (map-into (make-array n) #'make-the-distinct-thing)</lang>
D
For reference types (classes): <lang d>auto fooArray = new Foo[n]; foreach (ref item; fooArray)
item = new Foo();
</lang>
For value types: <lang d>auto barArray = new Bar[n]; barArray[] = initializerValue;</lang>
Delphi
Same object accessed multiple times (bad) <lang Delphi>var
i: Integer; lObject: TMyObject; lList: TObjectList<TMyObject>;
begin
lList := TObjectList<TMyObject>.Create; lObject := TMyObject.Create; for i := 1 to 10 do lList.Add(lObject); // ...</lang>
Distinct objects (good) <lang Delphi>var
i: Integer; lList: TObjectList<TMyObject>;
begin
lList := TObjectList<TMyObject>.Create; for i := 1 to 10 do lList.Add(TMyObject.Create); // ...</lang>
E
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.
<lang e>pragma.enable("accumulator") ...
accum [] for _ in 1..n { _.with(makeWhatever()) }</lang>
EchoLisp
<lang scheme>
- wrong - make-vector is evaluated one time - same vector
(define L (make-list 3 (make-vector 4))) L → (#(0 0 0 0) #(0 0 0 0) #(0 0 0 0)) (vector-set! (first L ) 1 '🔴) ;; sets the 'first' vector
L → (#(0 🔴 0 0) #(0 🔴 0 0) #(0 🔴 0 0))
- right - three different vectors
(define L(map make-vector (make-list 3 4))) L → (#(0 0 0 0) #(0 0 0 0) #(0 0 0 0)) (vector-set! (first L ) 1 '🔵) ;; sets the first vector
L → (#(0 🔵 0 0) #(0 0 0 0) #(0 0 0 0)) ;; OK </lang>
Elixir
<lang elixir>randoms = for _ <- 1..10, do: :random.uniform(1000)</lang>
Erlang
List comprehension that will create 20 random integers between 1 and 1000. They will only be equal by accident.
Randoms = [random:uniform(1000) || _ <- lists:seq(1,10)].
Factor
clone is the important word here to have distinct objects. This creates an array of arrays. <lang factor>1000 [ { 1 } clone ] replicate</lang>
Forth
Works with any ANS Forth
Needs the FMS-SI (single inheritance) library code located here: http://soton.mpeforth.com/flag/fms/index.html <lang forth>include FMS-SI.f include FMS-SILib.f
\ create a list of VAR objects the right way
\ each: returns a unique object reference
o{ 0 0 0 } dup p: o{ 0 0 0 }
dup each: drop . 10774016
dup each: drop . 10786896
dup each: drop . 10786912
\ create a list of VAR objects the wrong way
\ each: returns the same object reference
var x
object-list2 list
x list add:
x list add:
x list add:
list p: o{ 0 0 0 }
list each: drop . 1301600
list each: drop . 1301600
list each: drop . 1301600
</lang>
Fortran
<lang fortran> program multiple
! Define a simple type
type T
integer :: a = 3
end type T
! Define a type containing a pointer
type S
integer, pointer :: a
end type S
type(T), allocatable :: T_array(:) type(S), allocatable :: S_same(:) integer :: i integer, target :: v integer, parameter :: N = 10
! Create 10 allocate(T_array(N))
! Set the fifth one to b something different T_array(5)%a = 1
! Print them out to show they are distinct write(*,'(10i2)') (T_array(i),i=1,N)
! Create 10 references to the same object
allocate(S_same(N))
v = 5
do i=1, N
allocate(S_same(i)%a)
S_same(i)%a => v
end do
! Print them out - should all be 5 write(*,'(10i2)') (S_same(i)%a,i=1,N)
! Change the referenced object and reprint - should all be 3 v = 3 write(*,'(10i2)') (S_same(i)%a,i=1,N)
end program multiple </lang>
F#
The wrong way: <lang fsharp>>List.replicate 3 (System.Guid.NewGuid());;
val it : Guid list =
[485632d7-1fd6-4d9e-8910-7949d7b2b485; 485632d7-1fd6-4d9e-8910-7949d7b2b485; 485632d7-1fd6-4d9e-8910-7949d7b2b485]</lang>
The right way: <lang fsharp>> List.init 3 (fun _ -> System.Guid.NewGuid());;
val it : Guid list =
[447acb0c-092e-4f85-9c3a-d369e4539dae; 5f41c04d-9bc0-4e96-8165-76b41fe8cd93; 1086400c-72ff-4763-9bb9-27e17bd4c7d2]</lang>
Go
Useful: <lang go>func nxm(n, m int) [][]int {
d2 := make([][]int, n)
for i := range d2 {
d2[i] = make([]int, m)
}
return d2
}</lang> Probably not what the programmer wanted: <lang go>func nxm(n, m int) [][]int {
d1 := make([]int, m)
d2 := make([][]int, n)
for i := range d2 {
d2[i] = d1
}
return d2
}</lang>
Groovy
Correct Solution: <lang groovy>def createFoos1 = { n -> (0..<n).collect { new Foo() } }</lang>
Incorrect Solution: <lang groovy>// Following fails, creates n references to same object def createFoos2 = {n -> [new Foo()] * n }</lang>
Test: <lang groovy>[createFoos1, createFoos2].each { createFoos ->
print "Objects distinct for n = "
(2..<20).each { n ->
def foos = createFoos(n)
foos.eachWithIndex { here, i ->
foos.eachWithIndex { there, j ->
assert (here == there) == (i == j)
}
}
print "${n} "
}
println()
}</lang>
Output:
Objects distinct for n = 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
Objects distinct for n = Caught: Assertion failed:
assert (here == there) == (i == j)
| | | | | | |
| | | | 0 | 1
| | | false false
| | Foo@19c8ef56
| true
Foo@19c8ef56
Haskell
Below, we are assuming that makeTheDistinctThing is a monadic expression (i.e. it has type m a where m is some monad, like IO or ST), 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.
<lang haskell>replicateM n makeTheDistinctThing</lang>
in an appropriate do block. If it is distinguished by, say, a numeric label, one could write
<lang haskell>mapM makeTheDistinctThing [1..n]</lang>
An incorrect version: <lang haskell>do x <- makeTheDistinctThing
return (replicate n x)</lang>
Icon and Unicon
An incorrect approach uses, e.g., the list constructor procedure with an initial value:
<lang Icon>
items_wrong := list (10, []) # prints '0' for size of each item every item := !items_wrong do write (*item) # after trying to add an item to one of the lists push (items_wrong[1], 2) # now prints '1' for size of each item every item := !items_wrong do write (*item)
</lang>
A correct approach initialises each element separately:
<lang Icon>
items := list(10) every i := 1 to 10 do items[i] := []
</lang>
J
<lang J>i.</lang>
Example use:
<lang J> i. 4 0 1 2 3</lang>
J almost always uses pass-by-value, so this topic is not very relevant to J.
Note also that J offers a variety of other ways of generating multiple distinct objects. This just happens to be one of the simplest of them. In essence, though: generating multiple distinct objects is what J *does* - this is an elemental feature of most of the primitives.
Java
simple array: <lang java>Foo[] foos = new Foo[n]; // all elements initialized to null for (int i = 0; i < foos.length; i++)
foos[i] = new Foo();
// incorrect version: Foo[] foos_WRONG = new Foo[n]; Arrays.fill(foos, new Foo()); // new Foo() only evaluated once</lang>
simple list: <lang java5>List<Foo> foos = new ArrayList<Foo>(); 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</lang>
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 String of the class name. When using the second method, be sure to use the full class name (ex: "java.lang.String" for "String"). InstantiationExceptions will be thrown when instantiating classes that you would not normally be able to call new on (abstract classes, interfaces, etc.). Also, this only works on classes that have a no-argument constructor, since we are using newInstance().
<lang java5>public static <E> List<E> getNNewObjects(int n, Class<? extends E> c){
List<E> ans = new LinkedList<E>();
try {
for(int i=0;i<n;i++)
ans.add(c.newInstance());//can't call new on a class object
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return ans;
}
public static List<Object> getNNewObjects(int n, String className) throws ClassNotFoundException{ return getNNewObjects(n, Class.forName(className)); }</lang>
JavaScript
<lang javascript>var a = new Array(n); for (var i = 0; i < n; i++)
a[i] = new Foo();</lang>
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":<lang jq> def Array(atype; n):
if atype == "number" then [ range(0;n) ]
elif atype == "object" then [ range(0;n)| {"value": . } ]
elif atype == "array" then [ range(0;n)| [.] ]
elif atype == "string" then [ range(0;n)| tostring ]
elif atype == "boolean" then
if n == 0 then [] elif n == 1 then [false] elif n==2 then [false, true]
else error("there are only two boolean values")
end
elif atype == "null" then
if n == 0 then [] elif n == 1 then [null]
else error("there is only one null value")
end
else error("\(atype) is not a jq type")
end;
- Example:
Array("object"; 4)</lang>
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: <lang logtalk> | ?- create_protocol(statep, [], [public(state/1)]),
findall(
Id,
(integer::between(1, 10, N),
create_object(Id, [implements(statep)], [], [state(N)])),
Ids
).
Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10]. </lang> 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: <lang logtalk> | ?- create_object(state, [instantiates(state)], [public(state/1)], [state(0)]),
findall(
Id,
(integer::between(1, 10, N),
create_object(Id, [instantiates(state)], [], [state(N)])),
Ids
).
Ids = [o1, o2, o3, o4, o5, o6, o7, o8, o9, o10]. </lang>
Lua
This concept is relevant to tables in Lua <lang Lua>local table1 = {1,2,3}</lang>
The following will create a table of references to table1 <lang Lua>function nRefs (t, n)
local refTab = {}
for i = 1, 10 do refTab[n] = t end
return refTab
end
local mistake = nRefs(table1, 10)</lang>
Instead, tables should be copied using a function like this <lang Lua>function copy (t)
local new = {}
for k, v in pairs(t) do new[k] = v end
return new
end</lang>
Now we can create a table of independent copies of table1 <lang Lua>function nCopies (t, n)
local copyTab = {}
for i = 1, 10 do copyTab[i] = copy(table1) end
return copyTab
end
local tableOfTables = nCopies(table1, 10)</lang>
Mathematica
The mistake is often written as: <lang Mathematica>{x, x, x, x} /. x -> Random[]</lang>
Here Random[] can be any expression that returns a new value which is incorrect since Random[] is only evaluated once. e.g. {0.175125, 0.175125, 0.175125, 0.175125}
A correct version is:
<lang Mathematica>{x, x, x, x} /. x :> Random[]</lang>
which evaluates Random[] each time e.g. ->{0.514617, 0.0682395, 0.609602, 0.00177382}
Maxima
<lang maxima>a: [1, 2]$
b: makelist(copy(a), 3); [[1,2],[1,2],[1,2]]
b[1][2]: 1000$
b; [[1,1000],[1,2],[1,2]]</lang>
Modula-3
Similar to the Ada version above: <lang modula3>VAR a: ARRAY OF T</lang> This creates an open array (an array who's size is not known until runtime) of distinct elements of type T.
Modula-3 does not define what values the elements of A have, but it does guarantee that they will be of type T.
NGS
Incorrect, same object n times: <lang NGS>{ [foo()] * n }</lang>
Correct: <lang NGS>{ n.map(F(i) foo()) }</lang>
Nim
The simplest form of initialization works, but is a bit cumbersome to write: <lang nim>proc foo(): string =
echo "Foo()" "mystring"
let n = 100
var ws = newSeq[string](n)
for i in 0 .. <n: ws[i] = foo()</lang>
If actual values instead of references are stored in the sequence, then objects can be initialized like this. Objects are distinct, but the initializer foo() is called only once, then copies of the resulting object are made:
<lang nim>proc newSeqWith[T](len: int, init: T): seq[T] =
result = newSeq[T] len for i in 0 .. <len: result[i] = init
var xs = newSeqWith(n, foo())</lang>
To get the initial behaviour, where foo() is called to create each object, a template can be used:
<lang nim>template newSeqWith2(len: int, init: expr): expr =
var result {.gensym.} = newSeq[type(init)](len)
for i in 0 .. <len:
result[i] = init
result
var ys = newSeqWith2(n, foo())</lang>
OCaml
For arrays:
Incorrect: <lang ocaml>Array.make n (new foo);; (* here (new foo) can be any expression that returns a new object,
record, array, or string *)</lang>
which is incorrect since new foo is only evaluated once. A correct version is:
<lang ocaml>Array.init n (fun _ -> new foo);;</lang>
Oforth
The right way : the block sent as parameter is performed n times :
<lang Oforth>ListBuffer init(10, #[ Float rand ]) println</lang>
- Output:
[0.281516067014556, 0.865269004241814, 0.101437334065733, 0.924166132625347, 0.88135127712 167, 0.176233635448137, 0.963837773505447, 0.570264579328023, 0.385577832707742, 0.9086026 42741616]
The "wrong" way : the same value is stored n times into the list buffer
<lang Oforth>ListBuffer initValue(10, Float rand) println</lang>
- Output:
[0.314870762000671, 0.314870762000671, 0.314870762000671, 0.314870762000671, 0.31487076200 0671, 0.314870762000671, 0.314870762000671, 0.314870762000671, 0.314870762000671, 0.314870 762000671]
ooRexx
<lang ooRexx> -- get an array of directory objects array = fillArrayWith(3, .directory) say "each object will have a different identityHash" say loop d over array
say d~identityHash
end
- routine fillArrayWith
use arg size, class
array = .array~new(size)
loop i = 1 to size
-- Note, this assumes this object class can be created with
-- no arguments
array[i] = class~new
end
return array </lang>
Oz
With lists, it is difficult to do wrong. <lang oz>declare
Xs = {MakeList 5} %% a list of 5 unbound variables
in
{ForAll Xs OS.rand} %% fill it with random numbers (CORRECT)
{Show Xs}</lang>
With arrays on the other hand, it is easy to get wrong: <lang oz>declare
Arr = {Array.new 0 10 {OS.rand}} %% WRONG: contains ten times the same number
in
%% CORRECT: fill it with ten (probably) different numbers
for I in {Array.low Arr}..{Array.high Arr} do
Arr.I := {OS.rand}
end</lang>
Pascal
See Delphi
Perl
incorrect: <lang perl>(Foo->new) x $n
- here Foo->new can be any expression that returns a reference representing
- a new object</lang>
which is incorrect since Foo->new is only evaluated once.
A correct version is: <lang perl>map { Foo->new } 1 .. $n;</lang> which evaluates Foo->new $n times and collects each result in a list.
Perl 6
Unlike in Perl 5, the list repetition operator evaluates the left argument thunk each time, so
<lang perl6>my @a = Foo.new xx $n;</lang>
produces $n distinct objects.
PicoLisp
Create 5 distinct (empty) objects: <lang PicoLisp>: (make (do 5 (link (new)))) -> ($384717187 $384717189 $384717191 $384717193 $384717195)</lang> Create 5 anonymous symbols with the values 1 .. 5: <lang PicoLisp>: (mapcar box (range 1 5)) -> ($384721107 $384721109 $384721111 $384721113 $384721115)
- (val (car @))
-> 1
- (val (cadr @@))
-> 2</lang>
PureBasic
<lang PureBasic>n=Random(50)+25 Dim A.i(n)
- Creates a Array of n [25-75] elements depending on the outcome of Random().
- Each element will be initiated to zero.
For i=0 To ArraySize(A())
A(i)=2*i
Next i
- Set each individual element at a wanted (here 2*i) value and
- automatically adjust accordingly to the unknown length of the Array.
NewList *PointersToA() For i=0 To ArraySize(A())
AddElement(*PointersToA()) *PointersToA()=@A(i)
Next
- Create a linked list of the same length as A() above.
- Each element is then set to point to the Array element
- of the same order.
ForEach *PointersToA()
Debug PeekI(*PointersToA())
Next
- Verify by sending each value of A() via *PointersToA()
- to the debugger's output.</lang>
Python
The mistake is often written as: <lang python>[Foo()] * n # here Foo() can be any expression that returns a new object</lang> which is incorrect since Foo() is only evaluated once. A common correct version is: <lang python>[Foo() for i in range(n)]</lang> which evaluates Foo() n times and collects each result in a list. This last form is also discussed here, on the correct construction of a two dimensional array.
R
The mistake is often written as: <lang r>rep(foo(), n) # foo() is any code returning a value</lang> A common correct version is: <lang r>replicate(n, foo())</lang> which evaluates foo() n times and collects each result in a list. (Using simplify=TRUE lets the function return an array, where possible.)
Racket
<lang racket>
- lang racket
- a list of 10 references to the same vector
(make-list 10 (make-vector 10 0))
- a list of 10 distinct vectors
(build-list 10 (λ (n) (make-vector 10 0))) </lang>
Ruby
The mistake is often written as one of these:
<lang ruby>[Foo.new] * n # here Foo.new can be any expression that returns a new object
Array.new(n, Foo.new)</lang>
which are incorrect since Foo.new is only evaluated once, and thus you now have n references to the same object. A common correct version is:
<lang ruby>Array.new(n) { Foo.new }</lang>
which evaluates Foo.new n times and collects each result in an Array. This last form is also discussed here, on the correct construction of a two dimensional array.
Scala
Yielding a normal class instance here (rather than a case class instance), as case objects are identical if created with the same constructor arguments.
<lang scala>for (i <- (0 until n)) yield new Foo()</lang>
Seed7
The example below defines the local array variable fileArray. The times operator creates a new array value with a specified size. Finally multiple distinct objects are assigned to the array elements. <lang seed7>$ include "seed7_05.s7i";
const func array file: openFiles (in array string: fileNames) is func
result
var array file: fileArray is 0 times STD_NULL; # Define array variable
local
var integer: i is 0;
begin
fileArray := length(fileNames) times STD_NULL; # Array size computed at run-time
for key i range fileArray do
fileArray[i] := open(fileNames[i], "r"); # Assign multiple distinct objects
end for;
end func;
const proc: main is func
local
var array file: files is 0 times STD_NULL;
begin
files := openFiles([] ("abc.txt", "def.txt", "ghi.txt", "jkl.txt"));
end func;</lang>
Sidef
<lang ruby>[Foo.new] * n; # incorrect (only one distinct object is created)</lang> <lang ruby>n.of {Foo.new}; # correct</lang>
Smalltalk
<lang smalltalk>|c| "Create an ordered collection that will grow while we add elements" c := OrderedCollection new. "fill the collection with 9 arrays of 10 elements; elements (objects)
are initialized to the nil object, which is a well-defined 'state'"
1 to: 9 do: [ :i | c add: (Array new: 10) ]. "However, let us show a way of filling the arrays with object number 0" c := OrderedCollection new. 1 to: 9 do: [ :i | c add: ((Array new: 10) copyReplacing: nil withObject: 0) ]. "demonstrate that the arrays are distinct: modify the fourth of each" 1 to: 9 do: [ :i | (c at: i) at: 4 put: i ]. "show it" c do: [ :e | e printNl ].</lang>
Swift
<lang swift>class Foo { }
var foos = [Foo]() for i in 0..<n {
foos.append(Foo())
}
// incorrect version: var foos_WRONG = [Foo](count: n, repeatedValue: Foo()) // Foo() only evaluated once</lang>
Tcl
Tcl values are implemented using copy-on-write reference semantics with no (exposed) mechanism for determining whether two values are really references to the same value, which makes this task relatively moot. However, in the case where there is a collection of objects it becomes important to perform the construction correctly (i.e., repeatedly) otherwise it is just the name of the object that will be copied when it is written to.
or
<lang Tcl>package require TclOO
- The class that we want to make unique instances of
set theClass Foo
- Wrong version; only a single object created
set theList [lrepeat $n [$theClass new]]
- Right version; objects distinct
set theList {} for {set i 0} {$i<$n} {incr i} {
lappend theList [$theClass new]
}</lang>
XPL0
<lang XPL0>code Reserve=3, IntIn=10; char A; int N, I; [N:= IntIn(8); \get number of items from command line A:= Reserve(N); \create array of N bytes 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" ]</lang>
zkl
The pump and partial application methods are useful tools for creating initialized lists. <lang zkl>n:=3; n.pump(List) //-->L(0,1,2)
n.pump(List,List) //-->L(0,1,2), not expected
because the second list can be used to describe a calculation
n.pump(List,List(Void,List)) //--> L(L(),L(),L()) all same
List(Void,List) means returns List, which is a "known" value
n.pump(List,List.fpM("-")) //--> L(L(),L(),L()) all distinct
fpM is partial application: call List.create()
n.pump(List,(0.0).random.fp(1)) //--> 3 [0,1) randoms L(0.902645,0.799657,0.0753809)
n.pump(String) //-->"012", default action is id function
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</lang>
- Programming Tasks
- Object oriented
- Ada
- Aime
- ALGOL 68
- AutoHotkey
- BBC BASIC
- Brat
- C
- C++
- C sharp
- Clojure
- Common Lisp
- D
- Delphi
- E
- E examples needing attention
- EchoLisp
- Elixir
- Erlang
- Factor
- Forth
- Fortran
- F Sharp
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Jq
- Logtalk
- Lua
- Mathematica
- Maxima
- Modula-3
- Modula-3 examples needing attention
- Examples needing attention
- NGS
- Nim
- OCaml
- Oforth
- OoRexx
- Oz
- Pascal
- Perl
- Perl 6
- PicoLisp
- PureBasic
- Python
- R
- Racket
- Ruby
- Scala
- Seed7
- Sidef
- Smalltalk
- Swift
- Tcl
- TclOO
- XPL0
- Zkl
- GUISS/Omit
- PARI/GP/Omit
- TI-83 BASIC/Omit
- TI-89 BASIC/Omit