Uniform access principle

From Wikipedia, the free encyclopedia

Jump to: navigation, search

The Uniform Access Principle was put forth by Bertrand Meyer. It states "All services offered by a module should be available through a uniform notation, which does not betray whether they are implemented through storage or through computation." This principle applies generally to object-oriented programming languages. In simpler form, it states that there should be no difference between working with an attribute, precomputed property, or method/query.

While most examples focus on the "read" aspect of the principle, Meyer shows that the "write" implications of the principle are harder to deal with in his monthly column on the Eiffel programming language official website.

Many languages have various degrees of support for UAP, where some of the implementations violate the spirit of UAP. The inclusion of 'properties' in some programming languages is another way address the problem that Meyer discusses. Properties don't provide a uniform notation, but they do make the call to the method which provides a service opaque.


[edit] UAP Example

If a language allows access to a variable via dot-notation and assignment

Foo.bar = 5 //Assigns 5 to the object variable "bar"

then these operations should be the same :

//Assume print displays the variable passed to it, with or without parens
//Assume Foo.bar = 5 for now
print Foo.bar
print Foo.bar()

When executed, should display :


This allows the object to still hide information as well as being easy to access.

The same should be true for setting the data.

Foo.bar = 5
//These should achieve the same goal

[edit] Language Examples

[edit] Ruby

class Foo
  attr_reader :x
  def initialize(x)
    @x = x
  def squared_x
    return @x * @x
y = Foo.new(2)
puts y.x
puts y.squared_x

This outputs:


Note how even though x is an attribute and squared_x is a parameterless method call, they are accessed the same way.

[edit] Python

class Foo(object):
    def __init__(self, x):
    def getx(self):
        return self.__x
    def setx(self, x):
        self.__x = x
    def getsquared_x(self):
        return self.x * self.x
    x = property(getx, doc="getter for x")
    squared_x = property(getsquared_x, doc="getter for squared x")
y = Foo(2)
print y.x
print y.squared_x

This outputs:


Python properties can be used to achieve UAP. This method of using properties to map other functions to variable access matches Meyer's idea of UAP closely (Eiffel uses a similar mechanism).

[edit] PHP

class Foo{
    private $x;
    function __construct($x){
        $this->x = $x;
    function x(){
        return $this->x;
    function squared_x(){
        return $this->x * $this->x;
$y = new Foo(2);
echo $y->x();
echo $y->squared_x();

This outputs:


Observation: There are many other ways to achieve the same functionality in PHP, for example making x public and accessing it directly or using magic methods function __get($variable)

[edit] See also

Personal tools