I don't understand why this code doesn't compile:
http://dpaste.dzfl.pl/dfd8df7f80ad
This doesn't compiles
http://dpaste.dzfl.pl/bbcc31fbe016
I have rectangular forward range of forward ranges (not arrays):
[
[a11, a12, ... a1N],
[a21, a22, ... a2N],
...
[aM1, aM2, ... aMN]
]
I need lazy forward range:
[
a11 + a21 + ... aM1,
a12 + a22 + ... aM2,
...
a1N + a2N + ... aMN
]
Range of sum elements of every columns;
M, N -
void popFront() { foreach (ref r; rr) r.popFront(); }
I think it should be
void popFront() { foreach (ref r; rr.save) r.popFront(); }
but I think OP wanted a ready-made phobos solution, w/o all the
range boilerplate...
exactly.
DMD64 D Compiler v2.066.1
Why second call doesn't compile?
import std.array;
import std.algorithm;
class Foo {
bool flag;
}
void main() {
immutable(Foo)[] foos;
foreach(i; 0..5) foos ~= new Foo;
// compiles, typeof(bar1) == immutable(Foo)[]
auto bar1 =
интервал, область
Code:
import std.stdio;
struct Bar {
int payload;
alias payload this;
}
struct Foo {
private {
Bar m_bar;
int m_baz;
}
@property {
Bar bar() { return m_bar; }
void bar(Bar v) { m_bar = v; }
On Wednesday, 17 December 2014 at 08:09:44 UTC, Daniel Kozák via
Digitalmars-d-learn wrote:
This should work only with ref by spec
I totally agree.
On Saturday, 14 February 2015 at 10:23:48 UTC, Gary Willoughby
wrote:
I wrote a similar function here:
https://github.com/nomad-software/dunit/blob/master/source/dunit/toolkit.d#L42
or using an epsilon value:
https://github.com/nomad-software/dunit/blob/master/source/dunit/toolkit.d#L134
I
why std.conv.to is not pure?
string foo(real v) pure { return v.to!string; }
// Error: pure function 'foo' cannot call impure function
'std.conv.to!string.to!(real).to'
I wrote this function for comparing two floating point values:
import std.math;
import std.traits;
bool isEqual(T)(T v1, T v2) if(isFloatingPoint!T) {
return T.mant_dig - feqrel(v1, v2) 2;
}
What do you think about it?
Seems like is expression doesn't support type tuples:
pragma(msg, is(short : int)); // true
enum Test(ARGS...) = is(ARGS[0..2] : ARGS[2..4]);
pragma(msg, is(Test!(int, int, int, int))); // false
pragma(msg, Test!(int, short, int, int)); // false
Is it by design, or just
On Tuesday, 3 March 2015 at 16:42:22 UTC, bearophile wrote:
But it should be not too much hard to implement it your code.
Just use two is(), or use recursion (with splitting in two, and
not 1 + n-1).
Bye,
bearophile
I already have one:
template Is(ARGS...) if(ARGS.length % 2 == 0) {
On Thursday, 5 March 2015 at 06:05:56 UTC, zhmt wrote:
I am a gameserver developer, my programming lang is java now.
I want to change java to dlang, and I like boost_asio and it's
coroutine,
so, I want to create a binding of boost_asio.
But I am not familiar with dlang, so I want to find
On Tuesday, 3 March 2015 at 17:49:24 UTC, bearophile wrote:
That's 1 + n-1 :-)
Could you please explain what does '1 + n-1' mean?
I need current system time ISO string with timezone offset. For
example
2015-04-20T11:00:44.735441+03:00
but Clock.currTime.toISOExtString doesn't write offset:
2015-04-20T11:00:44.735441+03:00
I found workaround, but it looks redundant and needs memory
allocation:
auto t = Clock.currTime;
code:
class A {
void test(int) {}
}
class B : A {
void test() {
super.test(1); // compiles
test(10); // error
}
}
Error: function B.test () is not callable using argument types
(int)
Ok, it's a feature. Thanks.
On Sunday, 17 May 2015 at 09:10:06 UTC, Dennis Ritchie wrote:
It's uncomfortable:
-
char[][] s = [['f', 'o', 'o'], ['b', 'a', 'r']];
s[1][1] = 't';
auto s = [foo.dup, bar.dup];
s[1][1] = 't';
I quite often have to write similar designs:
-
import std.stdio;
void main() {
auto a = [ 1, 2, 3, 4, 5 ];
foreach (e; a) {
if (e == 4) {
writeln(Yes);
return;
}
}
I need mutable storage for immutable associative array. Just
create new immutable AA and store it for future passing it
between threads/fibers.
First attempt: just immutable AA
immutable aa = [1:1, 2:1];
aa = [1:1, 2:1]; // fail, can't assign a new AA
Second attempt: mutable AA with immutable
I made trivial pull request -
https://github.com/D-Programming-Language/phobos/pull/3341
RebindableAA!(immutable int[string]) aa = [a: 1, b: 2]; //
works
assert(aa[a] == 1); // cool
aa = [a: 3, b: 4]; // nice
auto bb = aa; // yes
bb = [a: 4, b: 5]; // super
aa[a] = 2; //
I don't see any reason why it should not compile.
import std.array;
import std.range;
import std.algorithm;
class Foo {
}
void main() {
auto result = iota(3).map!(i = new immutable Foo).array();
}
/usr/include/dmd/phobos/std/conv.d(4028): Error: cannot
implicitly convert expression
https://issues.dlang.org/show_bug.cgi?id=14751
Just creating a bunch (10k) of sleeping (for 100 msecs)
goroutines/tasks.
Compilers
go: go version go1.4.2 linux/amd64
vibe.d: DMD64 D Compiler v2.067.1 linux/amd64, vibe.d 0.7.23
Code
go: http://pastebin.com/2zBnGBpt
vibe.d: http://pastebin.com/JkpwSe47
go version build with go
On Tuesday, 30 June 2015 at 17:37:38 UTC, Atila Neves wrote:
Sleep will almost certainly pause and block the fiber. Vibe.d
only switches between them when there's IO to be done or
something else from the event loop.
Sleep blocks the fiber, but not the event loop. Because it isn't
fix - https://github.com/D-Programming-Language/phobos/pull/3524
Also, map is lazy, but each isn't.
Using lambdas in 2.068 becomes painful:
import std.algorithm;
struct Foo {
int baz(int v) {
static int id;
return v + id++;
}
void bar() {
auto arr1 = [1, 2, 3];
auto arr2 = [4, 5, 6];
On Tuesday, 25 August 2015 at 14:05:17 UTC, Steven Schveighoffer
wrote:
Can you post an example?
import std.range;
import std.algorithm;
class Foo {
int baz() { return 1;}
void bar() {
auto s = [1].map!(i = baz()); // compiles
auto r = [1].map!(i =
On Tuesday, 25 August 2015 at 18:03:21 UTC, Steven Schveighoffer
wrote:
https://issues.dlang.org/show_bug.cgi?id=14962
-Steve
Thanks.
On Saturday, 28 November 2015 at 18:03:13 UTC, Suliman wrote:
Could anybody help me to understand how to complete HTTP
response with vibed.
I am sending POST request from AngularJS:
$.post("http://127.0.0.1:8080/my;, total_result);
where total_result is JSON string: [{"QID":3,"AID":3},
On a server with 4GB of RAM our D application consumes about 1GB.
Today we have increased server memory to 6 Gb and the same
application under the same conditions began to consume about 3Gb
of memory.
Does GC greediness depend on available RAM?
import std.algorithm;
struct Bar {
const int a;
int b;
}
void main() {
Bar[1] arr;
Bar bar = Bar(1, 2);
bar[0].b = 4;
move(bar, arr[0]); // ok
arr[1] = bar;// fail, why?
move(Bar(1, 2), arr[0]); // fail, why source parameter isn't
auto ref?
}
On Thursday, 7 January 2016 at 00:19:12 UTC, anonymous wrote:
On 06.01.2016 23:04, Jack Applegame wrote:
move(bar, arr[0]); // ok
I consider it a bug that this compiles. You're overwriting
immutable data, which shouldn't be possible (without casting).
On Wednesday, 25 November 2015 at 09:31:15 UTC, John Colvin wrote:
import std.range;
import std.algorithm;
import std.utf;
void main() {
char[64] arr;
copy(chain("test1", "test2").byCodeUnit,
arr[0..10].byCodeUnit);
}
I'll use byCodeUnit. Thanks.
This doesn't compile:
import std.range;
import std.algorithm;
void main() {
char[64] arr;
copy(chain("test1", "test2"), arr[0..10]);
}
http://dpaste.dzfl.pl/24230ac02e6e
On Thursday, 26 November 2015 at 17:27:34 UTC, André wrote:
My question now is: is there some more elegant solution to
achieve this? Something like in C++ when you have std::map's of
std::map's and just access the elements and the entry is
created implicitly?
No. But you can create a wrapper:
On Friday, 27 November 2015 at 04:21:41 UTC, Nicholas Wilson
wrote:
AA are weird in that AFAIK you need to "initialise" them before
you try to look suff up in them else they crash. i.e.
int[string] foo;
// auto e = "1" in foo; // crash AA not initialised
foo[ "blah"] = 0;
foo.remove("blah");
On Thursday, 19 November 2015 at 03:53:48 UTC, Meta wrote:
On Wednesday, 18 November 2015 at 23:53:01 UTC, Chris Wright
wrote:
[...]
This is not true. Consider the following code:
import std.stdio;
void main()
{
int[] a = [0, 1, 2];
//4002E000 3
writeln(a.ptr, " ",
I prefer
import std.array;
if(!arr.empty) {}
Heh
immutable Foo foo2 = new Foo("bar"); // compiles
I believe that object constructed with pure constructor should be
implicitly convertible to immutable. It is, but only for default
constructor.
class Foo {
string s;
this() pure {
s = "fpp";
}
this(string p) pure { s = p; }
}
void main() {
auto foo1 = new immutable
On Sunday, 12 July 2015 at 08:38:01 UTC, Tofu Ninja wrote:
Is it even possible?
You can use function instead delegate, and bind captured
variables as struct:
http://dpaste.dzfl.pl/6e23bbcfe17f
auto bind(F: R function(ARGS), R, ARGS...)(F fn, ARGS args) @nogc
{
struct Functor {
Why is this happening...?
For safety reasons. Your array can be shared between parts of
application.
...how to avoid it?
https://dlang.org/library/object/assume_safe_append.html
On Friday, 20 May 2016 at 17:28:55 UTC, Namespace wrote:
But you can cheat:
You can just cast const away:
struct A {
int id = 0;
this(int id) {
this.id = id;
}
void change() const {
(cast() id)++;
}
}
On Monday, 23 May 2016 at 11:05:34 UTC, Jonathan M Davis wrote:
I don't know why you think that D violates its own rules
frequently though. It's not perfect, but it usually does follow
its own rules - and when it doesn't, we fix it (though not
always as quickly as would be ideal).
The most
On Sunday, 22 May 2016 at 13:08:19 UTC, Jonathan M Davis wrote:
Given how const and immutable work in D, having any portion of
them be treated as mutable, becomes highly problematic. It
could theoretically be done by having to mark such variables
with an attribute and mark such types with a
On Friday, 20 May 2016 at 20:46:18 UTC, Jonathan M Davis wrote:
Casting away const and mutating is undefined behavior in D. No
D program should ever do it.
Really? Mutating immutable is UB too, but look at
std.typecons.Rebindable.
On Saturday, 21 May 2016 at 21:49:23 UTC, Jonathan M Davis wrote:
Rebindable is in kind of a weird grey area. It involves a
union, not casting, and it's only ever mutating the class
reference, not the object itself. Certainly, if it mutated the
object, it would be undefined behavior, but it's
ttt.d
import std.string;
void main() {
lastIndexOf("aa","bb");
}
rdmd ttt.d
compiles successfully without any errors or warnings
rdmd -dw ttt.d
compiles successfully without any errors or warnings
rdmd -de ttt.d
/usr/include/dmd/phobos/std/string.d(1239): Error: template
On Tuesday, 5 July 2016 at 13:48:50 UTC, ag0aep6g wrote:
Something is also going wrong in dmd. There should be a
deprecation message.
Exactly.
On Wednesday, 1 February 2017 at 14:09:41 UTC, aberba wrote:
I can't find it. Like set_cookie() in php.
Yes, it does.
http://vibed.org/api/vibe.http.common/HTTPResponse.cookies
bug report: https://issues.dlang.org/show_bug.cgi?id=17128
Code:
import std.stdio;
struct Foo {
int val = 0;
~this() {
writefln("destruct %s", val);
}
}
void bar(ARGS...)() {
ARGS args;
args[0].val = 1;
writefln("val = %s", args[0].val);
}
void main() {
bar!Foo();
}
Excpected output:
val = 1
destruct 1
But
WORKAROUND:
import std.stdio;
struct Foo {
int val = 0;
~this() {
writefln("destruct %s", val);
}
}
void bar(ARGS...)() {
struct Tuple {
ARGS args;
alias args this;
}
Tuple args;
args[0].val = 1;
writefln("val = %s", args[0].val);
}
On Monday, 16 January 2017 at 14:47:23 UTC, Era Scarecrow wrote:
static char[1024*4] buffer; //4k reusable buffer, NOT
thread safe
Maybe I'm wrong, but I think it's thread safe. Because static
mutable non-shared variables are stored in TLS.
On Sunday, 21 August 2016 at 19:29:26 UTC, Engine Machine wrote:
I know you like to play the right or wrong game, but did you
ever learn that a single example does not prove the truth of
something?
How about something more complex?
Your demagogy will not help you learn the basics of the D
On Monday, 22 August 2016 at 00:43:00 UTC, Engine Machine wrote:
The following code works and does what I want!
template InstantiateOrEmptySeq(alias tmpl, args...)
{
alias Seq(T...)=T;
static if (args.length > 0)
alias InstantiateOrEmptySeq = tmpl!(args[0 .. $-1]);
else
On Saturday, 20 August 2016 at 00:46:15 UTC, Engine Machine wrote:
Any ideas?
Something like this?
mixin template TypeData(string type: "Animal") {
int y;
}
mixin template TypeData(string type: "Dog") {
int z;
}
mixin template TypeData(string type: "Pug") {
int s;
}
template
On Sunday, 21 August 2016 at 00:06:07 UTC, Engine Machine wrote:
On Saturday, 20 August 2016 at 22:21:00 UTC, ag0aep6g wrote:
On 08/21/2016 12:11 AM, Engine Machine wrote:
Is there a way to rebind the arguments of a template?
template foo(X)
{
// X is like A!(a,b,c)
Y =
On Monday, 22 August 2016 at 18:04:43 UTC, Engine Machine wrote:
How do you seriously think this is cleaner/simpler?
1. No extra encrypted things, such as InstantiateOrEmptySeq
2. Much more understandable.
You have two classes.
No. I have one template with two specializations. Class template
On Monday, 22 August 2016 at 18:48:12 UTC, ag0aep6g wrote:
You can take this further with template constraints. Gives it a
more uniform appearance at the price of some repetition:
class T()
{
int x;
}
class T(A...) : T!(A[0..$-1])
if (A.length > 0 && A[$-1] == "Animal")
{
int
On Monday, 22 August 2016 at 19:56:08 UTC, ag0aep6g wrote:
So this is just to avoid typing out `class Pug : Dog {...}
class Dog : Animal {...} class Animal {...}`?
This allows you to create different inheritance chains with the
same components quickly and easily. I don't know any use case,
but
On Tuesday, 23 August 2016 at 21:14:01 UTC, ciechowoj wrote:
This is a bit strange, as the local variables aren't known
either and they seem to work. I do not want to get the address,
rather an alias to `` expression.
D doesn't accept aliases to expressions, only symbols and
literals.
Spec:
object.destroy doesn't want to destroy const structure with
destructor:
struct T {
~this() {}
}
void foo_t(ref T t) {
destroy(t); // works
}
void foo_ct(ref const T t) {
destroy(t); // Error: mutable method T.~this is not callable
using a const object
}
Mutable destructor?
On Sunday, 28 August 2016 at 20:38:30 UTC, Lodovico Giaretta
wrote:
On Sunday, 28 August 2016 at 19:53:51 UTC, Illuminati wrote:
What are the D equivalents to these types of functions?
I do not see anything in core.atomic that can accomplish this.
I have tried to include
On Monday, 22 August 2016 at 22:01:51 UTC, ciechowoj wrote:
Is it possible to generate an argument list that contains
pointers to local variables at compile time?
For example, consider following code:
template Repeat(alias int N, alias variable)
{
// Magic
alias Repeat = /* Even more
On Monday, 22 August 2016 at 21:46:35 UTC, Engine Machine wrote:
I'm sorry if it confuses you... it doesn't confuse me.
Confuses? No.
I do not know why you have to try and prove something that is a
preference. Do you often get in to arguments with people about
how ford is better than chevy or
Code:
union A {
immutable int f;
}
union B {
immutable int f;
int e;
}
void main() {
A a = A(1);
//a = A(2); // a.f is immutable, fails to compile as expected
B b = B(1);
b = B(2); // compiles!!!
}
It turns out that if the union contains at least one
On Thursday, 25 August 2016 at 17:01:40 UTC, Meta wrote:
This should be fixed pretty soon:
https://github.com/dlang/dmd/pull/5940
Bye-bye immutable classes. :'(
On Thursday, 25 August 2016 at 19:19:49 UTC, Jonathan M Davis
wrote:
Why? I don't know exactly what that PR is supposed to do, but
std.datetime uses immutable time zone objects, and if that PR
made it so that you couldn't have an immutable instance of a
class, then it would have failed the
Also I hate Rebindable.
cast(const) x[];
cast(immutable) x[];
On Saturday, 24 December 2016 at 00:55:01 UTC, Yuxuan Shui wrote:
I tried this:
immutable int[char] xx = ['Q':0, 'B':1, 'N':2, 'R':3,
'P':4];
And got a "non-constant expression" error (with or without
'immutable').
What's the correct way?
This works:
void main() {
immutable
I'm pretty sure that this code should compile
(https://dpaste.dzfl.pl/cf1e1ee6ef4b):
struct A(T) {
~this() {
char[T.sizeof] data;
}
}
struct B(T) {
A!T foo;
}
struct C {
B!C bar;
}
void main() {
C c;
}
But it doesn't:
/d300/f416.d(3): Error: struct f416.C no size
Is this a bug?
Code (https://dpaste.dzfl.pl/8e7a9c380e99):
import std.stdio;
struct Foo {
int val;
this(int val) {
writefln("%s.this(int)", val);
this.val = val;
}
this(this) {
writefln("%s.this(this)", val);
this.val = val;
}
~this() {
On Tuesday, 7 March 2017 at 16:00:54 UTC, kinke wrote:
Definitely a very bad bug. It works too if you mark `fun()` as
nothrow. Please file a DMD issue.
https://issues.dlang.org/show_bug.cgi?id=17246
On Monday, 17 July 2017 at 17:38:23 UTC, Nordlöw wrote:
I'm want to define a specialization of `append()` that takes
only static arrays as inputs and returns a static array being
the sum of the lengths of the inputs.
Have anybody already implemented this?
If not, I'm specifically interested
On Tuesday, 18 July 2017 at 12:39:01 UTC, Stefan Koch wrote:
whhhahhh template bloat
Yes, and also very slow. :)
On Wednesday, 12 July 2017 at 05:45:13 UTC, Miguel L wrote:
Also what is it possible in D to write a function that accepts
an static array of any size?
void foo(size_t N)(ref int[N] arr) {
...
}
int[10] arr;
foo(arr);
On Tuesday, 19 September 2017 at 19:54:02 UTC, Steven
Schveighoffer wrote:
On 9/19/17 1:40 PM, EntangledQuanta wrote:
The first returns x + w/2 and the second returns w/2!
Did you mean (x + w) / 2 or x + (w / 2)? Stop being ambiguous!
-Steve
The best answer. :D
On Friday, 13 October 2017 at 12:03:55 UTC, Dgame wrote:
Interesting. If you remove the CTor in Foo it works again.
If you remove DTor it works again too. :)
On Friday, 13 October 2017 at 11:21:48 UTC, Biotronic wrote:
BountySource[2] lets you do basically exactly that.
My experience says that BountySource almost doesn't help.
If you don't want to get the great PITA, never create temporary
objects in function parameters.
I recently spent a whole day digging through my reference counted
containers library. But nasty bug was not there, but in the
compiler.
Look at this: https://glot.io/snippets/eui2l8ov0r
Result:
I recently came across an interesting exercise.
Given a series of positive numbers, each of which belongs to the
set
{ 2^^i * 3^^j * 5^^k | i, j, k ≥ 0 }.
The series is ordered in ascending order. The beginning looks
like this:
{ 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, ... }
And the first example still doesn't compile:
```
struct Range(R) {
import std.array : empty, front, popFront;
R range;
bool empty() const { return range.empty; }
auto front() const { return range.front; }
void popFront() { range.popFront(); }
}
void main() {
auto rng
On Monday, 11 May 2020 at 12:30:22 UTC, Adam D. Ruppe wrote:
UFCS is only defined to work with global scope functions. A
restricted import (module : symbol, symbols) puts things in
local scope so ufcs doesn't apply.
But in this case the error should be displayed for lines 4 and 5,
not 11.
On Monday, 11 May 2020 at 13:12:37 UTC, Simen Kjærås wrote:
Filed here: https://issues.dlang.org/show_bug.cgi?id=20821
Thanks.
Why doesn't it compile?
```
struct Range(R) {
import std.array : empty, front, popFront;
R range;
bool empty() const { return range.empty; }
auto front() const { return range.front; }
void popFront() { range.popFront(); }
}
void main() {
auto rng = Range!string("1234");
On Monday, 11 May 2020 at 12:20:06 UTC, Jack Applegame wrote:
assert(rng.front == 1);
Damn! I made a typo. It must be:
assert(rng.front == '1')
So the second example works fine.
I think it should compile.
```
struct NonCopyable {
int a;
this(this) @disable;
}
void main() {
NonCopyable[] arr = [NonCopyable(1), NonCopyable(2)]; // ok
arr ~= NonCopyable(3); // fails
}
```
On Saturday, 6 June 2020 at 12:02:03 UTC, MoonlightSentinel wrote:
On Saturday, 6 June 2020 at 08:55:20 UTC, Jack Applegame wrote:
Should it compile?
No, moveEmplace just sees a const reference and doesn't know
that a is void-initialized.
Actually, it knows. Because moveEmplace assumes
On Saturday, 6 June 2020 at 11:58:06 UTC, Basile B. wrote:
maybe it shouldn't but then with another message, for example
Error, cannot `void` initialize a `const` declaration.
since that makes very little sense, at least as a local
variable. (as a member, this can be initialized in a
Should it compile?
```d
import std.algorithm.mutation;
void main() {
const char a = void;
const char b ='b';
moveEmplace(b, a); // mutation.d: Error: cannot modify const
expression target
assert(a == 'b');
}
```
I think, it should.
There is a funny feature (or bug) in the D language:
static alias this and static operator overloading.
For example
interface Foo {
static {
int value;
void opAssign(int v) { value = v; }
int get() { return value; }
alias get this;
}
}
Now we can use
On Tuesday, 6 July 2021 at 12:33:20 UTC, Adam D Ruppe wrote:
The language always allows `a = b;` to be rewritten as `a(b);`.
And that's sad. It should happen for properties only.
Code:
```d
import std.stdio;
struct Field {
void opAssign(int a) {
writefln("Field.opAssign(%s)", a);
}
}
struct Register {
Field clock(int a) {
writefln("Register.clock(%s)", a);
return Field();
}
}
void main() {
Register register;
On Tuesday, 6 July 2021 at 10:25:28 UTC, Dennis wrote:
We're [still awaiting formal assessment on
dip1038](https://forum.dlang.org/thread/sojvxakgruzfvbigz...@forum.dlang.org), but if that gets in, you can mark `clock` or `Field` `@nodicard`. Otherwise I don't know of a way.
Yes, it would
1 - 100 of 107 matches
Mail list logo
