CONCEPT
    modifiers
    
DESCRIPTION

    Global variables and functions in an object can have the type modifiers
    'public', 'static', 'private', or 'protected'.
    
    
    The proper order to define a function call is:
    
        [ modifier ] [ varargs ] [ return type ] function( args...)
        
     Any other order will result in an error.
     
    
    Functions which are not given any modifier are by default always public.
    A public function may be called from anywhere ( using call_other(),
    filter_*(), map_*(), or object->fun() ).
    
    Variables are never accessible to external, non-inheriting objects, 
    regardless of modifier. Use properties for this instead.
    
    A public variable is only available to inheriting objects (objects
    which inherit the object where the variable is defined).
    
    Private functions are never visible outside of an object and may not
    be called from any other object, including inheriting objects.
    
    Private variables are not visible anywhere outside the object which
    defines them, not even to inheriting objects.
    
    Static functions are only visible to inheriting objects, but not to
    external objects. They may not be called using call_other(), etc. 

    Static variables will not be saved by save_object() or restored
    using restore_object(). Static variables are visible to inheriting
    objects only, never to external objects.

    Variables and functions that are declared as public cannot be
    made static or private by inheriting objects.
    
    
    ==============================================================
    [ FUNCTIONS ]  |  public  |  static  |  protected  |  private
    ==============================================================
    Accessible to  |          |          |             |     
    inheriting     |   yes    |   yes    |    yes      |    no
    objects?       |          |          |             |
    --------------------------------------------------------------
    Accessible via |          |          |             |
    call_other(),  |          |          |             |
    filter_*(),    |   yes    |   no     |    no       |    no
    map_*() from   |          |          |             |
    other objects? |          |          |             |
    ==============================================================
    [ VARIABLES ]  |  public  |  static  |  protected  |  private
    ==============================================================
    Accessible to  |          |          |             |
    inheriting     |   yes    |   yes    |    yes      |    no
    objects?       |          |          |             |
    --------------------------------------------------------------
    Accessible to  |   no     |   no     |    no       |    no
    other objects? |          |          |             |
    --------------------------------------------------------------
    Saved with     |   yes    |   no     |    yes      |    yes
    save_object()? |          |          |             |
    ==============================================================
    

    It is also possible to specify the treatment of the inherited
    variables and functions in the inherit statement, e.g.:

        private variables static functions inherit "/foo/bar";
        
    though this counts among the more bizzare things Amylaar has
    implemented. (In other words, don't use it).

    The type modifier 'protected' is currently unused.
    

SEE ALSO
    inheritance(LPC), functions(LPC), types(LPC), varargs(LPC)
