On Saturday, 27 April 2024 at 11:55:58 UTC, Basile B. wrote:
Here's [STYX](https://gitlab.com/styx-lang/styx) solution:
function sum[T,U](U u): u32
I think you meant `: T`.
{
var T result;
foreach const e in u do
if echo(is, e, T) do
resul
On Saturday, 27 April 2024 at 15:32:40 UTC, Nick Treleaven wrote:
On Saturday, 27 April 2024 at 11:55:58 UTC, Basile B. wrote:
foreach const e in u do
if echo(is, e, T) do
result += e;
static if (is(typeof(e) == int))
r += e;
Actually
On Wednesday, 1 May 2024 at 01:09:33 UTC, Liam McGillivray wrote:
I get compiler errors when using it on other array types. I've
tried using it to replace occurrences of a certain object in an
array with [] in order to remove all occurrences, but it's not
allowed.
Can you post a code example?
On Saturday, 4 May 2024 at 16:58:00 UTC, Dmitry Olshansky wrote:
So I have a function:
```d
size_t awaitAny(T...)(T args) { ... }
```
And I have:
``d
Event*[4] events;
``
How do I pass all 4 of events to awaitAny as tuple of arguments?
Use `awaitAny(events.tupleof)`?
https://dlang.org/spec/a
On Monday, 6 May 2024 at 06:29:49 UTC, Liam McGillivray wrote:
This is because the delegate assignment causes the local `card`
variable to remain alive. The delegate that's assigned is
linked to this variable itself, not the value at the time that
the delegate is assigned.
This is https://iss
On Monday, 6 May 2024 at 06:29:49 UTC, Liam McGillivray wrote:
Here's a line that caused a bug that took me awhile to find:
```
foreach(card; unitCards) card.submitted = delegate() =>
selectUnit(card.unit);
```
I think you can do:
```d
import std.algorithm.iteration : each;
unitCards.
On Wednesday, 8 May 2024 at 04:27:13 UTC, cc wrote:
It doesn't allow a simple boolean to be used as an argument, or
any other Flag as they are different instantiations of a
template rather than equivalent aliases.
It is however awful, cumbersome, annoying design and needs to
be completely phase
On Thursday, 9 May 2024 at 13:40:56 UTC, cc wrote:
It's pointless mandatory verbosity. StopWatch ctor only takes
one boolean argument. It doesn't *need* to specify what it
relates to. You either already know, or you have to look it up
anyway. Flags made sense when you might get the order of
On Wednesday, 8 May 2024 at 10:24:07 UTC, Nick Treleaven wrote:
Named arguments are optional, so I don't see how they could
make Flag redundant.
Actually, an external tool could detect when a bool is passed as
an argument to a function and warn when not done with a named
argument. This would
On Friday, 10 May 2024 at 15:23:39 UTC, Andy Valencia wrote:
On Friday, 10 May 2024 at 03:07:43 UTC, Steven Schveighoffer
wrote:
Yes, we say that a type has "truthiness" if it can be used in
a condition (`while`, `if`, `assert`, etc).
So if I may ask for one more small clarification... WRT
"t
On Sunday, 12 May 2024 at 21:34:30 UTC, Chris Piker wrote:
So, why does ImportC need *.c files exclusively? I'm sure it
solves a problem, but I don't know what that problem is.
Support for headers has been worked on, but had to be reverted:
https://issues.dlang.org/show_bug.cgi?id=23479
On Wednesday, 5 June 2024 at 09:09:40 UTC, Kagamin wrote:
On Wednesday, 5 June 2024 at 01:18:06 UTC, Paul Backus wrote:
The only safe values for a `bool` are 0 (false) and 1 (true).
AFAIK that was fixed and now full 8-bit range is safe.
`cast(bool) someByte` is fine - that doesn't reinterpre
On Wednesday, 5 June 2024 at 06:22:34 UTC, Eric P626 wrote:
Now according to the book, it's possible to assign a slice from
a fixed array. This code will compile:
~~~
int[12] monthDays = [ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31,
30, 31 ];
int[] a_slice = monthDays;
~~~
The element types are
On Tuesday, 4 June 2024 at 12:22:23 UTC, Eric P626 wrote:
~~~
void main()
{ writeln("Maze generation demo");
s_cell [5][5] maze;
print_maze (maze);
}
void print_maze ( s_cell [][] maze )
{
}
~~~
This is how to do it without GC allocations (I have used `int`
instead for demo purposes)
On Wednesday, 5 June 2024 at 10:27:47 UTC, Nick Treleaven wrote:
//~ void print_maze ( s_cell [][] maze... )
I meant to delete that line!
On Wednesday, 5 June 2024 at 10:27:47 UTC, Nick Treleaven wrote:
foreach (i, row; maze)
slices[i] = row;
Sorry that assignment was wrong (edited at last minute). Fixed:
```d
import std.stdio;
alias s_cell = int;
void main()
{ writeln("Maze generation demo");
s_cell [5][5] maze;
On Wednesday, 5 June 2024 at 09:24:23 UTC, evilrat wrote:
for simple cases like this it might work, but 2d array is not
even contiguous,
A 2D static array is contiguous:
https://dlang.org/spec/arrays.html#rectangular-arrays
D static arrays, while using the same syntax, are implemented
as a fi
On Thursday, 6 June 2024 at 17:49:39 UTC, Andy Valencia wrote:
I was using instance initialization which allocated a new
object. My intention was this initialization would happen
per-instance, but all instances appear to share the same
sub-object? That is, f1.b and f2.b appear to point to a s
On Saturday, 8 June 2024 at 16:09:04 UTC, monkyyy wrote:
rng is an optional parameter, `uniform(0,100).writeln;` alone
works; the docs not telling you that is really bad
They do tell you:
urng (optional) random number generator to use; if not
specified, defaults to rndGen
That overload is
On Tuesday, 25 June 2024 at 02:16:25 UTC, mw wrote:
Why `foo.x.saa.aa` and `foo.y.saa.aa` is the same? (and of
course print out the same contents).
`shared_AA.saa` should still be instance variable, not class
variable, right?
`saa` is an instance variable, but both `foo.x.saa` and
`foo.y.sa
On Saturday, 29 June 2024 at 23:33:41 UTC, solidstate1991 wrote:
S foo0 = S(TypeEnum.Integer32, S(20)); //Ugly, but works
S foo1 = S(TypeEnum.Integer64, S(20L)); //Error: cannot
Did you mean `U(20)`? The 20 applies to the first field of the
union, i32. `U(20L)` also works and (I think) it doe
On Monday, 1 July 2024 at 07:32:30 UTC, Dakota wrote:
this code give error:
```d
static if( !__traits(compiles, mixin("enum v = V;")) ) {
enum v = V;
}
```
__traits(compiles, ...) can't check if a declaration is valid
directly. You have to wrap it in a function literal expression:
```d
On Monday, 15 July 2024 at 06:44:12 UTC, Dakota wrote:
```d
struct type_s
{
union {
struct
{
int a;
int b;
} c;
};
};
```
`type c` will return false with `enum isStatic(alias V) =
__traits(compiles, { enum v = V; });`
I put `type_s` in
On Saturday, 20 July 2024 at 14:02:21 UTC, IchorDev wrote:
Why does Phobos not provide a method to easily deconstruct
tuples? Here's a trivial implementation:
...
tie!(y, x) = tupRetFn().expand;
writeln(x,", ",y);
}
```
Not having this is like if Phobos didn't have `AliasSeq`. Y
On Sunday, 21 July 2024 at 05:43:32 UTC, IchorDev wrote:
Obviously when writing optimised code it is desirable to reduce
heap allocation frequency. With that in mind, I'm used to being
told by the compiler that I can't do this in `@nogc` code:
```d
void assign(ref int[4] a) @nogc{
a[] = [1,3,6
On Sunday, 21 July 2024 at 04:05:52 UTC, IchorDev wrote:
On Saturday, 20 July 2024 at 20:48:29 UTC, Nick Treleaven wrote:
Instead of the `tie` assignment, you can just do:
```d
import std.meta;
AliasSeq!(y, x) = tupRetFn().expand;
```
And here I was trying to use comma expressi
On Sunday, 21 July 2024 at 10:33:38 UTC, Nick Treleaven wrote:
For instance, will this example *always* allocate a new
dynamic array for the array literal, and then append it to the
existing one, even in optimised builds?
```d
void append(ref int[] a){
a ~= [5, 4, 9];
}
```
If there i
On Sunday, 21 July 2024 at 10:33:38 UTC, Nick Treleaven wrote:
On Sunday, 21 July 2024 at 05:43:32 UTC, IchorDev wrote:
Does this mean that array literals are *always* separately
allocated first, or is this usually optimised out?
My understanding is that they do not allocate if used to
initia
On Thursday, 25 July 2024 at 15:06:35 UTC, IchorDev wrote:
I think your function most likely has a safe interface, so it
can be marked as `@trusted` as-per [the
spec](https://dlang.org/spec/function.html#safe-interfaces).
Just to mention that with -dip1000, taking the address of
variables is
On Thursday, 1 August 2024 at 08:46:00 UTC, IchorDev wrote:
P.S. You might want to put `value = void`, otherwise it’ll
always be default-constructed.
Doing `= void` can violate the assumptions of a destructor of T.
Nullable uses a union to store T, so it can decide when to call
the destructor
On Friday, 16 August 2024 at 06:15:18 UTC, Bruce wrote:
Is there an easy way to create a 60 character string in D?
Like in Python...
ul = '-'*60
2 ways:
```d
// use a fixed array:
immutable char[60] a = '-';
string s = a.dup; // copy to heap, assuming you need the data to
escape (use a[] othe
On Friday, 16 August 2024 at 13:30:53 UTC, IchorDev wrote:
On Friday, 16 August 2024 at 11:37:08 UTC, Nick Treleaven wrote:
On Friday, 16 August 2024 at 06:15:18 UTC, Bruce wrote:
```d
string s = a.dup; // copy to heap, assuming you need the data
to escape (use a[] otherwise)
s.writeln();
```
On Friday, 16 August 2024 at 16:30:09 UTC, Jonathan M Davis wrote:
Well, you if you use dup, you're asking for a mutable array,
whereas if you use idup, you're asking for an immutable array.
Yes, `idup` may be needed e.g. for overloads varying on
mutability.
Whether the result of dup is then
On Friday, 23 August 2024 at 08:58:16 UTC, Me'vâ wrote:
```
import std.stdio:writeln;
void main() {
int i = 5;
writeln("Result: ", i + ++i);
}
```
When I run this, it surprisingly outputs 11. I tried something
similar in C before and it gave me 12. I’m curious, why is
there a differen
On Friday, 23 August 2024 at 09:42:38 UTC, Nick Treleaven wrote:
C++: undefined, could be `6 + 6` if the increment is done
first. g++ gives me a warning with `-Wall`:
You asked about C, for some reason I used C++. But it's the same
in C, and the error happens with `gcc -Wall`.
On Saturday, 31 August 2024 at 15:38:49 UTC, ryuukk_ wrote:
Let's see how other languages do it:
```zig
map.put("hello", 42);
// get pointer
if (map.get("hello")) |*it| {
std.log.debug("{}", .{it});
}
// get value
if (map.get("hello")) |it| {
std.log.deb
On Monday, 2 September 2024 at 11:56:10 UTC, Nick Treleaven wrote:
Annoyingly, the `int` is required, though maybe just an IFTI
bug.
https://issues.dlang.org/show_bug.cgi?id=24255
On Monday, 2 September 2024 at 11:56:10 UTC, Nick Treleaven wrote:
test.update("hello", () => noreturn.init, (ref int x) {
x++;
});
Sorry, that aborts if the key isn't present. `update` requires
the first callback to provide a value for the key, and it can't
return void.
On Wednesday, 11 September 2024 at 08:08:45 UTC, ryuukk_ wrote:
It is a bug, don't claim it is not, the compiler gives the
wrong information, wich lead to a confused user
You don't want confused users, you want compiler say what's up,
if i type assert, it should assert, end of the story
The
On Wednesday, 10 August 2022 at 06:15:39 UTC, Dom Disc wrote:
Ok, then I consider this is a bug in Phobos that should be
corrected.
All instances of
```D
foo(T : fixedType)(T x) { }
```
should be replaced by
```D
foo(fixedType x) { }
```
Perhaps, but not necessarily. The body of foo could d
On Wednesday, 31 August 2022 at 14:34:50 UTC, musculus wrote:
Hi. I have an array of tuples that I would like to convert to
an array of arrays.
All of the elements in the tuples have matching types (string).
How would I go about doing this? Thanks!
Assuming std.typecons.Tuple, you can use `[tu
On Thursday, 25 August 2022 at 07:22:32 UTC, bauss wrote:
We really need a page in the documentation that describes how
to build each component of D for each major platform.
There is on the wiki, but it's out of date:
https://wiki.dlang.org/Building_under_Windows
build.d works for dmd, but I
On Saturday, 3 September 2022 at 21:20:01 UTC, solidstate1991
wrote:
During unittest in my own fork of std.experimental.xml (link:
https://github.com/ZILtoid1991/experimental.xml ), potentially
an error so severe is present, that it causes to crash the
compiler (both DMD and LDC2, on Windows).
On Sunday, 4 September 2022 at 20:48:52 UTC, solidstate1991 wrote:
What do I pass as the tester?
You can use a script as described here:
https://github.com/CyberShadow/DustMite/wiki/Detecting-a-segfault-in-dmd-itself
On Tuesday, 13 September 2022 at 03:00:17 UTC, Kyle Ingraham
wrote:
Any suggestions for being able to call one function for any
instance given but maintain flexible return types?
Not sure if it helps, but you can define final methods in an
interface, which can call virtual interface methods:
On Monday, 3 October 2022 at 18:09:05 UTC, Fausto wrote:
Hello all,
I am trying to rotate left an array.
I found a very basic way, and I am not sure if there is
something clever than this :) maybe using slices...
Here we can't use slice assignment instead of the inner loop
because that doesn
On Tuesday, 4 October 2022 at 18:18:41 UTC, Ali Çehreli wrote:
A related topic is how the "end slice" never loses that
capacity:
void main() {
auto a = [ 1, 2 ];
auto b = a;
assert(a.capacity != 0);
assert(b.capacity != 0);
b.length--;
assert(b.capacity == 0);
asse
On Sunday, 23 October 2022 at 20:12:46 UTC, Hipreme wrote:
For reducing a D Interface file dependency when generating it
with the `-H` flag for DMD, you can't import a module on the
top level.
Take a look at that example:
This would make a nice blog post if you have one ;-)
Hi,
The following seems like a bug to me (reduced code, FILE* changed
to int*):
```d
@safe:
struct LockedFile
{
private int* fps;
auto fp() return scope => fps;
}
void main()
{
int* p;
{
auto lf = LockedFile(new int);
p = lf.fp;
}
assert(p != null); //
On Saturday, 19 November 2022 at 14:52:23 UTC, ag0aep6g wrote:
That's essentially just a function that returns its pointer
parameter. So the program boils down to this:
@safe:
int* fp(return scope int* p) { return p; }
void main()
{
int* p;
{
auto lf = new int;
p =
On Friday, 25 November 2022 at 15:03:57 UTC, ShadoLight wrote:
I don't grok how `lf` can survive the local scope. Or am I
missing something?
Perhaps because the local scope is not pushed as a separate
(anonymous) function on the stack... if true then, yes, then
`lf` will indeed have the same
On Sunday, 4 December 2022 at 16:33:35 UTC, rempas wrote:
struct MemoryBlock {
char* ptr;
ulong length;
}
(MemoryBlock.sizeof is 16 on my 64-bit system).
void* ptr = cast(void*)0x7a7;
void* right() {
return cast(MemoryBlock*)(ptr + MemoryBlock.sizeof); // Cast
the whole expression bet
On Thursday, 8 December 2022 at 17:39:58 UTC, Ali Çehreli wrote:
On 12/8/22 08:21, Salih Dincer wrote:
> void stringCopy(Chars)(string source,
> ref Chars target)
>sample.stringCopy = cTxt; // disappeared ? char
Nothing disappeared on my system. (?)
Going off-topic,
On Wednesday, 14 December 2022 at 17:41:07 UTC, Ali Çehreli wrote:
I've never used Unique but I think it has a bug (or a design
issue?): Its destructor is the following:
~this()
{
if (_p !is null)
{
destroy(_p);
_p = null;
}
}
Because
On Saturday, 19 November 2022 at 15:24:33 UTC, Dukc wrote:
On Saturday, 19 November 2022 at 15:02:54 UTC, Nick Treleaven
wrote:
OK, so how do I make `lf` implicitly scope?
Have the `int*` inside it to point to a local, or assign
another `scope int*` to it.
Thanks, this works:
```d
@safe:
On Thursday, 15 December 2022 at 20:02:38 UTC, Nick Treleaven
wrote:
auto f() return @trusted => p ? p : v.ptr;
Whoops, that can't be @trusted unless I `assert(p)`.
This code segfaults when the GC calls the dtor after the unittest
succeeds:
```d
unittest
{
int i;
struct S
{
~this() { i++; }
}
(*new S).destroy;
}
```
It seems destroy clears the context pointer. Is there a way to
test if the context pointer is null in the dtor, t
On Friday, 16 December 2022 at 12:17:40 UTC, Nick Treleaven wrote:
It seems destroy clears the context pointer. Is there a way to
test if the context pointer is null in the dtor, to prevent the
increment?
This seems to work:
~this() @trusted { if (&i > cast(void*)1024) i++; }
It woul
On Thursday, 15 December 2022 at 20:12:12 UTC, Ali Çehreli wrote:
I think this is a bug because the documentation clearly talks
about destroying the object:
OK: https://github.com/dlang/phobos/pull/8651
> do we need to do some kind of deprecation?
The behavior is so different from the inten
On Tuesday, 20 December 2022 at 06:31:09 UTC, ag0aep6g wrote:
On 16.12.22 14:07, Nick Treleaven wrote:
This seems to work:
~this() @trusted { if (&i > cast(void*)1024) i++; }
It would be better if there was a struct property to get the
context pointer though.
A quick test suggests
On Saturday, 2 April 2022 at 21:57:02 UTC, Marcone wrote:
Where I download Digital Mars C Preprocessor sppn.exe? I need
it to use ImportC
Found this thread by googling `dlang sppn.exe`. For the record,
it can be obtained from sppn.zip here:
http://ftp.digitalmars.com/
I didn't have it for so
On Monday, 23 January 2023 at 17:15:30 UTC, Nick Treleaven wrote:
On Saturday, 2 April 2022 at 21:57:02 UTC, Marcone wrote:
Where I download Digital Mars C Preprocessor sppn.exe? I need
it to use ImportC
Found this thread by googling `dlang sppn.exe`. For the record,
it can be obtained from s
On Friday, 20 January 2023 at 11:28:23 UTC, thebluepandabear
wrote:
```
final abstract class Algo {
void drawLine(Canvas c, Pos from, Pos to) { .. };
}
```
This solution seems like a bit of a hack, which is why I don't
like it.
Interesting solution if you put `static:` in there.
Alte
With -preview=nosharedaccess, I get:
int y = 2;
shared int x = y; // OK
assert(x == 2); // no error
y = x; // error
So for the assignment to y, reading x is an error and atomicLoad
should be used instead. But is it an oversight that reading x in
the assert is not an error?
I
On Thursday, 16 March 2023 at 12:32:34 UTC, Nick Treleaven wrote:
With -preview=nosharedaccess, I get:
int y = 2;
shared int x = y; // OK
assert(x == 2); // no error
y = x; // error
This also does not error:
```d
bool b = x == 3;
```
Filed:
https://issues.dlang.org/show_bug.cg
On Saturday, 18 March 2023 at 19:22:07 UTC, Chris Katko wrote:
...
So there's multiple sub-problems to solve. I asked this years
ago, and got 90% of the way done and then lost the code and
cannot find the original forum post.
Maybe it was this?:
https://forum.dlang.org/post/dqzxnctucwvyhstfz
On Sunday, 26 March 2023 at 18:07:03 UTC, ryuukk_ wrote:
What i find even more weird is writing fast code is ugly in D
Look at this ugly code
```D
__gshared int fast_code_ugly;
```
Because it should be rare that __gshared is used. And if you need
it, you won't be worried about how the storag
On Sunday, 26 March 2023 at 20:39:21 UTC, ryuukk_ wrote:
if my code doesn't do threads, why should i put my variable
into TLS?
I don't think writing __gshared is a huge burden. You can use
-vtls to print out all variables that are TLS, and add that to an
automated test to check you don't have
On Sunday, 26 March 2023 at 20:39:21 UTC, ryuukk_ wrote:
if my code doesn't do threads, why should i put my variable
into TLS?
I don't think writing __gshared is much of a burden. You can use
-vtls to print out all variables that are TLS, and add that to an
automated test to check you don't h
On Sunday, 26 March 2023 at 20:36:37 UTC, ryuukk_ wrote:
Golang doesn't even have thread local storage, yet they do very
well
Go doesn't have a solution to preventing data races at compile
time, they just say don't share memory. But what if you
accidentally share memory? That is *very* easy t
On Monday, 27 March 2023 at 08:44:41 UTC, wjoe wrote:
e.g.: It used to be faster to ...
- pre-calculate sin/cos tables, now the memory look up cost
more cycles than the calculation itself
...
- only redraw the parts of the screen that changed, now the
branching is slower than to redraw eve
On Tuesday, 2 May 2023 at 13:06:41 UTC, ag0aep6g wrote:
void fun(alias method)(C c)
{
void delegate() dg;
dg.funcptr = &method;
dg.ptr = cast(void*) c;
dg();
}
This also works:
void fun(alias method)(C c)
{
void delegate() dg = &c.method;
dg();
}
On Wednesday, 3 May 2023 at 11:26:00 UTC, ag0aep6g wrote:
On 03.05.23 13:13, Nick Treleaven wrote:
void fun(alias method)(C c)
{
void delegate() dg = &c.method;
dg();
}
No, it doesn't. You're not using the alias. You're just
accessing `c.method` directly. If the actual method weren
On Monday, 19 June 2023 at 18:19:18 UTC, mw wrote:
2) `inout T` alone
Steve covered everything, though you might also like to read the
inout spec:
https://dlang.org/spec/const3.html#inout
On Sunday, 16 July 2023 at 18:18:08 UTC, Alain De Vos wrote:
12 │ ~this(){
13 │ writeln("Free heap");
14 │ import object: destroy;
15 │ import core.memory: GC;
16 │ i=null; // But How to force GC free ?
Firstly, be careful with class destr
On Wednesday, 2 August 2023 at 13:27:50 UTC, Steven Schveighoffer
wrote:
On 8/2/23 7:40 AM, Nick Treleaven wrote:
Presumably an allocation like `new T` (for a type with a @safe
constructor) can be made anywhere a call to `GC.collect` can
be made, which may trigger a collection. So why isn't
`G
On Wednesday, 2 August 2023 at 17:52:00 UTC, Nick Treleaven wrote:
Now I'm wondering why those functions are marked `pure` - they
must affect the GC's bookkeeping state.
Here's the pull that added it:
https://github.com/dlang/druntime/pull/3561
On Wednesday, 2 August 2023 at 17:55:12 UTC, Nick Treleaven wrote:
On Wednesday, 2 August 2023 at 17:52:00 UTC, Nick Treleaven
wrote:
Now I'm wondering why those functions are marked `pure` - they
must affect the GC's bookkeeping state.
I guess it was because the GC's internal state is not sup
On Thursday, 17 August 2023 at 09:28:05 UTC, Joel wrote:
.map!(std.uni.toLower)
.sort!"aonlineapp.d(8): Error: none of the overloads of template
`std.algorithm.sorting.sort` are callable using argument types
`!("a
/dlang/dmd/linux/bin64/../../src/phobos/std/algor
On Wednesday, 30 August 2023 at 09:24:21 UTC, Paolo Invernizzi
wrote:
src/api3.d(49):called from here:
`checkSql(Schema("public",
src/dget/db.d(276): Error: template instance
`api3.forgeSqlCheckerForSchema!(Schema("public", **BAZILLIONS of lines**> error instantiating
```
The comp
On Tuesday, 19 September 2023 at 06:35:01 UTC, JG wrote:
On Tuesday, 19 September 2023 at 00:34:01 UTC, vino wrote:
//auto a = Array!string("Aname"); // throws error
auto b = Array!char("Bname");// works
auto c = Array!string("Aname", "Bname"); // works
...
Looks
On Tuesday, 19 September 2023 at 19:57:34 UTC, Nick Treleaven
wrote:
This is because a single array can be passed to a typesafe
variadic parameter rather than elements of that array type. And
then immutable(char) doesn't convert to string.
I think a non-variadic overload could be added to make
On Thursday, 21 September 2023 at 02:57:07 UTC, Ki Rill wrote:
On Thursday, 21 September 2023 at 02:23:32 UTC, Ki Rill wrote:
wrote:
[...]
Translated it to this eventually:
```D
auto nk_container_of(P, T)(P ptr, T type, const(char)* member)
{
return cast(T*)(cast(void*)(cast(char*)
On Thursday, 21 September 2023 at 16:28:25 UTC, Nick Treleaven
wrote:
return cast(T*)(cast(void*)(cast(char*)ptr -
__traits(getMember, T, member).offsetof)));
There's a trailing `)` that needs removing. Also pretty sure it
can be simplified to:
return cast(T*)(cast(char*)ptr
On Saturday, 7 October 2023 at 17:23:40 UTC, ryuukk_ wrote:
there was a DIP for tuple/deconstruction prior to that
question, sadly nothing came out of it,
I don't think it was formally submitted.
and now the language is frozen...
The DIP process is temporarily suspended, it may be modifie
On Thursday, 12 October 2023 at 19:33:32 UTC, Paul wrote:
If **int x** is global mutable state, what does static mutable
state look like?
In addition to Jonathan's reply, see:
https://dlang.org/spec/function.html#local-static-variables
On Tuesday, 10 October 2023 at 11:45:25 UTC, Dennis wrote:
```D
enum itoa(int i) = i.stringof;
static foreach(i; 0 .. 10) {
mixin(create_fn!(itoa!i));
}
```
You can also do it using a string mixin:
mixin(create_fn!(mixin("`", i, "`")));
I think that's equivalent to `i.stringof` anyway.
On Monday, 16 October 2023 at 18:05:04 UTC, Paul wrote:
On Thursday, 12 October 2023 at 21:20:44 UTC, Jonathan M Davis
wrote:
look like?
Types can have static members.
Basically what it comes down to is that outside of immutable
data, pure functions only have access to their arguments and
to
On Tuesday, 14 November 2023 at 13:58:17 UTC, Paul Backus wrote:
On Tuesday, 14 November 2023 at 13:41:32 UTC, Steven
Schveighoffer wrote:
```
Error: copy constructor `testinoutctor.S1.this(ref const(S1)
s) const` is not callable using argument types `(const(S1))`
```
I'm not sure what this m
On Friday, 24 November 2023 at 09:35:00 UTC, BoQsc wrote:
I tried to look into https://dlang.org/phobos/std_conv.html
Most of the functions inside `std.conv` seem to be dependant on
[Garbage Collection](https://dlang.org/spec/garbage.html).
And I couldn't find a straightforward way to produce
On Monday, 27 November 2023 at 12:34:30 UTC, Nick Treleaven wrote:
On Friday, 24 November 2023 at 09:35:00 UTC, BoQsc wrote:
You can use std.conv.toChars:
```d
void main() @nogc
{
int n = 515;
import std.conv;
char[10] s = 0;
auto r = n.toChars();
assert(r.length < s.length)
On Saturday, 2 December 2023 at 15:03:25 UTC, ryuukk_ wrote:
I wish we could use ``version`` as expression, to void the
repetition:
```D
import std.stdio;
enum HasTest = version (Test) ? true : false;
Tomek Sowiński wrote this template:
```d
enum bool isVersion(string ver) = !is(typeof({
On Tuesday, 5 December 2023 at 19:47:38 UTC, confuzzled wrote:
On 12/6/23 4:28 AM, Adam D Ruppe wrote:
On Tuesday, 5 December 2023 at 19:24:51 UTC, confuzzled wrote:
Given the following union
union F
{
double x;
struct {
ulong lo;
ulong hi;
}
}
The default value o
On Wednesday, 6 December 2023 at 12:38:35 UTC, Nick Treleaven
wrote:
Correct. So I expected a NaN output for x. However, I wasn't
expecting lo == 13835058055282163712 and hi == 32767 where x
is of type real, or lo == 9221120237041090560 and hi = 0 where
x is of type double. Based on the default
On Tuesday, 12 December 2023 at 16:21:46 UTC, Kevin Bailey wrote:
On Tuesday, 12 December 2023 at 15:20:23 UTC, Paul Backus wrote:
But unfortunately, the code shown now prints 120 lines of:
b
120 being suspiciously equal to 5!. The documentation[2] seems
to imply that this should be:
baa
On Monday, 22 January 2024 at 01:14:06 UTC, Steven Schveighoffer
wrote:
The language should not allow unary unsigned anything.
This is unlikely to get fixed, just due to the nature of D's
philosophy when it comes to C compatibility.
It would also break a lot of existing code.
I think the b
On Monday, 22 January 2024 at 19:11:50 UTC, Siarhei Siamashka
wrote:
On Monday, 22 January 2024 at 16:39:10 UTC, Nick Treleaven
wrote:
Memory safety issues are a worse class of bug than arithmetic
bugs. The latter are reproducible if you feed them the same
input.
Memory safety bugs are reprod
On Monday, 22 January 2024 at 19:49:19 UTC, Siarhei Siamashka
wrote:
The two's complement wraparound behavior mandated by the D
language spec is a non-technical political decision, intended
to make life easier for the DMD compiler developers, but
ignoring the needs of the users.
Actually it i
On Friday, 9 February 2024 at 15:19:32 UTC, bachmeier wrote:
It's been discussed many, many times. The behavior is not going
to change - there won't even be a compiler warning. (You'll
have to check with the leadership for their reasons.)
Was (part of) the reason because it would disrupt exist
On Saturday, 23 March 2024 at 19:30:29 UTC, Menjanahary R. R.
wrote:
for (T candidate = T(5); candidate * candidate <= n;
candidate += T(6)) {
When T is `const int`, the above code declares and initializes a
constant variable:
```d
const int candidate = const int(5);
```
Then, at the end
1 - 100 of 187 matches
Mail list logo
