Consider this code, which is used as an example only:
auto scaleAll(int[] xs, int m) {
return xs.map!(x => m * x);
}
As m is captured, the delegate for map will rightly allocate the
closure in the GC heap.
In C++, you would write the lambda to capture m by value, but
this is not a facility
On Friday, 24 August 2018 at 13:04:47 UTC, Uknown wrote:
I was quite surprised by the fact that parallel ran so much
slower than recursive and loop implementations. Does anyone
know why?
n = 100 is too small to see parallelism gains.
Try n = 1
https://run.dlang.io/is/XDZTSd
On Thursday, 30 August 2018 at 19:59:17 UTC, Dr.No wrote:
I would to process the current block in parallel but priting
need to be theread-safe so I'm using
foreach(x; parallel(arr)) {
auto a = f(x);
auto res = g(a);
synchronized {
stdout.writeln(res);
stdout.flush();
On Saturday, 1 September 2018 at 16:20:11 UTC, Dr.No wrote:
why move flush to outside the synchronized block?
flush should be thread safe. In general, yiu want as little code
as possible to run under the lock. Not that important though.
trying out this approach I found to be ok except in som
On Saturday, 1 September 2018 at 17:17:37 UTC, puffi wrote:
Hi,
Is it by design that when calling functions with either ubyte
or byte variables the char overload is called instead of the
int (or generic) one?
It seems this is by design.
"If two or more functions have the same match level, th
Well, it doesn't work in 2.065, so must be 2.066 :-)
P.S. thanks for letting me know about this feature. I had no idea
it was going in!
template Foo(T...) {}
template Bar(T...) {}
template isFoo(alias F)
{
enum isFoo = __traits(isSame, F, Foo);
}
pragma(msg, isFoo!Foo); // true
pragma(msg, isFoo!Bar); // false
On Sunday, 3 August 2014 at 23:48:09 UTC, Martin wrote:
When I use the spawnProcess function in std.process, the
command line arguments that I provide to the function seem to
get "quoted".
I can't reproduce this on OS X with 2.066rc1 (args are unquoted).
Can someone else check Windows? Sounds
On Saturday, 9 August 2014 at 00:34:43 UTC, Puming wrote:
Yes, rust is a more infantile language compared to D, but
people are already using them to create complicate applications
like browser!
Rust was designed to build Servo. The people building Servo are
the people building Rust. With all
On Friday, 24 October 2014 at 21:56:20 UTC, Nordlöw wrote:
bool isPalindrome(R)(in R range) @safe pure
Aside: for templates, just let the compiler infer @safe and pure.
You don't know whether the range operations on R are pure or not.
As for the actual algorithm, there's no need for the rand
You need to take a slice of the buffer:
char[] buf = Input[];
readln(buf);
// line now in buf
The reason for this is because you need to know where the string
ends. If you just passed in Input, how would you know how long
the line read was?
On Thursday, 1 January 2015 at 13:13:10 UTC, Andrej Mitrovic via
Digitalmars-d-learn wrote:
On 1/1/15, Idan Arye via Digitalmars-d-learn
wrote:
If I have an associative array and I only modify it's values,
without changing the keys, can I assume that the order won't
change?
Associative arrays
Can someone please explain this behaviour? I find it totally
bizarre.
auto f(T)(T x) {
struct S {
T y;
this(int) { }
}
return S(0);
}
void main() {
f(f(0));
}
Error: constructor f376.f!(S).f.S.this field y must be
initialized in
On Friday, 2 January 2015 at 00:08:02 UTC, anonymous wrote:
Apparently dmd thinks that the result of f must be a nested
struct. I.e. it needs a context pointer. And I guess hell would
break loose if you'd use a nested struct with a null context
pointer. At least when the context pointer is actu
On Friday, 2 January 2015 at 23:51:05 UTC, John Colvin wrote:
The rule (in C(++) at least) is that all data is assumed to be
visible and mutable from multiple other threads unless proved
otherwise. However, given that you do not write a race, the
compiler will provide full sequential consistenc
Consider:
auto foo(T)(T a) {
T b; // Error: cannot access frame pointer of main.X
b.data[] = 1;
return b;
}
void main() {
struct X {
this(int) {}
int[4096] data;
}
foo(X());
}
Note the error is because you c
On Tuesday, 6 January 2015 at 23:32:25 UTC, Artur Skawina via
That shows a static struct, so I'm not sure it's the same
problem.
static structs with template alias parameters to local symbols
count as nested structs.
Your solution would likely work, but yes, I'm looking for
something less h
On Thursday, 15 January 2015 at 15:24:55 UTC, Ola Fosheim Grøstad
wrote:
I am trying to understand the idea behind "shared" typing fully.
If I am only allowed to share objects with another thread if it
is typed "shared", doesn't that imply that it should be
allocated as shared too and only be
On Thursday, 15 January 2015 at 17:05:32 UTC, Ola Fosheim Grøstad
wrote:
On Thursday, 15 January 2015 at 15:31:17 UTC, Peter Alexander
wrote:
On Thursday, 15 January 2015 at 15:24:55 UTC, Ola Fosheim
Grøstad wrote:
That would be nice, because then a precise garbage collector
could choose betwee
On Saturday, 7 February 2015 at 21:33:51 UTC, Kenny wrote:
The above code snippet works correctly when I use LDC compiler
(it finds expected 'f' value and prints it to console). I'm
wondering is it a bug in DMD?
p.s. the final code used by both compilers:
import std.stdio;
import std.conv;
i
On Saturday, 7 February 2015 at 23:06:15 UTC, anonymous wrote:
On Saturday, 7 February 2015 at 22:46:56 UTC, Ali Çehreli wrote:
1.0 is famously not representable exactly.
1.0 is representable exactly, though.
I think he meant 0.1 :-)
21 matches
Mail list logo
