doc/LPC/closures2 - mudlib-public - Gitiles

 Closures provide a means of creating code dynamically and passing pieces
 of code as parameters, storing them in variables. One might think of them
 as a very advanced form of process_string(). However, this falls short of
 what you can actually do with them.

 The simplest kind of closures are efuns, lfuns or operators. For
 example, #'this_player is an example of a closure. You can assign it
 to a variable as in

 	closure f;
 	object p;
 	f = #'this_player;

 and later use either the funcall() or apply() efun to evaluate it. Like

 	p = funcall(f);

 or
 	p = apply(f);

 In both cases there p will afterwards hold the value of this_player().
 Of course, this is only a rather simple application. More useful
 instances of closures can be created using the lambda() efun. It is much
 like the lambda function in LISP. For example, you can do the following:

 	f = lambda( ({ 'x }), ({ #'environment, 'x }) );

 This will create a lambda closure and assign it to f. The first argument
 to lambda is an array describing the arguments (symbols) passed to the
 closure upon evaluation by funcall() or apply(). You can now evaluate f,
 for example by means of funcall(f,this_object()). This will result in
 the following steps:

 	1. The value of this_object() will be bound to symbol x.
 	2. environment(x) evaluates to environment(this_object())
 	   and is returned as the result of the funcall().

 One might wonder why there are two functions, funcall() and apply(), to
 perform the seemingly same job, namely evaluating a closure. Of course
 there is a subtle difference. If the last argument to apply() is an array,
 then each of its elements gets expanded to an additional paramater. The
 obvious use would be #'call_other as in:

 	mixed eval(object ob,string func,mixed *args)
 	{
 	  return apply(#'call_other,ob,func,args);
 	}

 This will result in calling ob->func(args[0],args[1],...,args[sizeof(args)-1]).
 Using funcall() instead of apply() would have given us ob->func(args).

 Of course, besides efuns there are closures for operators, like #'+,
 #'-, #'<, #'&&, etc.

 Well, so far closures have been pretty much limited despite their
 obvious flexibility. This changes now with the introduction of
 conditional and loop operators. For example, try:

 	closure max;
 	max = lambda( ({ 'x, 'y }), ({ #'? ,({ #'>, 'x, 'y}), 'x, 'y }) });
 	return funcall(max,7,3);

 The above example will return 7. What happened? Of course #'? is the
 conditional operator and its 'syntax' is as follows:

 	({ #'?, cond1, val1, cond2, val2, ..., condn, valn, valdefault });

 It evaluates cond1, cond2, ..., condn successively until it gets a
 nonzero result and then returns the corresponding value. If there is no
 condition evaluating to a nonzero result, valdefault gets returned. If
 valdefault is omitted, 0 gets returned. #'?! works just like #'?, except
 that the ! operator is applied to conditions before testing. Therefore,
 while #'? is somewhat like an if statement, #'?! resembles an if_not
 statement if there were one.

 	There are also loops:
 	({ #'do, loopbody, loopcond, loopresult })
 	will evaluate loopbody until loopcond evaluates to 0 and
 	then return the value of loopresult. Symbols my be used
 	as variables, of course.

 	({ #'while, loopcond, loopresult, loopbody })
 	works similar but evaluates loopcond before loopbody.

 There are, however, some questions open:

 a) How do I write down an array within a lambda closure to avoid
    interpretation as a subclosure?
    ({ #'member_array, 'x, ({ "abc", "xyz }) }) will obviously result in
    an error as soon as lambda() tries to interpret "abc" as a closure
    operator. The solution is to quote the array, as in:
    ({ #'member_array, 'x, '({ "abc", "xyz }) }). Applying lambda() to
    this will not result in an error. Instead, the quote will be stripped
    from the array and the result regarded as a normal array literal. The
    same can be achieved by using the efun quote(), e.g.:
    ({ #'member_array, 'x, quote( ({ "abc", "xyz }) ) })
 b) Isn't it a security risk to pass, say, a closure to the master object
    which then evaluates it with all the permissions it got?
    Luckily, no. Each closure gets upon compilation bound to the object
    defining it. That means that executing it first sets this_object()
    to the object that defined it and then evaluates the closure. This
    also allows us to call lfuns which might otherwise be undefined in
    the calling object.
    There is however, a variant of lambda(), called unbound_lambda(),
    which works similar but does not allow the use of lfuns and does not
    bind the closure to the defining object. The drawback is that trying
    to evaluate it by apply() or funcall() will result in an error. The
    closure first needs to be bound by calling bind_lambda().
    bind_lambda() normally takes one argument and transforms an unbound
    closure into a closure bound to the object executing the
    bind_lambda().
    Privileged objects, like the master and the simul_efun object (or
    those authorized by the privilege_violation() function in the master)
    may also give an object as the second argument to bind_lambda(). This
    will bind the closure to that object. A sample application is:

    dump_object(ob)
    // will dump the variables of ob to /dump.o
    {
      closure save;
      save = unbound_lambda( ({ }), ({ #'save_object, "/open/dump" }) );
      bind_lambda(save,ob);
      funcall(save);
    }

    bind_lambda() can also be used with efun closures.

 c) It might be an interesting application to create closures dynamically
    as an alternative to writing LPC code to a file and then loading it.
    However, how do I avoid doing exactly that if I need symbols like 'x
    or 'y?
    To do that one uses the quote() efun. It takes a string as its
    argument and transforms it into a symbol. For example, writing
    quote("x") is exactly the same as writing 'x.

 d) How do I test if a variable holds a closure?
    Use the closurep() efun which works like all the other type testing
    efuns. For symbols there is also symbolp() available.

 e) That means, I can do:
    if (closurep(f)) return funcall(f); else return f; ?
    Yes, but in the case of funcall() it is unnecessary. If funcall()
    gets only one argument and it is not a closure it will be returned
    unchanged. So return funcall(f); would suffice.

 f) I want to use a function in some object as a closure. How do I do
    that?
    There are several ways. If the function resides in this_object(),
    just use #'func_name. If not, or if you want to create the function
    dnynamically, use the efun symbol_function(). It takes a string as
    it first and an object as its second argument and returns a closure
    which upon evaluation calls the given function in the given object
    (and faster than call_other(), too, if done from inside a loop,
    since function search will be done only when calling symbol_function().

 g) Can I create efun closures dynamically, too?
    Yes, just use symbol_function() with a single argument. Most useful
    for marker objects and the like. But theoretically a security risk
    if not used properly and from inside a security relevant object.
    Take care, however, that, if there is a simul_efun with the same
    name, it will be preferred as in the case of #'function. Use the
    efun:: modifier to get the efun if you need it.

 h) Are there other uses of closures except using them to store code?
    Lots. For example, you can use them within almost all of the
    efuns where you give a function as an argument, like filter(),
    sort_array() or walk_mapping(). sort_array(array,#'>) does indeed
    what is expected. Another application is set_prompt(), where a
    closure can output your own prompt based on the current time and other
    stuff which changes all the time.

 Finally, there are some special efun/operator closures:

 #'[ indexes an array.
 #'[< does the same, but starting at the end.
 #'negate is for unary minus.
 #', may be followed by any number of closures,
 e.g.: ({ #', ({#'= 'h, 'a, }), ({#'=, 'a, 'b }), ({#'=, 'b, 'h }) })
 will swap 'a and 'b when compiled and executed.

 ------------
 An example from Amylaar:

 #I have tested the replace_program() functionality with one example, which I
 #include below. The room is commonly known as /room/orc_valley.c .
 #A prerequisite to make this work is to have valued properties in room.c .
 #The property C_EXTRA_RESET, if defined, is evaluated at reset time in
 #the reset() of the used room.c .
 #Moreover, you need a function to query an unprocessed property to use
 #orc_valley.c from fortress.c (That is, don't do an automatic funcall there.)
 #If you can't supply such a function, you have to set the property "get_orc"
 #at the end of orc_valley.c 's extra_reset() with:
 #    add_prop("get_orc", lambda(0, get_orc) );
 #which will set the property to a function that returns the function that
 #is in the variable get_orc at the time you do the add_prop() call.
 #
 #Back to fortress.c : Assume you have the function successfully queried and
 #stored in the variable get_orc. Now you can compute your extra_reset()
 #function by:
 #    get_orc = lambda( 0, ({#'funcall, get_orc, 8, 40}) );
 #which creates the usual 8 orcs with an a_chat chance of 40.
 #
 #Here comes the orc_valley.c source:
 #
 #    ----------- cut here ------- cut here -------- cut here ------------
 #
 ##include "room.h"
 ##include "/sys/stdproperties.h"
 ##undef EXTRA_RESET
 ##define EXTRA_RESET extra_reset();
 #
 #extra_reset() {
 #    closure get_orc;
 #
 #    replace_program("room/room"); /* Must come first. */
 #    get_orc = lambda( ({'num_orcs, 'chat_chance}),
 #       ({#'?!, ({#'present, "orc", ({#'previous_object}) }),
 #           ({#'do,
 #               ({#'=, 'orc, ({#'clone_object, "obj/monster"}) }),
 #               ({#'=, 'i, 9}),
 #               ({#'do,
 #                   ({#'call_other, 'orc, "set_level",
 #                       ({#'+, ({#'random, 2}), 1}) }),
 #                   ({#'call_other, 'orc,
 #                       ({#'[,
 #                           quote(({"set_aggressive", "set_ac", "set_short",
 #                              "set_al", "set_ep", "set_hp", "set_race",
 #                              "set_alias", "set_name"})), ({#'-=, 'i, 1}) }),
 #                       ({#'[,
 #                           quote(({1, 0, "An orc", -60, 1014, 30, "orc",
 #                              "dirty crap", "orc"})), 'i}) }),
 #               'i, 0}),
 #               ({#'call_other, 'orc, "load_a_chat", 'chat_chance,
 #                   quote(({ "Orc says: Kill 'em!\n",
 #                       "Orc says: Bloody humans!\n",
 #                       "Orc says: Stop 'em!\n",
 #                       "Orc says: Get 'em!\n",
 #                       "Orc says: Let's rip out his guts!\n",
 #                       "Orc says: Kill 'em before they run away!\n",
 #                       "Orc says: What is that human doing here!\n",
 #                   })) }),
 #               ({#'=, 'n, ({#'*, ({#'random, 3}), 5}) }),
 #               ({#'=, 'weapon, ({#'clone_object, "obj/weapon"}) }),
 #               ({#'=, 'i, 5}),
 #               ({#'do,
 #                   ({#'call_other, 'weapon,
 #                       ({#'[,
 #                           quote(({ "set_alt_name", "set_weight", "set_value",
 #                               "set_class", "set_name"})), ({#'-=, 'i, 1}) }),
 #                       ({#'[,
 #                           quote(({ "knife", 1, 8,  5, "knife",
 #                               "knife", 1, 15, 7, "curved knife",
 #                               "axe",   2, 25, 9, "hand axe",  })),
 #                           ({#'+, 'n, 'i}) }) }),
 #               'i, 0}),
 #               ({#'transfer, 'weapon, 'orc}),
 #               ({#'command,
 #                   ({#'+, "wield ",
 #                       ({#'call_other, 'weapon, "query_name"}) }), 'orc}),
 #               ({#'move_object, 'orc, ({#'previous_object}) }),
 #           ({#'-=, 'num_orcs, 1}), 0})
 #       })
 #    );
 #    add_prop("get_orc", get_orc);
 #    get_orc = lambda( 0, ({#'funcall, get_orc, 2, 50}) );
 #    add_prop(C_EXTRA_RESET, get_orc);
 #    funcall(get_orc);
 #}
 #
 #TWO_EXIT("room/slope", "east",
 #        "room/fortress", "north",
 #        "The orc valley",
 #        "You are in the orc valley. This place is inhabited by orcs.\n" +
 #        "There is a fortress to the north, with lot of signs of orcs.\n", 1)
 #
 #    ----------- cut here ------- cut here -------- cut here ------------
 #
 Procedural elements:
 ====================

 definition of terms:
   <block>  : zero or more values to be evaluated.
   <test>   : one value to be evaluated as branch or loop condition.
   <result> : one value to be evaluated at the end of the execution of the
              form; the value is returned.
   <lvalue> : local variable/parameter, global variable, or an indexed lvalue.
 useded EBNF operators:
 { }     iteration
 [ ]     option

 forms:
   ({#', <body> <result>})
   ({#'? { <test> <result> } [ <result> ] })
   ({#'?! { <test> <result> } [ <result> ] })
   ({#'&& { test } })
   ({#'|| { test } })
   ({#'while <test> <result> <body>})    loop while test evaluates non-zero.
   ({#'do <body> <test> <result>})       loop till test evaluates zero.
   ({#'= { <lvalue> <value> } })         assignment
                                         other assignment operators work too.

 lisp similars:
   #',           progn
   #'?           cond
   #'&&          and
   #'||          or
   #'while       do      /* but lisp has more syntactic candy here */
   #'=           setq

 A parameter / local variable 'foo' is referenced as 'foo , a global
 variable as ({#'foo}) . In lvalue positions (assignment), you need not
 enclose global variable closures in arrays.

 Call by reference parameters are given with ({#'&, <lvalue>})

 Some special efuns:
 #'[             indexing
 #'[<            indexing from the end
 #'negate        unary -

 Unbound lambda closures
 =======================

 These closures are not bound to any object. They are created with the efun
 unbound_lambda() . They cannot contain references to global variables, and
 all lfun closures are inserted as is, since there is no native object for
 this closure.
 You can bind and rebind unbound lambda closures to an object with efun
 bind_lambda() You need to bind it before it can be called. Ordinary objects
 can obly bind to themselves, binding to other objects causes a privilege
 violation().
 The point is that previous_object for calls done from inside the closure
 will reflect the object doing bind_lambda(), and all object / uid based
 security will also refer to this object.


 The following is mostly vapourware.
 Well, another application would be that some things in the driver can be,
 sort of, microprogrammed.
 The master object could set some hooks in inaugurate_master(), like creating
 the code for move_object(), using a primitive low_move_object() or
 __move_object() or such. All calls of init(), exit(), etc. can thus be
 controlled on mudlib level.
 The driver would do an implicit bind_lambda() to the victim when the closure
 is used.

 e.g.
 ({#'?, ({#'=, 'ob, ({#'first_inventory, 'destination}) }),
     ({#'do,
         ({#'call_other, 'ob, "init"}),
     ({#'=, 'ob, ({#'next_inventory, 'ob}) }), 0 })
 })

 or

 ({#'filter_objects, ({#'all_inventory, 'destination}), "init"})
 /* Won't show init failures due to move/destruct */

 is equivalent to

 if (ob = first_inventory(destination) ) {
     do {
         ob->init();
     } while(ob = next_inventory(ob) );
 }

 and it's speed is mainly determined by the call_other. Thus, it shouldn't be
 noticably slower than the current C code in move_object().
	Closures provide a means of creating code dynamically and passing pieces
	of code as parameters, storing them in variables. One might think of them
	as a very advanced form of process_string(). However, this falls short of
	what you can actually do with them.

	The simplest kind of closures are efuns, lfuns or operators. For
	example, #'this_player is an example of a closure. You can assign it
	to a variable as in

	closure f;
	object p;
	f = #'this_player;

	and later use either the funcall() or apply() efun to evaluate it. Like

	p = funcall(f);

	or
	p = apply(f);

	In both cases there p will afterwards hold the value of this_player().
	Of course, this is only a rather simple application. More useful
	instances of closures can be created using the lambda() efun. It is much
	like the lambda function in LISP. For example, you can do the following:

	f = lambda( ({ 'x }), ({ #'environment, 'x }) );

	This will create a lambda closure and assign it to f. The first argument
	to lambda is an array describing the arguments (symbols) passed to the
	closure upon evaluation by funcall() or apply(). You can now evaluate f,
	for example by means of funcall(f,this_object()). This will result in
	the following steps:

	1. The value of this_object() will be bound to symbol x.
	2. environment(x) evaluates to environment(this_object())
	and is returned as the result of the funcall().

	One might wonder why there are two functions, funcall() and apply(), to
	perform the seemingly same job, namely evaluating a closure. Of course
	there is a subtle difference. If the last argument to apply() is an array,
	then each of its elements gets expanded to an additional paramater. The
	obvious use would be #'call_other as in:

	mixed eval(object ob,string func,mixed *args)
	{
	return apply(#'call_other,ob,func,args);
	}

	This will result in calling ob->func(args[0],args[1],...,args[sizeof(args)-1]).
	Using funcall() instead of apply() would have given us ob->func(args).

	Of course, besides efuns there are closures for operators, like #'+,
	#'-, #'<, #'&&, etc.

	Well, so far closures have been pretty much limited despite their
	obvious flexibility. This changes now with the introduction of
	conditional and loop operators. For example, try:

	closure max;
	max = lambda( ({ 'x, 'y }), ({ #'? ,({ #'>, 'x, 'y}), 'x, 'y }) });
	return funcall(max,7,3);

	The above example will return 7. What happened? Of course #'? is the
	conditional operator and its 'syntax' is as follows:

	({ #'?, cond1, val1, cond2, val2, ..., condn, valn, valdefault });

	It evaluates cond1, cond2, ..., condn successively until it gets a
	nonzero result and then returns the corresponding value. If there is no
	condition evaluating to a nonzero result, valdefault gets returned. If
	valdefault is omitted, 0 gets returned. #'?! works just like #'?, except
	that the ! operator is applied to conditions before testing. Therefore,
	while #'? is somewhat like an if statement, #'?! resembles an if_not
	statement if there were one.

	There are also loops:
	({ #'do, loopbody, loopcond, loopresult })
	will evaluate loopbody until loopcond evaluates to 0 and
	then return the value of loopresult. Symbols my be used
	as variables, of course.

	({ #'while, loopcond, loopresult, loopbody })
	works similar but evaluates loopcond before loopbody.

	There are, however, some questions open:

	a) How do I write down an array within a lambda closure to avoid
	interpretation as a subclosure?
	({ #'member_array, 'x, ({ "abc", "xyz }) }) will obviously result in
	an error as soon as lambda() tries to interpret "abc" as a closure
	operator. The solution is to quote the array, as in:
	({ #'member_array, 'x, '({ "abc", "xyz }) }). Applying lambda() to
	this will not result in an error. Instead, the quote will be stripped
	from the array and the result regarded as a normal array literal. The
	same can be achieved by using the efun quote(), e.g.:
	({ #'member_array, 'x, quote( ({ "abc", "xyz }) ) })
	b) Isn't it a security risk to pass, say, a closure to the master object
	which then evaluates it with all the permissions it got?
	Luckily, no. Each closure gets upon compilation bound to the object
	defining it. That means that executing it first sets this_object()
	to the object that defined it and then evaluates the closure. This
	also allows us to call lfuns which might otherwise be undefined in
	the calling object.
	There is however, a variant of lambda(), called unbound_lambda(),
	which works similar but does not allow the use of lfuns and does not
	bind the closure to the defining object. The drawback is that trying
	to evaluate it by apply() or funcall() will result in an error. The
	closure first needs to be bound by calling bind_lambda().
	bind_lambda() normally takes one argument and transforms an unbound
	closure into a closure bound to the object executing the
	bind_lambda().
	Privileged objects, like the master and the simul_efun object (or
	those authorized by the privilege_violation() function in the master)
	may also give an object as the second argument to bind_lambda(). This
	will bind the closure to that object. A sample application is:

	dump_object(ob)
	// will dump the variables of ob to /dump.o
	{
	closure save;
	save = unbound_lambda( ({ }), ({ #'save_object, "/open/dump" }) );
	bind_lambda(save,ob);
	funcall(save);
	}

	bind_lambda() can also be used with efun closures.

	c) It might be an interesting application to create closures dynamically
	as an alternative to writing LPC code to a file and then loading it.
	However, how do I avoid doing exactly that if I need symbols like 'x
	or 'y?
	To do that one uses the quote() efun. It takes a string as its
	argument and transforms it into a symbol. For example, writing
	quote("x") is exactly the same as writing 'x.

	d) How do I test if a variable holds a closure?
	Use the closurep() efun which works like all the other type testing
	efuns. For symbols there is also symbolp() available.

	e) That means, I can do:
	if (closurep(f)) return funcall(f); else return f; ?
	Yes, but in the case of funcall() it is unnecessary. If funcall()
	gets only one argument and it is not a closure it will be returned
	unchanged. So return funcall(f); would suffice.

	f) I want to use a function in some object as a closure. How do I do
	that?
	There are several ways. If the function resides in this_object(),
	just use #'func_name. If not, or if you want to create the function
	dnynamically, use the efun symbol_function(). It takes a string as
	it first and an object as its second argument and returns a closure
	which upon evaluation calls the given function in the given object
	(and faster than call_other(), too, if done from inside a loop,
	since function search will be done only when calling symbol_function().

	g) Can I create efun closures dynamically, too?
	Yes, just use symbol_function() with a single argument. Most useful
	for marker objects and the like. But theoretically a security risk
	if not used properly and from inside a security relevant object.
	Take care, however, that, if there is a simul_efun with the same
	name, it will be preferred as in the case of #'function. Use the
	efun:: modifier to get the efun if you need it.

	h) Are there other uses of closures except using them to store code?
	Lots. For example, you can use them within almost all of the
	efuns where you give a function as an argument, like filter(),
	sort_array() or walk_mapping(). sort_array(array,#'>) does indeed
	what is expected. Another application is set_prompt(), where a
	closure can output your own prompt based on the current time and other
	stuff which changes all the time.

	Finally, there are some special efun/operator closures:

	#'[ indexes an array.
	#'[< does the same, but starting at the end.
	#'negate is for unary minus.
	#', may be followed by any number of closures,
	e.g.: ({ #', ({#'= 'h, 'a, }), ({#'=, 'a, 'b }), ({#'=, 'b, 'h }) })
	will swap 'a and 'b when compiled and executed.

	------------
	An example from Amylaar:

	#I have tested the replace_program() functionality with one example, which I
	#include below. The room is commonly known as /room/orc_valley.c .
	#A prerequisite to make this work is to have valued properties in room.c .
	#The property C_EXTRA_RESET, if defined, is evaluated at reset time in
	#the reset() of the used room.c .
	#Moreover, you need a function to query an unprocessed property to use
	#orc_valley.c from fortress.c (That is, don't do an automatic funcall there.)
	#If you can't supply such a function, you have to set the property "get_orc"
	#at the end of orc_valley.c 's extra_reset() with:
	# add_prop("get_orc", lambda(0, get_orc) );
	#which will set the property to a function that returns the function that
	#is in the variable get_orc at the time you do the add_prop() call.
	#
	#Back to fortress.c : Assume you have the function successfully queried and
	#stored in the variable get_orc. Now you can compute your extra_reset()
	#function by:
	# get_orc = lambda( 0, ({#'funcall, get_orc, 8, 40}) );
	#which creates the usual 8 orcs with an a_chat chance of 40.
	#
	#Here comes the orc_valley.c source:
	#
	# ----------- cut here ------- cut here -------- cut here ------------
	#
	##include "room.h"
	##include "/sys/stdproperties.h"
	##undef EXTRA_RESET
	##define EXTRA_RESET extra_reset();
	#
	#extra_reset() {
	# closure get_orc;
	#
	# replace_program("room/room"); /* Must come first. */
	# get_orc = lambda( ({'num_orcs, 'chat_chance}),
	# ({#'?!, ({#'present, "orc", ({#'previous_object}) }),
	# ({#'do,
	# ({#'=, 'orc, ({#'clone_object, "obj/monster"}) }),
	# ({#'=, 'i, 9}),
	# ({#'do,
	# ({#'call_other, 'orc, "set_level",
	# ({#'+, ({#'random, 2}), 1}) }),
	# ({#'call_other, 'orc,
	# ({#'[,
	# quote(({"set_aggressive", "set_ac", "set_short",
	# "set_al", "set_ep", "set_hp", "set_race",
	# "set_alias", "set_name"})), ({#'-=, 'i, 1}) }),
	# ({#'[,
	# quote(({1, 0, "An orc", -60, 1014, 30, "orc",
	# "dirty crap", "orc"})), 'i}) }),
	# 'i, 0}),
	# ({#'call_other, 'orc, "load_a_chat", 'chat_chance,
	# quote(({ "Orc says: Kill 'em!\n",
	# "Orc says: Bloody humans!\n",
	# "Orc says: Stop 'em!\n",
	# "Orc says: Get 'em!\n",
	# "Orc says: Let's rip out his guts!\n",
	# "Orc says: Kill 'em before they run away!\n",
	# "Orc says: What is that human doing here!\n",
	# })) }),
	# ({#'=, 'n, ({#'*, ({#'random, 3}), 5}) }),
	# ({#'=, 'weapon, ({#'clone_object, "obj/weapon"}) }),
	# ({#'=, 'i, 5}),
	# ({#'do,
	# ({#'call_other, 'weapon,
	# ({#'[,
	# quote(({ "set_alt_name", "set_weight", "set_value",
	# "set_class", "set_name"})), ({#'-=, 'i, 1}) }),
	# ({#'[,
	# quote(({ "knife", 1, 8, 5, "knife",
	# "knife", 1, 15, 7, "curved knife",
	# "axe", 2, 25, 9, "hand axe", })),
	# ({#'+, 'n, 'i}) }) }),
	# 'i, 0}),
	# ({#'transfer, 'weapon, 'orc}),
	# ({#'command,
	# ({#'+, "wield ",
	# ({#'call_other, 'weapon, "query_name"}) }), 'orc}),
	# ({#'move_object, 'orc, ({#'previous_object}) }),
	# ({#'-=, 'num_orcs, 1}), 0})
	# })
	# );
	# add_prop("get_orc", get_orc);
	# get_orc = lambda( 0, ({#'funcall, get_orc, 2, 50}) );
	# add_prop(C_EXTRA_RESET, get_orc);
	# funcall(get_orc);
	#}
	#
	#TWO_EXIT("room/slope", "east",
	# "room/fortress", "north",
	# "The orc valley",
	# "You are in the orc valley. This place is inhabited by orcs.\n" +
	# "There is a fortress to the north, with lot of signs of orcs.\n", 1)
	#
	# ----------- cut here ------- cut here -------- cut here ------------
	#
	Procedural elements:
	====================

	definition of terms:
	<block> : zero or more values to be evaluated.
	<test> : one value to be evaluated as branch or loop condition.
	<result> : one value to be evaluated at the end of the execution of the
	form; the value is returned.
	<lvalue> : local variable/parameter, global variable, or an indexed lvalue.
	useded EBNF operators:
	{ } iteration
	[ ] option

	forms:
	({#', <body> <result>})
	({#'? { <test> <result> } [ <result> ] })
	({#'?! { <test> <result> } [ <result> ] })
	({#'&& { test } })
	({#'\|\| { test } })
	({#'while <test> <result> <body>}) loop while test evaluates non-zero.
	({#'do <body> <test> <result>}) loop till test evaluates zero.
	({#'= { <lvalue> <value> } }) assignment
	other assignment operators work too.

	lisp similars:
	#', progn
	#'? cond
	#'&& and
	#'\|\| or
	#'while do /* but lisp has more syntactic candy here */
	#'= setq

	A parameter / local variable 'foo' is referenced as 'foo , a global
	variable as ({#'foo}) . In lvalue positions (assignment), you need not
	enclose global variable closures in arrays.

	Call by reference parameters are given with ({#'&, <lvalue>})

	Some special efuns:
	#'[ indexing
	#'[< indexing from the end
	#'negate unary -

	Unbound lambda closures
	=======================

	These closures are not bound to any object. They are created with the efun
	unbound_lambda() . They cannot contain references to global variables, and
	all lfun closures are inserted as is, since there is no native object for
	this closure.
	You can bind and rebind unbound lambda closures to an object with efun
	bind_lambda() You need to bind it before it can be called. Ordinary objects
	can obly bind to themselves, binding to other objects causes a privilege
	violation().
	The point is that previous_object for calls done from inside the closure
	will reflect the object doing bind_lambda(), and all object / uid based
	security will also refer to this object.


	The following is mostly vapourware.
	Well, another application would be that some things in the driver can be,
	sort of, microprogrammed.
	The master object could set some hooks in inaugurate_master(), like creating
	the code for move_object(), using a primitive low_move_object() or
	__move_object() or such. All calls of init(), exit(), etc. can thus be
	controlled on mudlib level.
	The driver would do an implicit bind_lambda() to the victim when the closure
	is used.

	e.g.
	({#'?, ({#'=, 'ob, ({#'first_inventory, 'destination}) }),
	({#'do,
	({#'call_other, 'ob, "init"}),
	({#'=, 'ob, ({#'next_inventory, 'ob}) }), 0 })
	})

	or

	({#'filter_objects, ({#'all_inventory, 'destination}), "init"})
	/* Won't show init failures due to move/destruct */

	is equivalent to

	if (ob = first_inventory(destination) ) {
	do {
	ob->init();
	} while(ob = next_inventory(ob) );
	}

	and it's speed is mainly determined by the call_other. Thus, it shouldn't be
	noticably slower than the current C code in move_object().