Storing Object Data in a Context

  Brian,

  I was recently playing around with some code in Python on the idea that:

    "An object does not have attributes.
    Rather, if an object appears to have attributes, it's actually w.r.t. a context."

  So for example, I write:

  society = Obj()
  biology = Obj()
  a = Obj()

  with biology:
      a.sex = "M"
      a.born = Date("1977-08-29")

  with society:
      a.name = "Lion Kimbro"
      print(a.name)  # says "Lion Kimbro"

  with a:
      a.name = "Lion"

  print(a.name)  # Error;  a does not have a name
  print(biology.descriptions)  # outputs:  {id(a): {"sex": "M", "born": <1977-08-29>}}

  If there's a bi-directional links system in the code, then you can do things like:

  print(a.name)  # -> {id(society): "Lion Kimbro", id(a): "Lion"}

  My question for you is:
  * Do you know who is investigating these lines of thought?

  I've looked at "Contextual Oriented Programming" pages, but it all looks pretty arcane.
  I don't see anything that I can relate to there, and wonder if it's even the same idea.

  I understand what data looks like in what I've created above, but I am scratching my head around, "Where is a method?"  Is the method in the context?  Is the method in the object?  Are methods free-floating things?

  I can imagine a command like "talk" meaning different things in the biological context vs. the social context, or amongst different circles of friends, for example.

  Perhaps even saying "this object of this class" is a contextual operation, and the object has a different class depending on the context.  All assignments to the object happen within the framework of the active class, ..?

  I'm just making stuff up here.

--- main ideas of the code in the following:

class Object3Contextual:
   
    """An experiment in contextual attributes.
   
    Req:
    - Object3InitDelete
    - Object3GettersSetters
   
    FURTHER RESEARCH:
    - My main question is about, "What is the role of OPERATIONS,
      (of methods,) given this vision?"
    - because:
      We traditionally consider methods just like properties-
      things that are stuck to the object.
    - but now:
      We're saying that properties are NOT parts of the object.
      Rather, your properties are known through a context.
    - So are your methods your own, or do they belong to a context?
    """
   
    __context_stack__ = []
   
    def __myinit__(self, **kw):
        # describes:  id(obj) -> {attr:value, ...}
        object.__setattr__(self, "describes", {})
   
    def __enter__(self):
        Object3Contextual.__context_stack__.append(self)
    def __exit__(self, type, value, traceback):
        Object3Contextual.__context_stack__.pop()
   
    def _contextual_general_getter(self, key):
        for context in reversed(Object3Contextual.__context_stack__):
            desc = context.describes.get(id(self))
            if (desc is None) or (key not in desc):
                continue
            else:
                return (True, desc[key])
        return (False, None)
   
    def _contextual_general_setter(self, key, value):
        for context in reversed(Object3Contextual.__context_stack__):
            desc = context.describes.get(id(self))
            if (desc is None) or (key not in desc):
                continue
        ctxt = Object3Contextual.__context_stack__[-1]
        ctxt.describes.setdefault(id(self), {})[key] = value
        return True

@object3class
class CtxtPoint(Object3InitDelete, Object3GettersSetters, Object3Contextual):
    pass

Permalink | Leave a comment  »