Casts without explicit type

[thatbakamono]

In situations like this:

[DllImport(GlfwLibrary, EntryPoint = "glfwGetProcAddress", CallingConvention = Convention, BestFitMapping = false)]
public static extern void* GetProcessAddress([MarshalAs(UnmanagedType.LPUTF8Str)] string processName);

public readonly delegate* unmanaged[Cdecl]<uint, void> BindVertexArray = (delegate* unmanaged[Cdecl]<uint, void>) GetProcessAddress("glBindVertexArray");

You have the field's type two times in your code and it's a little bit unnecessary. It could be easily avoided with syntax like this:

[DllImport(GlfwLibrary, EntryPoint = "glfwGetProcAddress", CallingConvention = Convention, BestFitMapping = false)]
public static extern void* GetProcessAddress([MarshalAs(UnmanagedType.LPUTF8Str)] string processName);

public readonly delegate* unmanaged[Cdecl]<uint, void> BindVertexArray = (var) GetProcessAddress("glBindVertexArray");

I'm not 100% sure about the syntax, it looks a little bit weird, so it might be a good idea to discuss this and come up with something better.

Alternative solution to this problem is to allow implicit casts for void* to any other pointer type, but this solution is more generic and it's not limited to pointers so it may solve other similar problems too.

[huoyaoyuan]

Can be also called "target-typed explicit cast".
At my sight, the case that destination can't be declared as var is relatively rare. Explicit cast is also not so safe like other target-typed operations.

[AartBluestoke]

so basically a language feature to avoid 'no implicit cast exists, an explicit one does, did you miss a cast' error without having to directly name the type?

[thatbakamono]

It's a really aggressive way to describe equivalent of new(); but for casts.

[Rekkonnect]

I remember having seen a similar proposal where instead of var, the wildcard is _. It was either for the as operator, or casting to another type. Could not find that proposal again though.

My opinion on this is, x as _ for target-typing looks much clearer than x as var, because x is a var anyway (even if a const). But for casts, (_) looks like my face when I encounter a use case for an unshipped feature. We don't want C# to look sad.

Generally, those are the options I see as of now:

• (_)x
• (var)x (but x already is a var, what are you casting it to?)
• x as _
• x as var (same as above)

Note that x is var _ is already valid, though it does not target any type other than the type of x.

[thatbakamono]

I agree, _ looks a lot better.