The usual presentation of STRIPS actions is developed in a first-order
setting.  What that means is that in addition to 

	kind fact, action type.

We have another type for the objects that we encounter in the
environment.

	kind object type.

Facts and actions can now be parameterized with respect to the objects
that they involve.  For example, we can introduce a constant d1 to
represent an object this way:

	type d1 object.

Let's suppose that d1 is actually a door.  Then we might want to use
expressions such as the following to represent facts about d1:

	(door d1)
	(closed d1)
	(unlocked d1)
	
And so forth.  Similarly, we might want to use an expression such as
the following to indicate the action of pulling d1:

	(pull d1)

First question: what types should the constants door, closed, unlocked
and pull get in this new setting?

Next question: suppose we wanted to describe the consequences of
pulling on a door D, using the STRIPS notation.  How would we adapt
the definition in (9d) to do it?  Would we have to change the type of
is_action?  

----

Let's follow up on (13) a bit -- it's a chance to introduce a good
lambda prolog tip.  We saw that you can't use the definition of bp1
for search to find a plan.  If you wanted to, you would pose a query
such as the following:

	bp1 (closed::keyed::locked::nil) (finish (open::nil)) P.

And -- for reasons we discussed -- the lambda prolog interpreter would
disappear in an infinite loop of trying the same few actions over and
over again.  On the other hand, if you specified the value for P as in
(12), you would get a different query:

	bp1 (closed::keyed::locked::nil) (finish (open::nil)) 
	(step (closed::keyed::locked::nil)
	 turn
	 (step (closed::unlocked::nil)
	  pull
	  (finish (open::nil)))).

Pose this, and lambda prolog would say "solved".  

Obviously, this expression is pretty ungainly, and if you were
debugging the definition of bp1 you would find typing this query over
and over again tedious at best.  A good trick is therefore to add some
definitions to your program containing data structures that you want
to use in test examples.  Study this example.

type test_facts list fact -> o.
test_facts (closed::keyed::locked::nil).

type test_goal plan -> o.
test_goal (finish (open::nil)).

type test_plan plan -> o.
test_plan (step (closed::keyed::locked::nil) turn
	   (step (closed::unlocked::nil) pull
	    (finish (open::nil)))).


type test o.
test :-
	test_facts F,
	test_goal G,
	test_plan P,
	bp1 F G P.

Now you can add a goal like test_plan P to a query and after that goal
is solved, P will be instantiated to that horrible plan expression
without your having had to type it yourself!