/interpreter/tags/at2-build270707/src/edu/vub/at/objects/ATMethod.java

  1/**
  2 * AmbientTalk/2 Project
  3 * ATMethod.java created on Jul 24, 2006 at 9:42:24 PM
  4 * (c) Programming Technology Lab, 2006 - 2007
  5 * Authors: Tom Van Cutsem & Stijn Mostinckx
  6 * 
  7 * Permission is hereby granted, free of charge, to any person
  8 * obtaining a copy of this software and associated documentation
  9 * files (the "Software"), to deal in the Software without
 10 * restriction, including without limitation the rights to use,
 11 * copy, modify, merge, publish, distribute, sublicense, and/or
 12 * sell copies of the Software, and to permit persons to whom the
 13 * Software is furnished to do so, subject to the following
 14 * conditions:
 15 *
 16 * The above copyright notice and this permission notice shall be
 17 * included in all copies or substantial portions of the Software.
 18 *
 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 21 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 22 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 23 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 24 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 25 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 26 * OTHER DEALINGS IN THE SOFTWARE.
 27 */
 28package edu.vub.at.objects;
 29
 30import edu.vub.at.exceptions.InterpreterException;
 31import edu.vub.at.objects.grammar.ATBegin;
 32import edu.vub.at.objects.grammar.ATSymbol;
 33
 34/**
 35 * ATMethods are the AmbientTalk's representation of methods as named functions. These
 36 * functions do not close over an environment allowing for them to be shared between 
 37 * different clones. The environment is to be supplied during lookup (which wraps an 
 38 * ATMethod into {@link ATClosure}). As a consequence, it is not possible to
 39 * get hold of an ATMethod at the base-level (since lookup implies wrapping).
 40 * 
 41 * @author smostinc
 42 * @author tvcutsem
 43 */
 44public interface ATMethod extends ATObject {
 45
 46	/**
 47	 * Wrap the receiver method into a closure which packs together the code (method) and the scope (context)
 48	 * in which the code should be evaluated.
 49	 * 
 50	 * @param lexicalScope the lexical scope in which the method was created. During method invocation,
 51	 * lexical lookup should proceed along this scope.
 52	 * @param dynamicReceiver the dynamic receiver (value of <tt>self</tt>) at the time the method is
 53	 * selected from an object.
 54	 * @return a closure wrapping this method.
 55	 */
 56	public ATClosure base_wrap(ATObject lexicalScope, ATObject dynamicReceiver) throws InterpreterException;
 57	
 58	/**
 59	 * Applies the method to the given arguments in the given context.
 60	 * The context is usually supplied by a closure and is necessary in order to
 61	 * pair a method with its current receiver (its 'self').
 62	 * <p>
 63	 * The method itself is responsible for creating the appropriate 'call frame'
 64	 * or activation record in which to define temporary variables and parameter bindings.
 65	 * 
 66	 * @param arguments the actual arguments, already eagerly evaluated.
 67	 * @param ctx the context in which to evaluate the method body, call frame not yet inserted.
 68	 * @return the value of evaluating the method body in a context derived from the given context.
 69	 */
 70	public ATObject base_apply(ATTable arguments, ATContext ctx) throws InterpreterException;
 71	
 72	/**
 73	 * Applies the method to the given arguments in the given context.
 74	 * The context is usually supplied by a closure and is necessary in order to
 75	 * pair a method with its current receiver (its 'self').
 76	 * <p>
 77	 * The method will use the given context 'as-is', and will *not* insert an additional call frame.
 78	 * 
 79	 * @param arguments the actual arguments, already eagerly evaluated.
 80	 * @param ctx the context in which to evaluate the method body, to be used without inserting a call frame.
 81	 * @return the value of evaluating the method body in the given context.
 82	 */
 83	public ATObject base_applyInScope(ATTable arguments, ATContext ctx) throws InterpreterException;
 84	
 85	/**
 86	 * Returns the name of the method. 
 87	 * <p>
 88	 * Note that all methods (defined using <code>def name( ...args... ) { ... }</code> or <code>def foo: arg bar: arg { ... }</code>) 
 89	 * retain the name with which they were first bound. Literal blocks which may be created
 90	 * outside of a definition are implicitly named 'lambda'.
 91	 * 
 92	 * @return an {@link ATSymbol} representing the name by which the method can be identified.
 93	 */
 94	public ATSymbol base_name() throws InterpreterException;
 95	
 96	/**
 97	 * Returns the parameter list of the method which is normally a table of symbols.
 98	 * 
 99	 * @return an {@link ATTable} representing the parameter list of the method.
100	 */
101	public ATTable base_parameters() throws InterpreterException;
102	
103	/**
104	 * Returns the body of the method.
105	 * 
106	 * @return an {@link ATBegin} representing the body of the method.
107	 */
108	public ATBegin base_bodyExpression() throws InterpreterException;
109}