Re: Better debugging?
On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: Hi all, I am currently using GDB within VScode with the -gc DMD2 compiler switch and my debugging is not amazing. Whenever I inspect a struct/object it just shows me the pointer rather than the object information and strings come up as a gross array of the characters. Does anybody happen to know whether LDB is better or how I can have a nicer debug environment? Thanks in advance Might be something for Iain to weigh in one when it comes to GDC specifically but the non-dmd compilers generate better debug info.
Re: Python's list equivalent with std.variant?
On 10/3/21 3:22 PM, rjkilpatrick wrote: > I am trying to emulate Python's list in D, to store some derived classes I notice your code comment about SuperClass[]. It is still the most obvious solution here. You just need to check the reuslt of a cast(DerivedClass): import std.stdio : writefln; import std.variant; import std.conv; // Arbitrary super class class SuperClass { this() { } } // Derived class with members class DerivedClass : SuperClass { public: this(float a) { this.a = a; } float a; } class OtherDerivedClass : SuperClass {} void main() { // When we use `SuperClass[] list;` here, we find 'a' is hidden by the base class // [Ali]: When you must know what the exact derived type you //are using, generally there is a better approach. // //Assuming that you really want to "downcast", then you //simply cast to DerivedClass and see whether the //pointer is null or not. (See below.) SuperClass[] list; // Attempting to append derived class instances to list list ~= new DerivedClass(1.0f); list ~= new OtherDerivedClass; foreach (i, item; list) { auto p = cast(DerivedClass)item; if (p) { writefln!"%s: Yes, a DerivedClass object with a == %s."(i, p.a); } else { writefln!"%s: No, not a DerivedClass object."(i); } } } Ali
Re: Better debugging?
On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: Hi all, I am currently using GDB within VScode with the -gc DMD2 compiler switch and my debugging is not amazing. Whenever I inspect a struct/object it just shows me the pointer rather than the object information and strings come up as a gross array of the characters. Does anybody happen to know whether LDB is better or how I can have a nicer debug environment? Thanks in advance 1. LDC2 generate better debug infos, especially for classes, although this might change from the next DMD version (it will include the inherited fields, just like LDC2). 2. to inspect objects you must evluate the dereference of an instance. for example for a project, if i eval `d`, a class instance VS `*d`, the pointed chunk of memory. | name| value | ---| --- d | 0x77b4b480 s | 0x77b506c0 locParentAggr | 0x0 symParentAggr | 0x0 thisParentAggr | 0x0 needInheritance | false this | 0x77b506c0 loc | 0x77b43ea0 evaluation of `d` | 0x77b4b480 evaluation of `*d` | { = { = {}, startPos = {line = 18, column = 1}, ir = 0x0}, name = 0x77b4e5e0, symbol = 0x77b506c0, attributes = 0x0, asTypeDeclared = 0x77b50720, kind = 34 '\"', protection = 0 '\\000', progress = 0 '\\000'} I don't know how the debugger gui you use works, here this is just a paste of dexed-ide table for locals and custom expressions. More often I use a debug popup: ![](https://i.imgur.com/cGdQfOr.png) [A similar feature seems possible in vscode](https://github.com/microsoft/vscode-java-debug/issues/444), maybe post a feature request to the extension developpers, as the debug popup is often very handy (no need to type expressions, as they are already there in the code !)
Re: Python's list equivalent with std.variant?
On Sunday, 3 October 2021 at 22:22:48 UTC, rjkilpatrick wrote: ```d void main() { // When we use `SuperClass[] list;` here, we find 'a' is hidden by the base class Variant[] list; // Attempting to append derived class instances to list list ~= new DerivedClass(1.0f); list ~= new OtherDerivedClass; list[0].a; list[0].to!(get!(list[0].type)).a.writeln; } ``` This works: ```d void main() { Variant[] list; list ~= new DerivedClass(1.0f).Variant; list ~= new OtherDerivedClass().Variant; writeln(list[0].get!DerivedClass.a); } ``` Parameters passed in !() need to be statically known, at compile-time, so `get!(list[0].type)` doesn't make sense with a runtime list. If everything in the list is going to be a child of some class, then you don't need std.variant at all, you can just use OOP: ```d import std.stdio : writeln; class SuperClass { this() { } } class DerivedClass : SuperClass { public: this(float a) { this.a = a; } float a; } class OtherDerivedClass : SuperClass {} class YetAnotherDerivedClass : SuperClass {} void main() { SuperClass[] list; list ~= cast(SuperClass) new DerivedClass(1.0f); list ~= cast(SuperClass) new OtherDerivedClass; list ~= cast(SuperClass) new YetAnotherDerivedClass; writeln((cast(DerivedClass) list[0]).a); foreach (obj; list) { if (auto deriv = cast(DerivedClass) obj) { writeln("I found a DerivedClass: ", deriv.a); } else if (cast(OtherDerivedClass) obj) { writeln("I found an OtherDerivedClass"); } else { writeln("I found an unexpected child: ", obj); } } } ``` output: ``` 1 I found a DerivedClass: 1 I found an OtherDerivedClass I found an unexpected child: variant.YetAnotherDerivedClass ``` Object casts like that are `null` when the cast is invalid. If you don't necessarily have a superclass, but still do have a definite number of possible member types, you can use std.sumtype: ```d import std.stdio : writeln; import std.sumtype; struct A { float a; } struct B { } struct C { } alias Alpha = SumType!(A, B, C); void main() { Alpha[] list; list ~= A(1.0f).Alpha; list ~= B().Alpha; list ~= C().Alpha; list[0].tryMatch!((A a) => writeln(a.a)); foreach (obj; list) { obj.match!( (A a) => writeln("I found A(", a.a, ")"), (B _) => writeln("I found B"), (C _) => writeln("I found C"), ); } } ``` output: ``` 1 I found A(1) I found B I found C ```
Re: Better debugging?
On Sunday, 3 October 2021 at 22:27:20 UTC, Tim wrote: On Sunday, 3 October 2021 at 22:26:15 UTC, Imperatorn wrote: On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: [...] You don't say which operating system you are using. I usually use Visual D which works great imo. If I use vscode I use the C++ debug extension (don't remember what it's called). If I debug outside of the IDE I use WinDbg, also has source debug support if configured correctly. If you are on Linux I'm not sure, but I would go for the C++ thing probably. Apologies. I use KDE linux Then I guess code-d extension + MS C++ extension in order to debug, and webfreak's NativeDebug extension (https://marketplace.visualstudio.com/items?itemName=webfreak.debug)
Re: Better debugging?
On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: -gc DMD2 compiler switch tried plain -g ? -gc is a compatibility debug thing for things with zero D support. p oboslete now
Re: Python's list equivalent with std.variant?
On Sunday, 3 October 2021 at 22:22:48 UTC, rjkilpatrick wrote: Hi. I am trying to emulate Python's list in D, to store some derived classes [...] You would have to explicitly cast(Variant) when appending to your array. But in the last example where you have list[0].a, that will only work statically if you can resolve that property. So you would have to either check the type or get out of the box and use some dynamic object
Re: Better debugging?
On Sunday, 3 October 2021 at 22:26:15 UTC, Imperatorn wrote: On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: [...] You don't say which operating system you are using. I usually use Visual D which works great imo. If I use vscode I use the C++ debug extension (don't remember what it's called). If I debug outside of the IDE I use WinDbg, also has source debug support if configured correctly. If you are on Linux I'm not sure, but I would go for the C++ thing probably. Apologies. I use KDE linux
Re: Better debugging?
On Sunday, 3 October 2021 at 22:21:45 UTC, Tim wrote: Hi all, I am currently using GDB within VScode with the -gc DMD2 compiler switch and my debugging is not amazing. Whenever I inspect a struct/object it just shows me the pointer rather than the object information and strings come up as a gross array of the characters. Does anybody happen to know whether LDB is better or how I can have a nicer debug environment? Thanks in advance You don't say which operating system you are using. I usually use Visual D which works great imo. If I use vscode I use the C++ debug extension (don't remember what it's called). If I debug outside of the IDE I use WinDbg, also has source debug support if configured correctly. If you are on Linux I'm not sure, but I would go for the C++ thing probably.
Python's list equivalent with std.variant?
Hi. I am trying to emulate Python's list in D, to store some derived classes My initial thought was to use a dynamic array of `std.variant`s. I've tried implementing something but seeing as we can only instantiate templates at compile-time, and I may only know the type at run-time, I'm not sure how to go about this: ```d import std.stdio : writeln; import std.variant; import std.conv; // Arbitrary super class class SuperClass { this() { } } // Derived class with members class DerivedClass : SuperClass { public: this(float a) { this.a = a; } float a; } class OtherDerivedClass : SuperClass {} void main() { // When we use `SuperClass[] list;` here, we find 'a' is hidden by the base class Variant[] list; // Attempting to append derived class instances to list list ~= new DerivedClass(1.0f); list ~= new OtherDerivedClass; list[0].a; list[0].to!(get!(list[0].type)).a.writeln; } ``` And we get the error(s): ``` onlineapp.d(27): Error: cannot append type `onlineapp.DerivedClass` to type `VariantN!32LU[]` onlineapp.d(28): Error: cannot append type `onlineapp.OtherDerivedClass` to type `VariantN!32LU[]` onlineapp.d(30): Error: no property `a` for type `std.variant.VariantN!32LU` onlineapp.d(31): Error: template `object.get` does not match any template declaration ``` I would be grateful for any help
Better debugging?
Hi all, I am currently using GDB within VScode with the -gc DMD2 compiler switch and my debugging is not amazing. Whenever I inspect a struct/object it just shows me the pointer rather than the object information and strings come up as a gross array of the characters. Does anybody happen to know whether LDB is better or how I can have a nicer debug environment? Thanks in advance
Re: Regular Templates May Be `mixin`d?
On Sunday, 3 October 2021 at 03:34:19 UTC, surlymoor wrote: Lord, I'm careless. Thanks. So the difference between a `mixin template` and a regular one is that the former may only be used with a `mixin` statement? Yes, exactly.