Multiple distinct objects: Difference between revisions

From Rosetta Code
Content added Content deleted
(new task (inspired by the *name* of "Create a Sequence of unique elements"))
 
m (Formatting fix, added headers)
Line 8: Line 8:
This task mostly makes sense for languages operating in the pass-references-by-value style (most object-oriented or 'dynamic' languages).
This task mostly makes sense for languages operating in the pass-references-by-value style (most object-oriented or 'dynamic' languages).


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


foo *foos = malloc(n * sizeof(*foos));
<code c>foo *foos = malloc(n * sizeof(*foos));
for (int i = 0; i < n; i++)
for (int i = 0; i < n; i++)
init_foo(&foos[i]);
init_foo(&foos[i]);</code>


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

==Common Lisp==


=={{header|Common Lisp}}==
The mistake is often written as one of these:
The mistake is often written as one of these:
(make-list n :initial-element (make-the-distinct-thing))
<code lisp>(make-list n :initial-element (make-the-distinct-thing))
(make-array n :initial-element (make-the-distinct-thing))
(make-array n :initial-element (make-the-distinct-thing))</code>
which are incorrect since <code>(make-the-distinct-thing)</code> is only evaluated once. A common correct version is:
which are incorrect since <code>(make-the-distinct-thing)</code> is only evaluated once. A common correct version is:
(loop repeat n collect (make-the-distinct-thing))
<code lisp>(loop repeat n collect (make-the-distinct-thing))</code>
which evaluates <code>(make-the-distinct-thing)</code> <var>n</var> times and collects each result in a list.
which evaluates <tt>(make-the-distinct-thing)</tt> <var>n</var> times and collects each result in a list.


==Haskell==
=={{header|Haskell}}==


If the creator of the distinct thing is in some monad, then one can write
If the creator of the distinct thing is in some monad, then one can write
replicateM n makeTheDistinctThing
<code haskell>replicateM n makeTheDistinctThing</code>
in an appropriate do block. If it is distinguished by, say, a numeric label, one could write
in an appropriate do block. If it is distinguished by, say, a numeric label, one could write
map makeTheDistinctThing [1..n]
<code haskell>map makeTheDistinctThing [1..n]</code>

Revision as of 01:55, 29 January 2009

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

This task was inspired by the common error of intending to do this, but instead creating a sequence of nreferences to the same mutable object; it might be informative to show the way to do that as well.

This task mostly makes sense for languages operating in the pass-references-by-value style (most object-oriented or 'dynamic' languages).

C

foo *foos = malloc(n * sizeof(*foos)); for (int i = 0; i < n; i++)

 init_foo(&foos[i]);

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

Common Lisp

The mistake is often written as one of these: (make-list n :initial-element (make-the-distinct-thing)) (make-array n :initial-element (make-the-distinct-thing)) which are incorrect since (make-the-distinct-thing) is only evaluated once. A common correct version is: (loop repeat n collect (make-the-distinct-thing)) which evaluates (make-the-distinct-thing) n times and collects each result in a list.

Haskell

If the creator of the distinct thing is in some monad, then one can write replicateM n makeTheDistinctThing in an appropriate do block. If it is distinguished by, say, a numeric label, one could write map makeTheDistinctThing [1..n]