Uniform access principle

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 [http://www.eiffel.com/general/monthly_column/2005/Sept_October.html 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.

= 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 nowprint Foo.barprint Foo.bar()

When executed, should display :

55

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 = 5Foo.bar(5)//These should achieve the same goal

= Language Examples =

Ruby

class Foo attr_reader :x def initialize(x) @x = x end def x_times_5 return @x*5 endend

y = Foo.new(2)puts y.xputs y.x_times_5This outputs:

210

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

= Python =

class Foo(object): def __init__(self, x): self.setx(x)

def getx(self): return self.__x

def setx(self, x): self.__x = x

def getx_times_5(self): return self.x*5 x = property(getx, doc="getter for x") x_times_5 = property(getx_times_5, doc="getter for x, times 5")

y = Foo(2)print y.xprint y.x_times_5This outputs:

210

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).

= PHP =

class Foo{ private $x;

function __construct($x){ $this->x = $x; }

function x(){ return $this->x; }

function x_times_5(){ return $this->x*5;

$y = new Foo(2);echo $y->x();echo $y->x_times_5();This outputs:

210

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)

ee also

* [http://c2.com/cgi/wiki?UniformAccessPrinciple The UniformAccessPrinciple on the c2 wiki]
* http://www.eiffel.com/general/monthly_column/2005/Sept_October.html