[nem-en] Late Binding in Nemerle

[Alejandro Serrano]

Maybe we could see how the Microsoft VB.NET compiler implements late 
binding (mostly using Reflection at run-time) or also take some ideas 
from Boo, so we could have something like:

late
{
    def n = SomeActiveXControl ();
    n.Method ();
}

or maybe

def n : duck = SomeActiveXControl ();
n.Method () <- every call in a 'duck' type would use late binding

Kamil Skalski escribió:
> Generating such proxy classes should be relatively easy using a macro.
> def x = dynamic_implement (obj, IFoo, IBar, IWazz);
> x.foo();
> x.bar();
>
> would be quite nice. :)
>
> dynamic_implement would generate a class implementing IFoo, IBar,
> IWazz (maybe doing some caching to avoid generating the same proxy
> classes several times) and create its instance.
>
> 2006/7/2, Arthur Peters <amp at singingwizard.org>:
>> This is quite cool. I've been a Python programmer in the past so the
>> ability to do duck typing when needed could be really nice.
>>
>> I ran across a page about duck typing in Java. It provides a class that
>> can take an object and return a proxy object that implements an
>> interface you give even if the original object did not.
>> ( http://www.coconut-palm-software.com/the_visual_editor/?p=25 )
>>
>> This seems like it could be nice in addition to your macro, because it
>> would allow you to pass the proxy into places that don't know about the
>> whole duck typing thing. Also it provides a middle ground: You can
>> access functions based on only name and signature and you have the type
>> safety provided by a defined interface.
>>
>> I think it would be possible in .NET, but it looks complicated because
>> you would need to generate IL opcodes to create the proxy.
>>
>> If people think this would be useful I will take a crack at implementing
>> it.
>>
>> Thanks for the good work, everyone!
>> -Arthur
>>
>> On Sat, 2006-07-01 at 18:33 +0400, Snaury wrote:
>> > Hi everyone,
>> >
>> > I was trying to grok nemerle's macros for some time when an idea
>> > suddenly popped in my mind how I could do late binding aka dynamic
>> > typing aka duck typing in a pretty simple and (maybe?) rich way. So I
>> > wrote a macro for this, source code here:
>> > http://www.furry.ru/kitsu/nemerle/Kitsu.LateBindingMacro.n.txt
>> >
>> > It allows to use late binding on (I think) any expression, you just
>> > have to wrap it with late, and use like this:
>> >
>> >   late(expr).CallMe(param1, param2, param3).CallOtherMe(param, param,
>> > param).Property[param, param, param] = value
>> >
>> > It also supports ref/out and named parameters:
>> >
>> >   late(expr).CallMe(namedparameter = ref variable, out variable, and
>> > the like...)
>> >
>> > though one needs to be very careful with named parameters, because
>> > when you name a parameter, other (unnamed) parameters might get
>> > shifted, for example in function:
>> >
>> >   public void SomeFunc(a : int, b : int) : void
>> >
>> > when you use
>> >
>> >   late(obj).SomeFunc(v1, a = v2)
>> >
>> > SomeFunc will be called as SomeFunc(v2, v1), i.e. it won't produce any
>> > errors, it would just silently accept it.
>> >
>> > Also, there's not much error checking there (and to be honest I don't
>> > even know how I can do more error checking from within a macro), and
>> > if something goes wrong, you'll probably won't even know where exactly
>> > error happend, none the less I was extremely amazed at WHAT I could do
>> > with Nemerle's macro syntax so I though I'd share it with other people
>> > like me, who might really need to use late binding in their programs.
>> > =^_^=
>> >
>> > Now I can say it even more: Nemerle Rocks!
>> >
>> > P.S.
>> > If someone can help me to improve it, help in form of patches would be
>> > greatly appreciated :)
>> >
>> > P.P.S.
>> >
>> > When I was searching the net on any info about duck typing in Nemerle
>> > I occasionaly found this particular statement:
>> >
>> > http://nemerle.org/irc/nemerle-2006-01-09
>> > 13:50 <malekith> the main differences between boo and nemerle is that
>> > we do not allow dynamic typing to sneak at without notice, we have
>> > better support for metaprogramming (quotations) and compiler written
>> > in Nemerle (booc is in C#)
>> >
>> > After reading it I'm even a little scared if my idea of dynamic typing
>> > would be met with knifes and banished like something evil. All I'm
>> > trying to do is to give power when one needs it, especially when one
>> > *really* needs it. x_x
>> >
>> > _______________________________________________
>> > https://nemerle.org/mailman/listinfo/devel-en
>>
>>
>> _______________________________________________
>> https://nemerle.org/mailman/listinfo/devel-en
>>
>
>


		
______________________________________________ 
LLama Gratis a cualquier PC del Mundo. 
Llamadas a fijos y móviles desde 1 céntimo por minuto. 
http://es.voice.yahoo.com