Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 13:00:55 UTC, Ali Çehreli wrote:
On 12/17/21 1:57 AM, bauss wrote:
> You can also do it as a normal template:
>
> ```d
> template is_same(alias value, T)
> {
> enum is_same = is(typeof(value) == T);
> }
> ```
And even shorter by realizing that it's an eponymous template:
enum is_same(alias value, T) = is(typeof(value) == T);
Ali
Thanks guys! Yeah, I prefer Ali's shorter syntax!
Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 16:02:45 UTC, RazvanN wrote:
There is also a compiler trait [1] which can do that for you:
```d
void main()
{
int val = 10;
static if (__traits(isSame, typeof(val), int)) {}
}
```
[1] https://dlang.org/spec/traits.html#isSame
Thanks! The other options were simpler and faster to type tho
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:51:56 UTC, Ali Çehreli wrote:
On 12/17/21 10:01 AM, Tejas wrote:
> [...]
Storage,
There is no such requirement nor guarantee.
[...]
Well, I got completely mislead by my experiment
```d
struct S
{
~this() immutable {}
}
void main()
{
immutable S s = S();
}
```
This failed, so I just came up with reasons to justify this
behaviour
Thanks for correcting me
Re: This is bug or not? (immutable class containing struct with dtor)
On 12/17/21 10:01 AM, Tejas wrote:
> I think since `immutable` objects are kept in Read Only Storage,
There is no such requirement nor guarantee.
> you
> can't call destructors on them
Destructor is nothing but a piece of code that is executed when an
object's life ends. A destructor need not touch any member of the object:
struct S {
~this() {
import std.stdio;
writeln("done");
}
}
void main() {
immutable a = S();
auto b = immutable(S)();
}
Both objects are immutable there yet their destructor is executed.
> since the objects don't get erased when
> `~this` is called, but rather they get assigned their `.init` value,
That's true only for destroy(), which gets called only if the programmer
asks for it. Otherwise, destroyed objects don't get assigned any special
value.
> which tells the GC that they can be collected.
That's not true. The GC collects objects when there are no references to
them. The values of the object's members have nothing to do with it.
> `immutable class` has nothing to do with it, even the following fails to
> compile:
> ```d
>
>
>
> struct S
> {
> ~this() immutable {}
That immutable qualifier means "this destructor is for immutable objects
of this type." However, it seems impossible to define two destructors:
~this() {
writeln(__FUNCTION__);
}
~this() immutable {
writeln(__FUNCTION__);
}
Error: destructor `deneme.S.~this` conflicts with destructor
`deneme.S.~this` at deneme.d(79)
I think this is an unexplored corner of the language. Part of the
complication may be due to implementations by an earlier compiler
contributor, who I heard was responsible for qualifiers on constructors.
Note two different constructors here:
import std.stdio;
struct S {
this(int) {
writeln(__PRETTY_FUNCTION__);
}
this(int) immutable {
writeln(__PRETTY_FUNCTION__);
}
}
void main() {
auto a = immutable(S)(0);
auto b = S(1);
}
I bet the problem here is that the implementation in the compiler is
half-baked on these qualifiers.
Ali
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:32:43 UTC, Denis Feklushkin
wrote:
On Friday, 17 December 2021 at 18:02:52 UTC, Tejas wrote:
I improved your sample:
```d
immutable struct S
{
~this() {}
}
immutable struct S2
{
S sss;
~this() {}
}
void main()
{
S2 s = S2();
}
```
```
Error: `immutable` method `serializer_bug.S.~this` is not
callable using a mutable object
Error: mutable method `serializer_bug.S2.~this` is not callable
using a `immutable` object
serializer_bug.d(17,5):Consider adding `const` or
`inout` here
```
immutable dtor can't be called at all?
Nope, seems to go against the very promise it's making
Labelling `~this()` as const or immutable means it won't affect
the state of the object, but it will, by it's very nature.
That's why I said it's not too much of a stretch to imagine why
they're disallowed entirely.
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:02:52 UTC, Tejas wrote:
I improved your sample:
```d
immutable struct S
{
~this() {}
}
immutable struct S2
{
S sss;
~this() {}
}
void main()
{
S2 s = S2();
}
```
```
Error: `immutable` method `serializer_bug.S.~this` is not
callable using a mutable object
Error: mutable method `serializer_bug.S2.~this` is not callable
using a `immutable` object
serializer_bug.d(17,5):Consider adding `const` or `inout`
here
```
immutable dtor can't be called at all?
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:19:34 UTC, Denis Feklushkin wrote: On Friday, 17 December 2021 at 18:01:03 UTC, Tejas wrote: I think since `immutable` objects are kept in Read Only Storage Some of them can be stored in ROM in some cases, but actually "immutable" keyword means "not mutable for whole its lifetime" Well, it would be really weird if destructors successfully executed for some class of `immutable` qualified objects but didn't for others. Not too much of a stretch to imagine that destruction for immutable objects was outright disallowed. Someone who can explain this behaviour more thoroughly would be much appreciated Maybe we should allow finalizers to mutate their instance?
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:01:03 UTC, Tejas wrote: I think since `immutable` objects are kept in Read Only Storage Some of them can be stored in ROM in some cases, but actually "immutable" keyword means "not mutable for whole its lifetime"
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 18:01:03 UTC, Tejas wrote:
On Friday, 17 December 2021 at 17:34:05 UTC, Denis Feklushkin
wrote:
On Friday, 17 December 2021 at 17:27:53 UTC, Denis Feklushkin
wrote:
[...]
("serializer_bug" is just name of my local .d file)
I think since `immutable` objects are kept in Read Only
Storage, you can't call destructors on them since the objects
don't get erased when `~this` is called, but rather they get
assigned their `.init` value, which tells the GC that they can
be collected.
`immutable class` has nothing to do with it, even the following
fails to compile:
```d
struct S
{
~this() immutable {}
}
void main()
{
S s = S();
}
Error: `immutable` method `onlineapp.S.~this` is not callable
using a mutable object
```
Correction:
`immutable S s = S();` inside the `void main()`
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 17:34:05 UTC, Denis Feklushkin
wrote:
On Friday, 17 December 2021 at 17:27:53 UTC, Denis Feklushkin
wrote:
~this() {} // Comment out this to fix this compilation
error:
// Error: `immutable` method `serializer_bug.Imm.~this` is
("serializer_bug" is just name of my local .d file)
I think since `immutable` objects are kept in Read Only Storage,
you can't call destructors on them since the objects don't get
erased when `~this` is called, but rather they get assigned their
`.init` value, which tells the GC that they can be collected.
`immutable class` has nothing to do with it, even the following
fails to compile:
```d
struct S
{
~this() immutable {}
}
void main()
{
S s = S();
}
Error: `immutable` method `onlineapp.S.~this` is not callable
using a mutable object
```
Re: This is bug or not? (immutable class containing struct with dtor)
On Friday, 17 December 2021 at 17:27:53 UTC, Denis Feklushkin
wrote:
~this() {} // Comment out this to fix this compilation
error:
// Error: `immutable` method `serializer_bug.Imm.~this` is
("serializer_bug" is just name of my local .d file)
This is bug or not? (immutable class containing struct with dtor)
```d
/+ dub.json:
{
"name": "test",
"dependencies": {
}
}
+/
struct S
{
~this() {}
}
immutable class Imm
{
S s; // this is immutable value because whole class is
immutable
this()
{
s = S();
}
~this() {} // Comment out this to fix this compilation error:
// Error: `immutable` method `serializer_bug.Imm.~this` is
not callable using a mutable object
// What mutable object is meant here?
}
void main()
{
auto ic = new immutable Imm();
}
```
Run: $ dub --single bug.d
Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 07:52:18 UTC, rempas wrote:
I want to use an expression and put it in place inside the `if`
parentheses. The expression is: `is(typeof(val) == type)`. I
want to use a template called "is_same" that will take the
value and a type to place them to the respective places. I have
tried the following but it doesn't seem to work:
```
mixin template is_same(val, type) {
is(typeof(val) == type)
}
void main() {
int val = 10;
static if (is_same!(val, int)) {}
}
```
When trying to compile, I'm taking the following error message:
```
Error: declaration expected, not `is`
```
Is this a limitation of templates in D or is there a way to
bypass this?
There is also a compiler trait [1] which can do that for you:
```d
void main()
{
int val = 10;
static if (__traits(isSame, typeof(val), int)) {}
}
```
[1] https://dlang.org/spec/traits.html#isSame
Re: Is it possible to do this with a template?
On 12/17/21 1:57 AM, bauss wrote:
> You can also do it as a normal template:
>
> ```d
> template is_same(alias value, T)
> {
> enum is_same = is(typeof(value) == T);
> }
> ```
And even shorter by realizing that it's an eponymous template:
enum is_same(alias value, T) = is(typeof(value) == T);
Ali
Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 08:59:19 UTC, rempas wrote:
On Friday, 17 December 2021 at 08:44:39 UTC, Mitacha wrote:
It isn't really about limitation of templates. You're trying
to use mixin template and it's main purpose is to inject
declarations. If you want to replace `is expression` with
template you could use something like this:
```d
bool is_same(alias value, T)() {
return is(typeof(value) == T);
}
void main() {
int value = 10;
static if (is_same!(value, int)) {
writeln("it is true!");
} else {
writeln("it is false!");
}
}
```
Oh! That's nice! I didn't even knew it was possible to create
template functions like this! Thanks!
Personally, I don't see any benefit with replacing that kind
of `is expressions` with templates. Perhaps I'm missing
something :)
The benefits are typing less code and make it more readable and
easy on the eyes ;)
You can also do it as a normal template:
```d
template is_same(alias value, T)
{
enum is_same = is(typeof(value) == T);
}
```
Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 08:44:39 UTC, Mitacha wrote:
It isn't really about limitation of templates. You're trying to
use mixin template and it's main purpose is to inject
declarations. If you want to replace `is expression` with
template you could use something like this:
```d
bool is_same(alias value, T)() {
return is(typeof(value) == T);
}
void main() {
int value = 10;
static if (is_same!(value, int)) {
writeln("it is true!");
} else {
writeln("it is false!");
}
}
```
Oh! That's nice! I didn't even knew it was possible to create
template functions like this! Thanks!
Personally, I don't see any benefit with replacing that kind of
`is expressions` with templates. Perhaps I'm missing something
:)
The benefits are typing less code and make it more readable and
easy on the eyes ;)
Re: Is it possible to do this with a template?
On Friday, 17 December 2021 at 07:52:18 UTC, rempas wrote:
I want to use an expression and put it in place inside the `if`
parentheses. The expression is: `is(typeof(val) == type)`. I
want to use a template called "is_same" that will take the
value and a type to place them to the respective places. I have
tried the following but it doesn't seem to work:
```
mixin template is_same(val, type) {
is(typeof(val) == type)
}
void main() {
int val = 10;
static if (is_same!(val, int)) {}
}
```
When trying to compile, I'm taking the following error message:
```
Error: declaration expected, not `is`
```
Is this a limitation of templates in D or is there a way to
bypass this?
It isn't really about limitation of templates. You're trying to
use mixin template and it's main purpose is to inject
declarations. If you want to replace `is expression` with
template you could use something like this:
```d
bool is_same(alias value, T)() {
return is(typeof(value) == T);
}
void main() {
int value = 10;
static if (is_same!(value, int)) {
writeln("it is true!");
} else {
writeln("it is false!");
}
}
```
Personally, I don't see any benefit with replacing that kind of
`is expressions` with templates. Perhaps I'm missing something :)
