Dear all,
I agree that until or unless justice will not prevail in the society, it
will keep deteriorating and frustration of the people will keep mounting.
However, we cannot only stick to the judiciary crisis. We have so many other
important issues engulfing us that we cannot stay stick to this for long
(that movement can be carried in parallel with little flexibility, if all
the parties are not agreeing to a single point) and ignore all others saying
that first of all this should be done then come rest of the problems. I
think that we should move-on, find a middle way out and start focusing on
the other issues as well. I am a great supporter of a good judiciary system
but we cannot jeopardize the whole nation on this issue and ignoring other
issues with which life of common man is concerned more.
I totally respect your point of you, but I think its not about giving chance
to one party or the other, we cannot keep trying different sects of society.
Even then, some would say, they are good and some will say they are not. We
need to think on a wider frame, I guess.
Best regards,
Irum
On Tue, Sep 2, 2008 at 11:54 PM, Nauman Ilyas <[EMAIL PROTECTED]>wrote:
>
> Dear Natasha,
>
> I believe that we as common people of Pakistan should give these lawyers a
> chance. Everybody (politician, army, bureaucracy) got a chance; why not
> these lawyers. Who knows what good they will bring to this country; I am
> sure you agree with me that these lawyers will do no damage to our beloved
> country as compared to what Army and our political elite did.
>
> Nauman.
>
>
> >
>
--~--~-----, otherstuff);
req.add_callback(finish,stuff,otherstuff)
If (stuff.may_async) {
stuff.did_async=true;
Return OK;
}
// this also calls finish callback
req.wait_till_done();
return(stuff.status);
}
The obvious candidate for the lambda is the finish function, giving something
like this
(assuming lambda local-vars support is complete)
server_do_things(stuff) {
req=do_thing(stuff, otherstuff);
req.add_callback( (req) => (
stuff.status=req.receive(stuff);
// do more stuff here
) )
If (stuff.may_async) {
stuff.did_async=true;
Return OK;
}
// this also calls finish callback
req.wait_till_done();
return(stuff.status);
}
It's a little puzzling that the lamda appears halfway through; but it gets more
complicated if the server has to issue more than one client request; the nest
lambdas make the whole thing look like lisp.
The idea of implicit lamdas is to allow the code to be laid out as if it were
synchronous but still work asynchronously, see:
server_do_things(stuff) {
req=do_thing(stuff, otherstuff);
req.add_callback(finish,stuff,otherstuff)
If (stuff.may_async) {
stuff.did_async=true;
Return OK;
} else {
// this also calls finish callback
req.wait_till_done();
return (stuff.status);
}
finish:
stuff.status=req.receive(stuff);
// do more stuff here
return(req.status);
}
finish: is a regular C style label; but if it's address is taken for a delegate
then it becomes simultaneously a lambda until the end of the enclosing block
and also a call to that lambda.
Thus the code can be run_into during normal execution as well as apparently
run-into for async execution.
If such a thing were possible, the rpc glue would differ so as to make better
use of it.
Here's a more complex case which unwinds a terrible state machine into an
apparent linear function:
server_auth(stuff) {
req=send_get_auth_types(stuff);
// I'll talk about block this later...
if (stuff.may_async) {
req.add_callback(type);
Stuff.dyd_async=true;
return;
} else {
Req.wait_for_response();
}
type:
if (stuff.kerberos) {
kreq=send_kerberos(krb);
...
krb:
If (kreq.success)...
} else if (stuff.ntlm) {
}
}
I said that implicit lambdas ought to last to the end of the containing block,
but really when that block finishes a new implicit lambda should start in the
outer block as if it were declared in the same manner as discussed; and so on
until the end of the enclosing function block is reached.
That way parts of the function can be deferred or executed immediately without
a problem.
I don't know how such a lamda would cope with being in a loop.
The If block for which I said: "// I'll talk about block this later..." clearly
it's a pain to have to repeat that async/sync fixup code everytime, but I think
I've said enough to layout the problem and how lamdas could unwind horrible
continuation chains and async state machines, so I'm open for comment.
Sam
_______________________________________________
Vala-list mailing list
Vala-list@gnome.org
http://mail.gnome.org/mailman/listinfo/vala-list
