```cs public ref struct PtrType<T> { // inner magic to store the arbitrary pointer } public str

```cs public ref struct PtrType { // inner magic to store the arbitrary pointer } public str

Kai · 2023-08-04T20:10:56.975Z

```cs public ref struct PtrType { // inner magic to store the arbitrary pointer } public struct Ptr : IPtrMarker { } public interface IPtrMarker { } public static class PtrAccessor { public static PtrType Inner (this PtrType self) where T: IPtrMarker { // IDK take an index and do magic with the inner of PtrType throw null; } } public class C { public static void Main() { PtrType > a = new(); PtrType b = new(); PtrType c = a.Inner >(); // Can I get this to infer somehow? // Invalid: b.Inner (); } } ```

public ref struct PtrType<T> {
    // inner magic to store the arbitrary pointer
}

public struct Ptr<T>: IPtrMarker<T> { }

public interface IPtrMarker<T> { }

public static class PtrAccessor
    
{
    public static PtrType<T2> Inner<T2, T>(this PtrType<T> self)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
}


public class C {
    public static void Main() {
        PtrType<Ptr<int>> a = new();
        PtrType<int> b = new();
        
        PtrType<int> c = a.Inner<int, Ptr<int>>(); // Can I get this to infer somehow?
        // Invalid: b.Inner<int, ???>();
    }
}

public ref struct PtrType<T> {
    // inner magic to store the arbitrary pointer
}

public struct Ptr<T>: IPtrMarker<T> { }

public interface IPtrMarker<T> { }

public static class PtrAccessor
    
{
    public static PtrType<T2> Inner<T2, T>(this PtrType<T> self)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
}


public class C {
    public static void Main() {
        PtrType<Ptr<int>> a = new();
        PtrType<int> b = new();
        
        PtrType<int> c = a.Inner<int, Ptr<int>>(); // Can I get this to infer somehow?
        // Invalid: b.Inner<int, ???>();
    }
}

public ref struct PtrType<T> {
    // inner magic to store the arbitrary pointer
}

public struct Ptr<T>: IPtrMarker<T> { }

public interface IPtrMarker<T> { }

public static class PtrAccessor
    
{
    public static PtrType<T2> Inner<T2, T>(this PtrType<T> self)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
}


public class C {
    public static void Main() {
        PtrType<Ptr<int>> a = new();
        PtrType<int> b = new();
        
        PtrType<int> c = a.Inner<int, Ptr<int>>(); // Can I get this to infer somehow?
        // Invalid: b.Inner<int, ???>();
    }
}

public ref struct PtrType<T> {
    // inner magic to store the arbitrary pointer
}

public struct Ptr<T>: IPtrMarker<T> { }

public interface IPtrMarker<T> { }

public static class PtrAccessor
    
{
    public static PtrType<T2> Inner<T2, T>(this PtrType<T> self)
        where T: IPtrMarker<T2>
    {
         // IDK take an index and do magic with the inner of PtrType
        throw null;
    }
}


public class C {
    public static void Main() {
        PtrType<Ptr<int>> a = new();
        PtrType<int> b = new();
        
        PtrType<int> c = a.Inner<int, Ptr<int>>(); // Can I get this to infer somehow?
        // Invalid: b.Inner<int, ???>();
    }
}

KaiOP•8/4/23, 8:11 PM

cursed trash from my brain

Maxine•8/4/23, 8:11 PM

what about ByReference<T>, is this anything

Perksey•8/4/23, 8:11 PM

(re: maxine) that's just a ref field before ref fields existed

Maxine•8/4/23, 8:11 PM

before .NET7 ByReference<T> was how Span<T> worked

Maxine•8/4/23, 8:11 PM

what happens if the struct is not ref

KaiOP•8/4/23, 8:12 PM

Idk if this is more ergonomic then RefMutRefInt but, maybe

MMaxine what happens if the struct is not ref

Perksey•8/4/23, 8:12 PM

ByReference<T> is a ref struct because... it's a ref

KaiOP•8/4/23, 8:12 PM

ByReference<T> was a ref struct before it was cool

Perksey•8/4/23, 8:12 PM

so it won't be allowed in anything but a ref struct

Maxine•8/4/23, 8:12 PM

ohhhh right i didn't even see that

KKai ```cs public ref struct PtrType<T> { // inner magic to store the arbitrary p...

KaiOP•8/4/23, 8:13 PM

@Perksey thoughts?

Perksey•8/4/23, 8:13 PM

there's not enough there for me to have any thoughts really, i don't know how that'd actually work

Perksey•8/4/23, 8:14 PM

for reference the desired user experience is just taking something you can take a ref to and doing .AsPtr.AsPtr or .AsMut.AsMut

Maxine•8/4/23, 8:14 PM

where does the ref go

Maxine•8/4/23, 8:14 PM

wait i kinda see what kai is cooking here

Perksey•8/4/23, 8:14 PM

e.g.:

    // -------------------vvvvvvvv-- returns a ref struct
    if (glfwGetError(error.AsPtr2D()) == 0 || error == nullptr)
    {
        throw new Exception("failed to create window and failed to get error");
    }

    // -------------------vvvvvvvv-- returns a ref struct
    if (glfwGetError(error.AsPtr2D()) == 0 || error == nullptr)
    {
        throw new Exception("failed to create window and failed to get error");
    }

KaiOP•8/4/23, 8:15 PM

uh I thought that'd be enough. PtrType can then have the "normal" private readonly ref byte InteriorRef;private readonly ref byte InteriorRef; and then that works?
We calculate the inner in InnerInner (or whatever it's called) and return another PtrType<T>PtrType<T>.
All the other methods work the same as Any2D but with generics

Aqua•8/4/23, 8:15 PM

maybe i have come in at the wrong time - but has the prospect of having 2 overloads, a safe and unsafe, been ruled out?
on a personal level, this is what i would prefer to see. it's how i tend to structure my apis as well - if you take a look at pie you'll see that pretty much everything that takes an array also has a pointer overload
but it's one or the other, no combinations

PPerksey e.g.: ```cs // -------------------vvvvvvvv-- returns a ref struct if (gl...

Maxine•8/4/23, 8:15 PM

that should still work with this design

PPerksey e.g.: ```cs // -------------------vvvvvvvv-- returns a ref struct if (gl...

KaiOP•8/4/23, 8:15 PM

what is error here? SomeT**SomeT**?

AAqua maybe i have come in at the wrong time - but has the prospect of having 2 overlo...

Maxine•8/4/23, 8:16 PM

if you want to do things unsafely there could probably be an implicit cast from pointer to Ptr<T> if that's allowed in c#

Perksey•8/4/23, 8:16 PM

error is ConstPtr<sbyte>ConstPtr<sbyte> in this instance

AAqua maybe i have come in at the wrong time - but has the prospect of having 2 overlo...

KaiOP•8/4/23, 8:16 PM

unsafe overloads will stay, I'm very confident to say that

Perksey•8/4/23, 8:16 PM

NO OVERLOADS

KaiOP•8/4/23, 8:16 PM

unsafe ways to call the function

KaiOP•8/4/23, 8:16 PM

whatever

Maxine•8/4/23, 8:16 PM

a cast that doesn't change the underlying memory of the value is free

Perksey•8/4/23, 8:16 PM

the JIT is smart enough that if for every

Ptr

Ptr

you implicitly cast from a something*something*, it will be equivalent to fully unsafe

PPerksey error is `ConstPtr<sbyte>` in this instance

KaiOP•8/4/23, 8:17 PM

? So what does AsPtr2D() return? that makes no sense to me

Perksey•8/4/23, 8:17 PM

ConstPtr<sbyte>ConstPtr<sbyte> incorrectly returns ConstPtr2D<sbyte>ConstPtr2D<sbyte> atm

KKai ? So what does AsPtr2D() return? that makes no sense to me

Maxine•8/4/23, 8:17 PM

sbyte* to sbyte**, i presume

Perksey•8/4/23, 8:17 PM

i.e. it converts a ref this ConstPtr<sbyte>ref this ConstPtr<sbyte> to a ConstPtr2D<sbyte>ConstPtr2D<sbyte>

Perksey•8/4/23, 8:17 PM

(or in IL terms, ldarg.0ldarg.0 retret)

KaiOP•8/4/23, 8:18 PM

KaiOP•8/4/23, 8:18 PM

ref

KaiOP•8/4/23, 8:18 PM

I see where the extra comes from now

KaiOP•8/4/23, 8:18 PM

implicit ref

Perksey•8/4/23, 8:18 PM

lmao

Perksey•8/4/23, 8:18 PM

i'm sorry I just found that hilarious

Perksey•8/4/23, 8:18 PM

PPerksey NO OVERLOADS

Aqua•8/4/23, 8:18 PM

hmm that's where i disagree
one of the big benefits of C# is that it has overloads
sure you can have too many of them
but if you only have a few they can work very well
a pointer overload and an array overload
maybe a span
i just feel like this

Ptr<T>

Ptr<T>

stuff may be a bit hard to understand, certainly i'm looking at this and wondering what exactly this is supposed to mean
i feel like for most users, they will only ever want safe overloads that take an array/whatever else, instead of a

Ptr<T>

Ptr<T>

struct that may leave (especially to beginners) some users scratching their heads
and for those that want pointer overloads, they are available as well

KaiOP•8/4/23, 8:18 PM

yeah so that way around I see no problem with my design? It would work fine, the same way it works now. Use some IL magic to load the arg ptr and then store it into the outer PtrType ref struct

KaiOP•8/4/23, 8:19 PM

(but also do generic magic so the compiler knows what indirection level we are at now, but this isn't a runtime thing)

KaiOP•8/4/23, 8:19 PM

(unfortunately the JIT won't see it that way and produce many re-compilations of the same IL but that's not on me)

KaiOP•8/4/23, 8:19 PM

(and also also the case with The RefMutRef design)

Perksey•8/4/23, 8:19 PM

can you define an E2E of how it'll work with a dummy glfwGetError signature, sorry just being stupid and can't quite visualise it

KaiOP•8/4/23, 8:19 PM

eeeh

KaiOP•8/4/23, 8:20 PM

can you give me the E2E I'm supposed to translate? I don't know what it looks like right now

Perksey•8/4/23, 8:21 PM

what would int glfwGetError(const char**)int glfwGetError(const char**) (i.e. sbyte**sbyte**) look like, how would the user use it, and what does the AsPtr2D (or whatever) have to do to make it work

Maxine•8/4/23, 8:22 PM

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> b = a.PtrTo();

glfwGetError(b);

PtrType<sbyte> a = ???;

PtrType<Ptr<sbyte>> b = a.PtrTo();

glfwGetError(b);

```cs public ref struct PtrType<T> { // inner magic to store the arbitrary pointer } public str

Similar Threads