Function pointers/delegates default args were stealth removed?

[Manu]

On 27 August 2012 11:28, Walter Bright <newshound2 at digitalmars.com> wrote:

> On 8/27/2012 1:08 AM, Manu wrote:
>
>>
>>  Also, I think it could be fixed so the scenario in the bug report worked
>> as
>> expected (I still don't understand why it did't work in the first place).
>>
>
> Because the two types were considered to be the same, only different.
>

And how was that a problem? They never interacted in the example, the
assignments were totally separate, they shouldn't have been confused.
Just speculating, but it just looks like the type was misrepresented when
it was looked up from a map by name or something, and matched the wrong
cached definition... or something along those lines.
It looks like a bug exposed from implementation detail, I can't see
anything in the bug report that shouldn't theoretically work fine.

------------------------------**----
>
> Please post a canonical example of how you use this, so we can think of an
> alternative.
>

Well likewise, can you provide an example where, assuming that one bug were
fixed, that the old approach actually caused a problem?
The bug report shows a situation that has a clear presumed behaviour, and
could surely have just been fixed.



Almost all my API's are dynamically bound to foreign code, eg:

extern(C) void function( ref const(Vector2) v0, ref const(Vector2) v1, ref
const(Vector2) v2, ref const(Color) color = Color.white, BlendMode
blendMode = BlendMode.Disabled ) fillTriangle2D;
extern(C) void function( ref const(Vector3) v0, ref const(Vector3) v1, ref
const(Vector3) v2, ref const(Color) color = Color.white, BlendMode
blendMode = BlendMode.Disabled ) fillTriangle;
extern(C) void function( ref const(Vector2) vPosition, ref const(Vector2)
vSizeref, ref BaseTexture texture, ref const(Color) color = Color.white,
BlendMode blendMode = BlendMode.Disabled, TextureMode textureMode =
TextureMode.AllChannels ) fillSprite;
extern(C) void function( ref const(Vector2) vMin, ref const(Vector2) vMax,
ref const(Color) color = Color.white, BlendMode blendMode =
BlendMode.Disabled ) fillRectangle;
extern(C) void function( ref const(Vector3) vMin, ref const(Vector3) vMax,
ref const(Matrix4x3) mLocalToWorld = Matrix4x3.identity, ref const(Color)
color = Color.white, BlendMode blendMode = BlendMode.Disabled ) fillBox;
extern(C) void function( ref const(Vector3) vCenter, float fRadius, ref
const(Matrix4x3) mLocalToWorld = Matrix4x3.identity, ref const(Color) color
= Color.white, BlendMode blendMode = BlendMode.Disabled, int iTessellationX
= 12, int iTessellationY = 8 ) fillSphere;
extern(C) void function( float fLength, float fRadius, ref const(Matrix4x3)
mLocalToWorld = Matrix4x3.identity, ref const(Color) color = Color.white,
BlendMode blendMode = BlendMode.Disabled, int iTessellation = 10 ) fillCone;
extern(C) void function( float fLength, float fRadius1, float fRadius2, ref
const(Matrix4x3) mLocalToWorld = Matrix4x3.identity, ref const(Color) color
= Color.white, BlendMode blendMode = BlendMode.Disabled, int iTessellation
= 10 ) fillCylinder;
extern(C) void function( ref const(Matrix4) mClipToWorld, ref const(Color)
color = Color.white, BlendMode blendMode = BlendMode.Disabled ) fillFrustum;


Functions in structs is common, default args are often convenient:

struct MFMaterialInterface
{
extern (C) int       function(void* pPlatformData) registerMaterial;
extern (C) void      function() unregisterMaterial;

extern (C) void      function(MFMaterial* pMaterial, MFMaterialCreateParams
*pCreateParams = null) createInstance;
extern (C) void      function(MFMaterial* pMaterial) destroyInstance;

extern (C) int       function() getNumParams;
extern (C) MFMaterialParameterInfo* function(int parameterIndex)
getParameterInfo;
extern (C) void      function(MFMaterial* pMaterial, int parameterIndex,
int argIndex, size_t value) setParameter;
extern (C) size_t    function(MFMaterial* pMaterial, int parameterIndex,
int argIndex, void* pValue = null) getParameter;
}

extern (C) void function(const(char)* pName, const(MFMaterialInterface)*
pInterface) MFMaterial_RegisterMaterialType;

This isn't the best demonstration of this pattern, just a compact one. But
function pointers in structs/classes is not unusual.



Here's an advanced trick I use a lot since D doesn't extern to static C++
methods (heavily simplified, this is way out of context):

struct CPPClass
{
    this()
    {
        // not my actual code, but effectively, write 'this' and the C++
method pointer into a delegate on initialisation [I wrap this process up
using magic]
        void** pDelegate = cast(void**)&cppNonVirtualMethod;
        pDelegate[0] = this;
        pDelegate[1] = pCPPMethodPointer;
    }

    void delegate(int x = 0) cppNonVirtualMethod; // C++ methods often have
default args

private:
    // C++ method pointer received from foreign code during initialisation
    static void* pCPPMethodPointer;
}
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20120827/d63745b6/attachment-0001.html>