not an issue. just some suggestions

[aferust]

Will you implement all from scratch? Or you can speed up using existing libraries

I suggest you to borrow code around

• set, map : https://github.com/AuburnSounds/Dplug/blob/master/core/dplug/core/map.d rbtree based ordered map. based on a nogc version of phobos
• unordered map: https://github.com/aferust/bcaa
• for queues, stacks etc: https://github.com/libmir/dcv/blob/master/source/dcv/core/utils.d#L293 (slist would be better for stack)
• your vector looks good. I also implemented one before: https://github.com/aferust/dvector

more for nogc
https://github.com/AuburnSounds/Dplug/blob/master/core/dplug/core/nogc.d
https://github.com/AuburnSounds/Dplug/blob/master/core/dplug/core/thread.d
http://mir-algorithm.libmir.org/ mir libraries provide betterc or nogc alternatives for std.algorithm

[nxuv]

Thanks for suggestion and links!

It'll greatly help me build everything up

Mostly my goals for this library is to build somehwat of a nogc runtime and if I can borrow more efficient code I will (with right authorship notices ofc)

[nxuv]

Actually biggest problem is typeinfo
I have no idea how to do it properly besides of what __traits provides

[aferust]

I never attempted to implement it or need it actually.
This search lists somethings
https://github.com/search?q=org%3Alibmir+typeinfo+language%3AD&type=code&l=D

[aferust]

İf you inherit all extern c++ classes from a extern c++ CppObject, you may achieve something similar maybe

[nxuv]

https://github.com/libmir/mir-algorithm/blob/f3d0b7fe4cb0e4a52c8929a1ac85213f5e123bd3/source/mir/type_info.d

Hmm
Not sure how it works
Also I saw typeid which uses D's TypeInfo which is nono, though it's for some pointer things..
Dunno dunno

[aferust]

not a neat option: linking with a cpp runtime

https://github.com/dlang-cpp-interop/stl-containers/blob/master/source/core/experimental/stdcpp/typeinfo.d

[nxuv]

I think I'll pass on that one

[nxuv]

Oh, while you're here
Just thinking
Would it be good idea changing name of package to something like stdcpp or stdc
Problem with that is it might be confusing with core.stdc and core.stdcpp
Edit: maybe clib or cpplib
Honestly kinda confused on all that naming thing rn

Edit:
Had a crazy idea to have all of modules top level and name them something like vector.h (i.e import vector.h;). Bad idea, but technically can be done

[aferust]

I am not good at naming stuff either. I should reflect your intention. maybe "stld". not sure though.

[nxuv]

If to reflect intension then it'd be something like nogcstd
Maybe I'll go with clib. It's simple, consise and nice to type
Gonna do some reogranisation today then and some changes in readme

[aferust]

i think this is doable:

https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L587

create a nogc port of TypeInfo class as extern(C++) class TypeInfo https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L587

you will also need porting extern(C++) class TypeInfo_Class : TypeInfo https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L1575

then all extern(C++) classes must have the required member methods via a template mixin or deriving them from a CPPObject class having the required methods. (this is how D classes actually work, all of them is implicitly derived from an Object class)
https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L110

Then create a function:
TypeInfo_Class _typeid(T)(T cppclass) ;
TypeInfo_Class _typeid(T)() ;

toString method must yield: modulename.ClassName // traits does the trick name field is important to compare two instances or two types, see here: https://github.com/dlang/dmd/blob/master/druntime/src/object.d#L848

opEquals, getHash, equals, compare, name, etc.

You are doing this because you want to provide runtime type information for the situations:

pseoudo code:

import core.stdc.stdio;

extern (C++) class Base {}
extern (C++) class Derived : Base {}

extern(C)
int main() {
Base base = _new!Derived();

// Check the actual runtime type of the object
if (_typeid(base) == _typeid!(Derived)) {

// _typeid(Derived)) access name field via traits, this have to be a compile time variable that may be produced with traits
// _typeid(base) access name field at runtime. it should not be difficult after figuring out _typeid!(Derived))
    printf("base is of type Derived");
} else {
    printf("base is not of type Derived");
}

return 0;
}

[nxuv]

This might work
I'll try tomorrow

[nxuv]

Ok, typeinfo is impossible for now
DMD complains about missing symbols

/bin/ld: /home/al1-ce/.dub/cache/clib/~master/build/library-debug-OqusfGrASdkkikmE3QPpNA/libclib.a(classes_5_39a.o):(.data._D4clib7classes9cppObject7__ClassZ+0x0): undefined reference to `_D14TypeInfo_Class6__vtblZ'
/bin/ld: /home/al1-ce/.dub/cache/clib/~master/build/library-debug-OqusfGrASdkkikmE3QPpNA/libclib.a(classes_5_39a.o):(.text.d_dso_init[.data.d_dso_rec]+0x22): undefined reference to `_d_dso_registry'
collect2: error: ld returned 1 exit status

And LDC complains about missing symbols

/bin/ld: /home/al1-ce/.dub/cache/clib/~master/build/library-debug-1Sw9Nsl7VdWbAC49c21ZkQ/libclib.a(clib.classes.o):(.data._D4clib7classes9cppObject7__ClassZ+0x0): undefined reference to `_D14TypeInfo_Class6__vtblZ'
collect2: error: ld returned 1 exit status

All that it seems because classes are in libraries and they have no typeinfo which brokenD still expects for some god unknown reason

Is what I was going to say, but turns out I had to compile library with -betterC flag
Got something working I guess

[aferust]

Are you really sure to go for betterC? Even c++ has a runtime. You don't have to go betterC for nogc nothrow code.

I would invest nogc code over betterC. İ believe it is not a reasonable approach to expect full functioning OO features without a runtime. C and betterC is already there for the particular needs. What I and many needs in d is a standard library without gc. Please read this article

https://www.auburnsounds.com/blog/2016-11-10_Running-D-without-its-runtime.html

Not all runtime use GC.

I made DCV nogc nothrow. And i am happy with it. https://github.com/libmir/dcv.

[aferust]

Please also note that reference counted class objects will not be possible untill Walter Bright implements some compiler internals. Then you can forget shared pointers like in c++ for class objects