i can't wait until we have spans of spans/const generics/ref struct fields and all of this goes to w
i can't wait until we have spans of spans/const generics/ref struct fields and all of this goes to waste
Poh also don't forget being implicitly convertible from
NullPtr. basically just go over the existing manual types and see if there's anything missing from the generated ones (as this is basically what i'm doing now)Pand if that doesn't pull up anything obvious, getting the unit tests/playground project to light up sure will
Ksame, thatll make this so much easier lmao
Pyep this is basically why this exists
Mthe destiny of a c# developer is to rewrite all of their code every new version
Pgood thing that we'll be on a major release every 2 years by then
PSilk.NET 4.0 will release on November 2025, this is a promise
Pto coincide with .NET 10, the latest LTS
Cthat sould already be there
Poh did i miss it
Pone sec
Pah yeah there it is
Pwait are the equality operators in there
Cnot with nullptr I don't think, I'll get those in
Pjust realised this is not possible also (ref struct as generics, iirc this is why I included the very vague "unless the Silk.NET team deem it inappropriate or inapplicable" language)public static implicit operator PTRMUTPTR(Span<PTRMUT> span) => new(ref span.GetPinnableReference());
Cokay, I can move that line to only make the spans for single dimension types
CWill the As span then not work for the higher dimensionals as well?
Pyep they won't work either
Ksaving that for later
Ma bold promise to make
Pmy plan is to have 3.0 being the working copy up until the first .NET 10 preview releases, and then we branch off and start working on new stuff on a 4.0 branch, using the backport bot in arcade as necessary.
Asilk.net 5.0:
game is ai generated
game is ai generated
PCOkay, I think we are good, but here is an example of each of the cases in case I missed something.
Pstill implicitpublic static implicit operator void***(PTRMUTPTR<T> ptr) => (void***)Unsafe.AsPointer(ref Unsafe.AsRef(in ptr.Ref));
this doesn't feel correct, mainly because we're not using the value ofpublic static bool operator !=(object? lh, PTRMUTPTR<T> rh) => lh == null ? (void*)rh != null : true;
lh, we're just null checkingshould bepublic MUT(ref readonly T @Ref)
ref T - mutability does not match
Palso there's no string operators, but i can do that if you haven't got a lot of time
Cby string operators do you mean the string conversions?
Pyeah
CThe base explicit conversion is there for the 1 dimensional variants, fully defined for the non-generic. For the generic, I just need to do the extension methods to let it call the correct functions assuming it is the correct types. Are you expecting anything for higher dimensions, or are we just worried about 1D case?
PConstPtr2D supported string arrays as well, and was just about as complicated as the jagged array stuff
Pi think generally the best route once the generation is working it to try and replace the original manual types, and see what's missing.
CAlso for your second comment, about the object equality, it is because we only really care about the case of an object being null, since the more specific overrides will take over if we are talking about other types we care about. I can use the !rh.Equals(lh) in place of true and make sure equals uses base.equals as its final, but in the end it should always turn out to be true anyways.
Pwhat if you have a boxed raw pointer
Kis boxing pointers even legal in c#?
Mlaws are made to be broken
Ano
Klmao
Pah apparently not
Aalthough you could in theory just use a nuint which iirc can be boxed
Phrnrfnubefuywebfyuewb you are right
Pbut
Pas the kids say
P"ratio"
Mwhat is this boxing shit about can you guys elaborate so i tell you exactly why not to care
Pa box is a value type passed around as an
objectMyeah i know that
Mi mean why is it relevant here
Kthe
== operators in the prototype that take object? only check for nullPwe have an
object? operator, which fine i guess it wasn't part of the original proposal but i see no harmPactually yeah that operator is never going to get called because it's already impossible to compare a ptr to be
null