On Wednesday, 28 July 2021 at 21:39:43 UTC, jfondren wrote:
I don't know, but .byValue is @safe and returns a forward
range, so you could use `.init.byValue.array` instead.
Great point. Thanks.
Why is call to `values` in, for instance,
```d
auto _ = string[string].init.values;
```
not `@safe`?
On Thursday, 15 July 2021 at 11:08:25 UTC, Per Nordlöw wrote:
The adding of copy construtors to `Service` defined as
```d
@safe struct Service {
this(ref return scope typeof(this) rhs) {}
this(const ref return scope typeof(this) rhs) const {}
}
Using `inout` as
```d
@safe struct
On Thursday, 15 July 2021 at 11:08:25 UTC, Per Nordlöw wrote:
fails in the same way. What's wrong?
```d
@safe struct Service {
this(ref typeof(this) rhs) {}
this(const ref typeof(this) rhs) const {}
}
```
also fails. On the other hand, using a postblit as
```
@safe struct Service {
The adding of copy construtors to `Service` defined as
```d
@safe struct Service {
this(ref return scope typeof(this) rhs) {}
this(const ref return scope typeof(this) rhs) const {}
}
@safe struct Session {
void openAndGetService(in string key) scope {
import
Given
```d
import std.range.primitives : isInputRange;
enum isDumb(Args...) = (Args.length == 2 && Args.length == 3);
void f(Args...)(Args args)
if (isDumb!(Args))
{
}
void g(Arg)(Arg arg)
if (isInputRange!(Arg))
{
}
@safe pure unittest
{
f(2, 3);
g(2);
}
```
`dmd` diagnoses the
On Thursday, 6 May 2021 at 01:04:02 UTC, Jack wrote:
Does it allocate the object rather on stack, like auto scope a
= new A or what?
Further note that
auto scope a = new A;
can be written shorter as
scope a = new A;
On Monday, 4 March 2019 at 00:07:39 UTC, r-const-dev wrote:
I'm trying to implement a thread safe class, guarding data
access with synchronized and atomicOp.
To get more help with memory safety checking from the compiler,
please instead use `@safe` as
```d
import std.typecons : Nullable;
On Monday, 12 April 2021 at 20:50:49 UTC, Per Nordlöw wrote:
more aggressive collections when nearing it.
What is a more aggressive collection compared to a normal
collection? Unfortunately we still have no move support in D's GC
because of its impreciseness.
On Monday, 12 April 2021 at 20:50:49 UTC, Per Nordlöw wrote:
I'm surprised there is no such functionality available.
It doesn't sound to me like it's that difficult to implement.
Afaict, we're looking for a way to call `GC.collect()` when
`GC.Status.usedSize` [1] reaches a certain threshold.
On Monday, 12 April 2021 at 07:03:02 UTC, Sebastiaan Koppe wrote:
On side-note, it would also be good if the GC can be aware of
the max memory it is allotted so that it knows it needs to do
more aggressive collections when nearing it.
I'm surprised there is no such functionality available.
It
Inside dmd source tree, under sub-directory test, I do
./run.d compilable/
. This errors as
```
... compilable/json.d -d -preview=dip1000 -o- -X
-Xf/home/per/Work/dmd/test/test_results/compilable/json.out
-fPIC ()==
Test 'compilable/json.d'
https://forum.dlang.org/post/rkxnfxsjvkffxufok...@forum.dlang.org
On Thursday, 1 January 2015 at 19:18:34 UTC, Nordlöw wrote:
Do we really need Append and Prepend (along with append and
prepend) here? Doesn't [cC]hain already fulfill the needs of a
lazy range in this case inplace of Append?
On Sunday, 4 April 2021 at 11:48:37 UTC, Imperatorn wrote:
On Sunday, 4 April 2021 at 11:12:36 UTC, Per Nordlöw wrote:
Trying to access https://dlang.slack.com/ hangs for minutes on
my machine.
I'm only using the app, same thing there for you? 樂
I was trying the desktop version. Works now.
Trying to access https://dlang.slack.com/ hangs for minutes on my
machine.
On Wednesday, 24 March 2021 at 10:25:21 UTC, Basile B. wrote:
In now way. But in your question you mentioned @nogc nothrow
and not @safe and pure.
Ok, thanks.
Note that core.exception.onOutOfMemoryError is already qualified
as @nogc nothrow pure @trusted.
On Wednesday, 24 March 2021 at 08:31:19 UTC, Basile B. wrote:
There are several ways to do that. In addition to
onOutOfMemoryError, you can use a static instance
void v() @nogc nothrow
{
__gshared oom = new OutOfMemoryError();
auto X* = X_create();
if (X is null)
throw
When wrapping C code that tries to allocate memory resources via
functions such as
X* X_create();
should one call `onOutOfMemoryError();` upon null return?
Making more D wrappers `nothrow @nogc`.
On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer
wrote:
And the answer is complex. You can't accept a const range,
because they don't work. The only way to have purity infer
uniqueness is to accept paramters that the result could not
have come from. Usually this means accepting
On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer
wrote:
const(char)[] x = "foo";
string chained = chainPath(x, "bar").array;
that calls the template overload
ForeachType!Range[] array(Range)(Range r)
if (isIterable!Range && !isAutodecodableString!Range &&
!isInfinite!Range)
On Monday, 22 March 2021 at 20:38:36 UTC, Per Nordlöw wrote:
chainPath(...).array
To clarify, for instance, given
string s;
const(char)[] c;
all the calls
chainPath(s, s).array
chainPath(c, c).array
chainPath(s, c).array
chainPath(c, s).array
return
Am I the only one being annoyed by the fact that
chainPath(...).array
doesn't implicit convert to string despite the array returned
from .array is allocated by the GC.
Yes, I know that I should do
chainPath(...).array.assumeUnique
but the uniqueness of .array (and in turn implicit
On Tuesday, 16 March 2021 at 13:31:34 UTC, Imperatorn wrote:
foreach(0..n) could work. Why though.
When performing a side-effect n times.
I find myself writing
foreach (_; 0 .. n)
doSomething(); // no using the variable `_`
.
What about relaxing the syntax to allow
foreach (; 0 .. n)
and/or
foreach (0 .. n)
?
Thereby making the `ForeachTypeList` of `AggregateForeach` in the
grammar rule [1] optional.
[1]
On Tuesday, 9 February 2021 at 03:05:10 UTC, frame wrote:
On Sunday, 7 February 2021 at 14:13:18 UTC, vitamin wrote:
Why using 'new' is allowed in pure functions but calling
GC.addRange or GC.removeRange isn't allowed?
Would making
`new T[]` inject a call to `GC.addRange` based on `T` (and
On Monday, 1 February 2021 at 15:47:33 UTC, Steven Schveighoffer
wrote:
"Concatenation always creates a copy of its operands, even if
one of the operands is a 0 length array"
Btw, does
x ~ y ~ z ~ ...
result in a single allocation?
On Monday, 1 February 2021 at 16:30:31 UTC, Per Nordlöw wrote:
Btw, does
x ~ y ~ z ~ ...
result in a single allocation?
Provided all the operands has a `length` property.
On Monday, 1 February 2021 at 10:27:29 UTC, Jacob Carlborg wrote:
Why isn't
"Name " ~ name ~ " could not be found"
implicitly convertible to `string`?
Because if you have arrays of reference types, it's possible to
change an element of the mutable array, which will affect the
immutable
On Monday, 1 February 2021 at 10:24:59 UTC, Mike Parker wrote:
There is no "extra" instance because there's no single instance
of an enum value. They have no address. When you use one, it's
just as if you were writing the literal instead of the enum
name. In other words:
enum ea = [1, 2, 3];
On Monday, 1 February 2021 at 11:37:49 UTC, Per Nordlöw wrote:
Ok, so then my follow-up question becomes, does the right hand
sides of these two assignment share the same AST node? If not,
why?
Because such a shared AST node could be potentially mutated in
different ways in different
On Monday, 1 February 2021 at 09:52:07 UTC, Jacob Carlborg wrote:
If you don't want a new instance, then don't use `enum`. Use
`immutable` instead.
Agreed. My question is why does an `enum` require an extra
instance from a compiler architecture point of view? Do all
compilers handle
An enum only exists at compile-time, and does not occupy any
space. Each time it's referenced, a new instance of the value
is created. Why is that? Seems like a waste of resources to the
compiler.
Given
char x[];
why is
typeof("a" ~ x)
`char[]` when
typeof("a" ~ x.idup)
is
`string`?
My case is
class NameLookupException : Exception
{
this(string name) {
super("Name " ~ name ~ " could not be found");
}
this(scope const(char)[] name) {
On Tuesday, 19 January 2021 at 21:04:51 UTC, kdevel wrote:
And then? I mean: What do you want to do with the long what
could not
be done with the double in the first place?
Motivated question.
We want to propagate to our system locally that a double received
from a network communication
On Tuesday, 19 January 2021 at 16:14:17 UTC, drug wrote:
https://dlang.org/phobos/std_bitmanip.html#FloatRep
Doesn't this pattern already cover all possible cases of `value`
needed?
void f(double value)
{
auto lvalue = cast(long)value;
if (lvalue == value) // `value` lacks
On Tuesday, 19 January 2021 at 17:03:53 UTC, Ali Çehreli wrote:
I think it would be a useful improvement.
Indeed. Maybe Ilya could help out adding this to dmd.
On Tuesday, 19 January 2021 at 13:36:58 UTC, Steven Schveighoffer
wrote:
Use a cast instead.
const lvalue = cast(long)value;
Ahh, good point.
Followd by a compare of the original value I presume.
I want to convert a double to a long if conversion is lossless
(without fractional part, non-nan, non-inf, within long-range,
etc).
I currently have
void foo()
{
const double value = 10.1;
try
{
import std.conv : to;
const lvalue = value.to!long;
if (lvalue
On Sunday, 3 January 2021 at 18:26:44 UTC, Per Nordlöw wrote:
alias Matcher = Match function(Matcher[] matchers...);
but it errors as
recursive alias declaration
Preferrably I wanted a non-templated definition.
How can I define a function type `Matcher` that takes an array of
`Matcher`s and returns an instance of a `struct Match` defined as
struct Match
{
@safe pure nothrow @nogc:
static Match zero()
{
return typeof(return)(0);
}
static Match none()
{
return
On Wednesday, 18 November 2020 at 23:43:15 UTC, Petar Kirov
[ZombineDev] wrote:
https://gist.github.com/PetarKirov/b4c8b64e7fc9bb7391901bcb541ddf3a
Thanks a lot!
On Monday, 16 November 2020 at 10:21:27 UTC, Per Nordlöw wrote:
Which DUB packages do you prefer?
https://code.dlang.org/packages/dlibgit seems good. But that
requires `libgit` to be installed. It would be nice to have a
fallback to calling `git`.
I need a function that gets the relative path of a file in a
Git-repo and preferrably also its status.
Either via an external call to `git` or optionally via `libgit`
(if available).
Which DUB packages do you prefer?
On Monday, 9 November 2020 at 16:39:49 UTC, Boris Carvajal wrote:
There's also:
dchar(0xd8000)
Thanks
On Thursday, 12 November 2020 at 09:22:10 UTC, Per Nordlöw wrote:
Why don't I get a stack trace on Memory allocation exceptions?
Is it because the stack may be corrupted?
Why don't I get a stack trace on Memory allocation exceptions?
In my case I only get:
src/core/exception.d(647): [unittest] Memory allocation failed
core.exception.OutOfMemoryError@src/core/exception.d(647): Memory
allocation failed
On Monday, 9 November 2020 at 17:06:50 UTC, H. S. Teoh wrote:
I'm pretty sure std.regex already supports Unicode regexes.
Yep [1].
Thanks
[1]
https://dlang.org/phobos/std_regex.html#Syntax%20and%20general%20information
Is there any library that can deal with decoding and generating
character matchers for Unicode regular expression described at
https://www.regular-expressions.info/unicode.html
On Sunday, 8 November 2020 at 10:47:34 UTC, Per Nordlöw wrote:
cast(dchar)0xd8000
To clarify,
enum dch1 = cast(dchar)0xa0a0;
enum dch2 = '\ua0a0';
assert(dch1 == dch2);
works. Can I use the first-variant if I want to postpone these
encoding questions for now?
On Saturday, 7 November 2020 at 17:49:54 UTC, Jacob Carlborg
wrote:
[1] https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF
Thanks!
I'm only using these UTF characters to create ranges that source
code characters as checked against during parsing. Therefore I
would like to just convert
I'm writing a parser generator for ANTLR-grammars and have come
across the rule
fragment Letter
: [a-zA-Z$_] // these are below 0x7F
| ~[\u-\u007F\uD800-\uDBFF] // covers all characters
above 0x7F which are not a surrogate
| [\uD800-\uDBFF] [\uDC00-\uDFFF] // covers UTF-16
On Tuesday, 27 October 2020 at 10:46:42 UTC, Jacob Carlborg wrote:
[1] http://mustache.github.io/mustache.5.html
[2] https://code.dlang.org/packages/mustache-d
Thanks
I'm looking for elegant ways of expressing expansion of
parameterized strings written to a file at run-time. My primary
use case is run-time generation of D code. In the lazy case,
something like
import std.file : write;
import std.algorithm : substitute;
const s = q{int $X =
I need a string template system for generation of parsers in D
code to compiled in separate phase (not Pegged).
What packages is there for this?
If I want GC-free string formatting and outputting to
stdout/stderr what packages should I prefer at code.dlang.org?
On Saturday, 17 October 2020 at 13:42:46 UTC, Steven
Schveighoffer wrote:
I think it *should* be possible to do this, if it's not
already, just with pragmas. (i.e. pack T but not S).
Agree, a pragma, say `pragma(pack)`, to control this would be
great to avoid the unsafe union hack.
On Saturday, 17 October 2020 at 13:23:38 UTC, Adam D. Ruppe wrote:
Use a union.
Nice! Thanks!
On Saturday, 17 October 2020 at 12:51:21 UTC, ag0aep6g wrote:
c does come directly after s. The padding between b and c is
part of s. If you don't want that padding, you can use
`align(1)` to define S without padding. But then 75% of the
ints in an S[] will be misaligned.
I understand that.
On Saturday, 17 October 2020 at 12:44:44 UTC, Per Nordlöw wrote:
Can `align`s be inserted in S or/and T so that T is packed to 8
bytes but still aligned to 8 bytes? I don't see why this
shouldn't be the default behaviour...
I though this would do the trick but not...
struct S
{
On Saturday, 17 October 2020 at 12:35:37 UTC, Per Nordlöw wrote:
On Friday, 16 October 2020 at 21:26:12 UTC, Steven
Schveighoffer wrote:
To further explain this -- the padding is added so things like
pointer arithmetic on an array work.
In my code sample above one can only access the first
On Friday, 16 October 2020 at 21:26:12 UTC, Steven Schveighoffer
wrote:
To further explain this -- the padding is added so things like
pointer arithmetic on an array work.
In my code sample above one can only access the first element
anyhow so I don't understand why this restriction is
Why is `Appender`'s store `Data` put directly as
`private Data* _data;`
instead of
`private Data _data;`
?
Removing the pointer indirection would give better locality.
If it's about optimizing for empty `Appender`s then a `Appender*`
should be used in those cases instead.
Why is `T.sizeof` 12 instead of 8 when `U.sizeof` is 8 in the
following example?
struct S
{
int i;
bool b;
}
struct T
{
S s;
char c;
}
struct U
{
int i;
bool b;
char c;
}
?
On Monday, 28 September 2020 at 10:01:23 UTC, ikod wrote:
Is it specific to some types? What if collection supports
stable "foreach"?
Yes it depends on how collection members (such as insert, find,
replace, erase, etc) are implemented.
I presume we need attributes on mutating collection
On Monday, 28 September 2020 at 07:15:27 UTC, Imperatorn wrote:
Yes, this should be a compile-time error
Spec here:
https://dlang.org/spec/statement.html#foreach_restrictions
On Monday, 28 September 2020 at 08:26:15 UTC, Per Nordlöw wrote:
In the case where the AA-KeyType is a class (which is
represented as a pointer in D) I want the equality (opEquals)
and the hashing (toHash) of the AA to compare and hash the
pointers themselves, not the fields the classes points
On Sunday, 27 September 2020 at 19:45:07 UTC, Ferhat Kurtulmuş
wrote:
Sorry I did not understand what you meant. It would be better
if you share the answer here. I found this also
https://dlang.org/library/std/traits/key_type.html, but I dont
know if it is related.
In the case where the
On Sunday, 27 September 2020 at 14:23:11 UTC, H. S. Teoh wrote:
No. Modifying a container while iterating over it is, in
general, a bad idea (unless the container is designed to be
used that way, but even then, such removal is generally
restricted), because it often leads to highly
On Sunday, 27 September 2020 at 18:39:10 UTC, Per Nordlöw wrote:
How do I defined an AA with class as key where keys are
compared using `is` instead of `opEquals`? Do I have to store
the key as a `void*`?
I got a good answer at
https://dlang.slack.com/archives/C1ZDHBB2S/p1601234030016700
On Sunday, 27 September 2020 at 18:56:15 UTC, Ferhat Kurtulmuş
wrote:
By looking at object.d and aaA.d of druntime, I d say you don't
need to use void*. Object class has required infrastructure
ready for using classes aa keys (have not tried though). Object
class has both toHash and opEquals
How do I defined an AA with class as key where keys are compared
using `is` instead of `opEquals`? Do I have to store the key as a
`void*`?
Is it safe to remove AA-elements from an `aa` I'm iterating over
via aa.byKeyValue?
I'm currently doing this:
foreach (ref kv; aa.byKeyValue)
{
if (pred(kv.key))
aa.remove(kv.key); // ok?
}
if (aa.length == 0)
aa = null;
Is there a better way?
On Wednesday, 23 September 2020 at 00:06:38 UTC, DlangUser38
wrote:
Hmm, why would `b` have longer lifetime? Isn't the lifetime of
`b` throughout `bar`?
The following analysis might be wrong but I think that `scope`
as a **member** function attribute is not supposed to be used
as that is not
On Saturday, 19 September 2020 at 18:48:31 UTC, Jacob Carlborg
wrote:
A nested class seems to be able to escape the `this` reference:
Ahh, thanks.
I just realized that it can escape into other parameters without
the `scope` qualifier?
This
class Bar
{
void bar(scope Bar b) @safe pure
On Saturday, 19 September 2020 at 16:07:24 UTC, Per Nordlöw wrote:
If an aggregate member is pure but not scope when can it escape
the `this` pointer?.
Or rather when and, if so, how can the member allow its `this`
pointer to escape?
It seems to me like the `scope` qualifier is no effect in
If an aggregate member is pure but not scope when can it escape
the `this` pointer?.
Only via return?
In the struct and class case?
On Tuesday, 18 August 2020 at 08:03:04 UTC, Per Nordlöw wrote:
Forgot to mention that I want to support variadic arguments to
`ctLog` similar to what is done with
And these arguments should be of any template argument kind, not
only a compile-time string.
On Monday, 17 August 2020 at 22:37:12 UTC, Simen Kjærås wrote:
mixin template ctLog(string msg, string file = __FILE__, size_t
line = __LINE__) {
pragma(msg, file, "(", line, "): ", msg);
}
Thanks.
Forgot to mention that I want to support variadic arguments to
`ctLog` similar to what is
I'm using
pragma(msg, __FILE__, "(", __LINE__, ",1): Debug: ", "A
useful debug message");
to print compile-time information formatted as standard compiler
diagnostics.
These are picked up by Emacs Flycheck and overlayed in the editor
and listen in the *Flycheck errors* buffer. Very
On Monday, 10 August 2020 at 05:54:14 UTC, Daniel Kozak wrote:
I am not sure but last time I checked ldc does not do cross
module inlinig by default, and LTO only help if your
ldc(druntime+phobos) are built with enabled LTO[1]
[1]
On Sunday, 9 August 2020 at 22:45:16 UTC, claptrap wrote:
I'm not 100% sure but I think LDC did cross module inlining by
default at some point, then I updated the compiler and had to
add the LTO thing. I think there is an option to enable just
cross module inlining, but if you want speed
Is cross-module-inlining enabled by default in LDC when compiling
in release mode or do I have to use explicitly flag for it? I
can't find any such flag from the output of neither
ldc2 -h
nor
ldmd2 -h
.
Johan Engelen mentioned this, then experimental, flag in his
DConf talk from
On Thursday, 6 August 2020 at 22:24:43 UTC, Paul Backus wrote:
[1] https://dlang.org/spec/expression.html#is_expression
Thanks
On Friday, 7 August 2020 at 23:58:03 UTC, Adam D. Ruppe wrote:
Maybe someday we can link in dub's update to click that button
for you but for the foreseeable future you need to hit it
yourself to update the docs.
Got it. Thanks a lot for now, anyway.
I've pushed a new tag several times now and triggered manual
update of my
https://code.dlang.org/packages/phobos-next
but the docs at
https://phobos-next.dpldocs.info/index.html
aren't updated. For instance the file
https://github.com/nordlow/phobos-next/blob/master/src/nxt/open_hashmap.d
On Thursday, 6 August 2020 at 22:24:43 UTC, Paul Backus wrote:
[1] https://dlang.org/spec/expression.html#is_expression
I bet there a several places in Phobos where this feature isn't
but could be used.
On Thursday, 6 August 2020 at 22:24:43 UTC, Paul Backus wrote:
[1] https://dlang.org/spec/expression.html#is_expression
Thanks
I just discovered that the is-operator can be used as in
template ElementType(R)
{
static if (is(typeof(R.init.front.init) T))
alias ElementType = T;
else
alias ElementType = void;
}
. Very powerful. Is this documented?
On Thursday, 6 August 2020 at 21:50:06 UTC, Per Nordlöw wrote:
I just discovered that the is-operator can be used as in
...
Doh, title should of course be
I just discovered an alternative use of `is`-expressions.
On Thursday, 6 August 2020 at 13:18:40 UTC, Per Nordlöw wrote:
Can somebody find a better alternative?
Let's continue discussion at
https://github.com/dlang/phobos/pull/7582
On Thursday, 6 August 2020 at 13:07:14 UTC, Per Nordlöw wrote:
Do you have any simple solution to this, H. S. Teoh?
I also tried
template maxSize(Ts...)
{
align(1) union Impl
{
// See_Also:
https://forum.dlang.org/thread/wbpnncxepehgcswhu...@forum.dlang.org?page=1
On Thursday, 6 August 2020 at 12:51:22 UTC, H. S. Teoh wrote:
Of course. In fact, it's trivial:
--
template maxSizeOf(T...)
{
align(1) union Impl {
T t;
}
enum maxSizeOf = Impl.sizeof;
}
I originally copied my original version of `maxSizeOf` from
On Thursday, 6 August 2020 at 12:51:22 UTC, H. S. Teoh wrote:
Of course. In fact, it's trivial:
--
template maxSizeOf(T...)
{
align(1) union Impl {
T t;
}
enum maxSizeOf = Impl.sizeof;
}
Clever. Thanks
On Thursday, 6 August 2020 at 01:13:28 UTC, Ali Çehreli wrote:
Boring in D. :p
template maxSizeOf(T...) {
enum maxSizeOf = compute();
auto compute() {
size_t result;
static foreach (t; T) {
if (t.sizeof > result) {
result = t.sizeof;
}
}
return result;
On Thursday, 6 August 2020 at 01:13:41 UTC, Adam D. Ruppe wrote:
It is very easy too... just write an ordinary function:
size_t maxSizeOf(T...)() {
size_t max = 0;
foreach(t; T)
if(t.sizeof > max)
max = t.sizeof;
return max;
}
On Thursday, 6 August 2020 at 01:17:51 UTC, lithium iodate wrote:
more love for phobos pls
template maxSizeOf(T...)
{
template sizeOf(T) { // doesn't exist in phobos?
enum sizeOf = T.sizeof;
}
enum size_t maxSizeOf = maxElement([staticMap!(sizeOf, T)]);
}
On Thursday, 6 August 2020 at 01:13:28 UTC, Ali Çehreli wrote:
Boring in D. :p
template maxSizeOf(T...) {
enum maxSizeOf = compute();
auto compute() {
size_t result;
static foreach (t; T) {
if (t.sizeof > result) {
result = t.sizeof;
}
}
return result;
Is it possible to implement
template maxSizeOf(T...)
{
static if (T.length == 1)
enum size_t maxSizeOf = T[0].sizeof;
else
{
enum size_t firstSize = T[0].sizeof;
enum size_t maxSizeRest = maxSizeOf!(T[1 .. $]);
enum size_t maxSizeOf = firstSize >=
On Wednesday, 22 January 2020 at 15:11:09 UTC, Jacob Carlborg
wrote:
BTW, why don't you implement `opCmp` with the built-in
comparison operators. Those are going to get lower to a call to
`__cmp`. Something like this:
int opCmp()(const scope typeof(this) that) const @nogc
{
auto a =
On Sunday, 26 July 2020 at 21:48:09 UTC, Per Nordlöw wrote:
I see. Thanks.
The code
long add_long_n0(alias T=void)(long x) { return x + 0; }
should be
long add_long_n0(T=void)(long x) { return x + 0; }
. My mistake.
Thanks.
1 - 100 of 802 matches
Mail list logo
