Inheritance and forward references (prototypes)

Discussion in 'Python' started by Lorenzo Di Gregorio, Jun 20, 2009.

  1. Hi,

    I'm wondering what would be the preferred way to solve the following
    forward reference problem:

    ---------------------------------------
    class BaseA(object):
    def __init__(self):
    return

    class DebugA(BaseA):
    def __init__(self):
    return

    # here I would have a prototype of class A which is the same as class
    BaseA

    class B(object):
    def __init__(self):
    self.obj = A()
    return

    if __name__ == "__main__":
    # class A(BaseA): # Uncomment this for using BaseA objects
    # pass
    class A(DebugA): # Uncomment this for using DebugA objects
    pass
    ---------------------------------------

    I can figure out some ways to fix this but none seems satisfying.
    Either they are too specific or too cumbersome.
    A runtime redefinition of class A does not seem to work either.
    What would be the most "pythonesque" solution other than sorting out
    the class order?

    Best Regards,
    Lorenzo
    Lorenzo Di Gregorio, Jun 20, 2009
    #1
    1. Advertising

  2. Lorenzo Di Gregorio wrote:

    > Hi,
    >
    > I'm wondering what would be the preferred way to solve the following
    > forward reference problem:


    You don't actually explain what is the problem. Fortunately, I'm good at
    guessing, and I think I can guess what your problem is (see below):


    > ---------------------------------------
    > class BaseA(object):
    > def __init__(self):
    > return
    >
    > class DebugA(BaseA):
    > def __init__(self):
    > return
    >
    > # here I would have a prototype of class A which is the same as class
    > BaseA
    >
    > class B(object):
    > def __init__(self):
    > self.obj = A()
    > return
    >
    > if __name__ == "__main__":
    > # class A(BaseA): # Uncomment this for using BaseA objects
    > # pass
    > class A(DebugA): # Uncomment this for using DebugA objects
    > pass
    > ---------------------------------------


    Class A only gets defined if you run the module as a script. What you need
    is to unconditionally define class A, outside of the if __name__ block:


    class A(BaseA):
    pass

    # A.__base__ = DebugA ## Uncomment this line for debugging.




    --
    Steven
    Steven D'Aprano, Jun 20, 2009
    #2
    1. Advertising

  3. Lorenzo Di Gregorio

    Dave Angel Guest

    Lorenzo Di Gregorio wrote:
    > Hi,
    >
    > I'm wondering what would be the preferred way to solve the following
    > forward reference problem:
    >
    > ---------------------------------------
    > class BaseA(object):
    > def __init__(self):
    > return
    >
    > class DebugA(BaseA):
    > def __init__(self):
    > return
    >
    > # here I would have a prototype of class A which is the same as class
    > BaseA
    >
    > class B(object):
    > def __init__(self):
    > self.obj = A()
    > return
    >
    > if __name__ == "__main__":
    > # class A(BaseA): # Uncomment this for using BaseA objects
    > # pass
    > class A(DebugA): # Uncomment this for using DebugA objects
    > pass
    > ---------------------------------------
    >
    > I can figure out some ways to fix this but none seems satisfying.
    > Either they are too specific or too cumbersome.
    > A runtime redefinition of class A does not seem to work either.
    > What would be the most "pythonesque" solution other than sorting out
    > the class order?
    >
    > Best Regards,
    > Lorenzo
    >
    >

    You haven't shown us any problem. class B works fine with a forward
    reference to A. Now if you were trying to subclass A before defining
    it, that'd be a problem. Or if you were trying to make an instance of B
    before defining A.

    Better put some code together with enough meat to actually show a
    symptom. And tell us what sys.version says. I'm testing with 2.6.2
    (r262:71605, Apr 14 2009, 22:40:02) [MSC v.1500 32 bit (Intel)], running
    on Win XP.
    Dave Angel, Jun 20, 2009
    #3
  4. >>>>> Steven D'Aprano <> (SD) wrote:

    >SD> Lorenzo Di Gregorio wrote:
    >>> Hi,
    >>>
    >>> I'm wondering what would be the preferred way to solve the following
    >>> forward reference problem:


    >SD> You don't actually explain what is the problem. Fortunately, I'm good at
    >SD> guessing, and I think I can guess what your problem is (see below):



    >>> ---------------------------------------
    >>> class BaseA(object):
    >>> def __init__(self):
    >>> return
    >>>
    >>> class DebugA(BaseA):
    >>> def __init__(self):
    >>> return
    >>>
    >>> # here I would have a prototype of class A which is the same as class
    >>> BaseA
    >>>
    >>> class B(object):
    >>> def __init__(self):
    >>> self.obj = A()
    >>> return
    >>>
    >>> if __name__ == "__main__":
    >>> # class A(BaseA): # Uncomment this for using BaseA objects
    >>> # pass
    >>> class A(DebugA): # Uncomment this for using DebugA objects
    >>> pass
    >>> ---------------------------------------


    >SD> Class A only gets defined if you run the module as a script. What you need
    >SD> is to unconditionally define class A, outside of the if __name__ block:



    >SD> class A(BaseA):
    >SD> pass


    >SD> # A.__base__ = DebugA ## Uncomment this line for debugging.


    >>>A.__base__ = DebugA

    TypeError: readonly attribute

    Make that: A.__bases__ = DebugA,

    >SD> --
    >SD> Steven



    --
    Piet van Oostrum <>
    URL: http://pietvanoostrum.com [PGP 8DAE142BE17999C4]
    Private email:
    Piet van Oostrum, Jun 20, 2009
    #4
  5. On Jun 20, 8:43 pm, Dave Angel <> wrote:
    > Lorenzo Di Gregorio wrote:
    > > Hi,

    >
    > > I'm wondering what would be the preferred way to solve the following
    > > forward reference problem:

    >
    > > ---------------------------------------
    > > class BaseA(object):
    > >     def __init__(self):
    > >         return

    >
    > > class DebugA(BaseA):
    > >     def __init__(self):
    > >         return

    >
    > > # here I would have a prototype of class A which is the same as class
    > > BaseA

    >
    > > class B(object):
    > >     def __init__(self):
    > >         self.obj = A()
    > >         return

    >
    > > if __name__ == "__main__":
    > > #    class A(BaseA): # Uncomment this for using BaseA objects
    > > #       pass
    > >     class A(DebugA): # Uncomment this for using DebugA objects
    > >         pass
    > > ---------------------------------------

    >
    > > I can figure out some ways to fix this but none seems satisfying.
    > > Either they are too specific or too cumbersome.
    > > A runtime redefinition of class A does not seem to work either.
    > > What would be the most "pythonesque" solution other than sorting out
    > > the class order?

    >
    > > Best Regards,
    > > Lorenzo

    >
    > You haven't shown us any problem.  class B works fine with a forward
    > reference to A.  Now if you were trying to subclass A before defining
    > it, that'd be a problem.  Or if you were trying to make an instance of B
    > before defining A.
    >
    > Better put some code together with enough meat to actually show a
    > symptom.  And tell us what sys.version says.  I'm testing with   2.6.2
    > (r262:71605, Apr 14 2009, 22:40:02) [MSC v.1500 32 bit (Intel)], running
    > on Win XP.- Hide quoted text -
    >
    > - Show quoted text -


    Thank you for your help: I'm working on a rather large source, but I
    think I have isolated the problem now.
    This listing generates an error:

    -----------------------------------------------
    class BaseA(object):
    def __init__(self):
    return

    class DebugA(BaseA):
    def __init__(self):
    return

    class B(object):
    def __init__(self,test=A()):
    self.obj = A()
    return

    if __name__ == "__main__":
    # class A(BaseA): # Uncomment this for using BaseA objects
    # pass
    class A(DebugA): # Uncomment this for using DebugA objects
    pass
    -----------------------------------------------

    The error happens because Python apparently evaluates the named
    arguments before running the script.
    I think I have read something about this some (long) time ago but I
    can't find it anymore.

    Suggestions?

    BTW, my Python version is 2.6.1 (with latest PyDev).

    Thx!
    Lorenzo
    Lorenzo Di Gregorio, Jun 20, 2009
    #5
  6. Lorenzo Di Gregorio

    Rhodri James Guest

    On Sat, 20 Jun 2009 21:26:56 +0100, Lorenzo Di Gregorio
    <> wrote:

    > Thank you for your help: I'm working on a rather large source, but I
    > think I have isolated the problem now.
    > This listing generates an error:
    >
    > -----------------------------------------------
    > class BaseA(object):
    > def __init__(self):
    > return
    >
    > class DebugA(BaseA):
    > def __init__(self):
    > return
    >
    > class B(object):
    > def __init__(self,test=A()):
    > self.obj = A()
    > return
    >
    > if __name__ == "__main__":
    > # class A(BaseA): # Uncomment this for using BaseA objects
    > # pass
    > class A(DebugA): # Uncomment this for using DebugA objects
    > pass
    > -----------------------------------------------
    >
    > The error happens because Python apparently evaluates the named
    > arguments before running the script.
    > I think I have read something about this some (long) time ago but I
    > can't find it anymore.


    I could have sworn this was in the FAQ, but apparently not. You're
    right, Python evaluates the default arguments when it executes the
    `def` instruction. (Yes, `def` is an executable instruction. It's
    got to create the function/method object after all!)

    The usual fix is not to make the default an instance of A (which
    will have all sorts of other side effects as well, since the same
    instance of A will be shared by all the Bs that don't supply a
    `test` parameter), but to use `None` as a marker.

    class B(object):
    def __init__(self, test=None):
    if test is None:
    test = A()
    self.obj = A()

    and so on.
    --
    Rhodri James *-* Wildebeest Herder to the Masses
    Rhodri James, Jun 21, 2009
    #6
  7. On Sat, 20 Jun 2009 13:26:56 -0700 (PDT), Lorenzo Di Gregorio
    <> declaimed the following in
    gmane.comp.python.general:


    >
    > The error happens because Python apparently evaluates the named
    > arguments before running the script.
    > I think I have read something about this some (long) time ago but I
    > can't find it anymore.


    File "E:\UserData\Dennis Lee Bieber\My Documents\Python
    Progs\Script1.py", line 9, in <module>
    class B(object):
    File "E:\UserData\Dennis Lee Bieber\My Documents\Python
    Progs\Script1.py", line 10, in B
    def __init__(self,test=A()):
    NameError: name 'A' is not defined

    Which is to be expected... "class" and "def" are EXECUTABLE
    statements, not DECLARATIONS. Execution consists of "compiling" code
    blocks, which includes executing default arguments (these are computed
    ONCE, at the time the "def" is executed), finally binding the compiled
    code block to a name...

    Compare to:
    -=-=-=-=-=-=-
    class BaseA(object):
    def __init__(self):
    pass

    class DebugA(BaseA):
    def __init__(self):
    pass

    class B(object):
    def __init__(self,test=None):
    if not test: test = A()
    #do something with test
    self.obj = A()

    if __name__ == "__main__":
    # class A(BaseA): # Uncomment this for using BaseA objects
    # pass
    class A(DebugA): # Uncomment this for using DebugA objects
    pass
    print "done"
    -=-=-=-=-=-=-

    --
    Wulfraed Dennis Lee Bieber KD6MOG

    HTTP://wlfraed.home.netcom.com/
    (Bestiaria Support Staff: )
    HTTP://www.bestiaria.com/
    Dennis Lee Bieber, Jun 21, 2009
    #7
  8. Lorenzo Di Gregorio

    Dave Angel Guest

    Lorenzo Di Gregorio wrote:
    > On Jun 20, 8:43 pm, Dave Angel <> wrote:
    >
    >> Lorenzo Di Gregorio wrote:
    >>
    >>> Hi,
    >>>
    >>> I'm wondering what would be the preferred way to solve the following
    >>> forward reference problem:
    >>>
    >>> ---------------------------------------
    >>> class BaseA(object):
    >>> def __init__(self):
    >>> return
    >>>
    >>> class DebugA(BaseA):
    >>> def __init__(self):
    >>> return
    >>>
    >>> # here I would have a prototype of class A which is the same as class
    >>> BaseA
    >>>
    >>> class B(object):
    >>> def __init__(self):
    >>> self.obj =()
    >>> return
    >>>
    >>> if __name__ ="__main__":
    >>> # class A(BaseA): # Uncomment this for using BaseA objects
    >>> # pass
    >>> class A(DebugA): # Uncomment this for using DebugA objects
    >>> pass
    >>> ---------------------------------------
    >>>
    >>> I can figure out some ways to fix this but none seems satisfying.
    >>> Either they are too specific or too cumbersome.
    >>> A runtime redefinition of class A does not seem to work either.
    >>> What would be the most "pythonesque" solution other than sorting out
    >>> the class order?
    >>>
    >>> Best Regards,
    >>> Lorenzo
    >>>

    >> You haven't shown us any problem. class B works fine with a forward
    >> reference to A. Now if you were trying to subclass A before defining
    >> it, that'd be a problem. Or if you were trying to make an instance of B
    >> before defining A.
    >>
    >> Better put some code together with enough meat to actually show a
    >> symptom. And tell us what sys.version says. I'm testing with 2.6.2
    >> (r262:71605, Apr 14 2009, 22:40:02) [MSC v.1500 32 bit (Intel)], running
    >> on Win XP.- Hide quoted text -
    >>
    >> - Show quoted text -
    >>

    >
    > Thank you for your help: I'm working on a rather large source, but I
    > think I have isolated the problem now.
    > This listing generates an error:
    >
    > -----------------------------------------------
    > class BaseA(object):
    > def __init__(self):
    > return
    >
    > class DebugA(BaseA):
    > def __init__(self):
    > return
    >
    > class B(object):
    > def __init__(self,test=A()):
    > self.obj =()
    > return
    >
    > if __name__ ="__main__":
    > # class A(BaseA): # Uncomment this for using BaseA objects
    > # pass
    > class A(DebugA): # Uncomment this for using DebugA objects
    > pass
    > -----------------------------------------------
    >
    > The error happens because Python apparently evaluates the named
    > arguments before running the script.
    > I think I have read something about this some (long) time ago but I
    > can't find it anymore.
    >
    > Suggestions?
    >
    > BTW, my Python version is 2.6.1 (with latest PyDev).
    >
    > Thx!
    > Lorenzo
    >
    >

    This error is caused because a default argument uses class A. Default
    arguments of class methods are evaluated during the definition of the
    class, and not later when the class is instantiated. Thus the problem.

    To work around that specific problem, you may want to use the following:

    class B(object):
    def __init__(self,test=None):
    if test==None:
    test = A()
    self.obj =()
    return


    This is actually different than what you had, since what you had would
    have used the same A() object for all instances of B that didn't supply
    their own test() parameter. Maybe that's what you wanted, and maybe
    not, but default arguments set to mutable values are frequently a bug.

    But I'm wondering if you're just looking for problems. Why not put the
    commented switch early in the file, and test for it wherever you need to
    use it?

    import x, y, z
    _debug = False
    #_debug = True


    then as soon as BaseA and DebugA are defined, do the following:

    if _debug:
    class A(DebugA):
    pass
    else:
    class A(BaseA)
    pass
    Dave Angel, Jun 21, 2009
    #8
  9. On Sat, 20 Jun 2009 16:37:12 -0700, Dennis Lee Bieber
    <> declaimed the following in
    gmane.comp.python.general:

    > class B(object):
    > def __init__(self,test=None):
    > if not test: test = A()


    Okay -- I got sloppy here, and passing [] to the creation would also
    trigger the above, vs testing for identity to None

    if test is None:...
    --
    Wulfraed Dennis Lee Bieber KD6MOG

    HTTP://wlfraed.home.netcom.com/
    (Bestiaria Support Staff: )
    HTTP://www.bestiaria.com/
    Dennis Lee Bieber, Jun 21, 2009
    #9
  10. On 21 Jun., 01:54, Dave Angel <> wrote:
    > LorenzoDiGregoriowrote:
    > > On Jun 20, 8:43 pm, Dave Angel <> wrote:

    >
    > >>LorenzoDiGregoriowrote:

    >
    > >>> Hi,

    >
    > >>> I'm wondering what would be the preferred way to solve the following
    > >>> forward reference problem:

    >
    > >>> ---------------------------------------
    > >>> class BaseA(object):
    > >>>     def __init__(self):
    > >>>         return

    >
    > >>> class DebugA(BaseA):
    > >>>     def __init__(self):
    > >>>         return

    >
    > >>> # here I would have a prototype of class A which is the same as class
    > >>> BaseA

    >
    > >>> class B(object):
    > >>>     def __init__(self):
    > >>>         self.obj =()
    > >>>         return

    >
    > >>> if __name__ ="__main__":
    > >>> #    class A(BaseA): # Uncomment this for using BaseA objects
    > >>> #       pass
    > >>>     class A(DebugA): # Uncomment this for using DebugA objects
    > >>>         pass
    > >>> ---------------------------------------

    >
    > >>> I can figure out some ways to fix this but none seems satisfying.
    > >>> Either they are too specific or too cumbersome.
    > >>> A runtime redefinition of class A does not seem to work either.
    > >>> What would be the most "pythonesque" solution other than sorting out
    > >>> the class order?

    >
    > >>> Best Regards,
    > >>>Lorenzo

    >
    > >> You haven't shown us any problem.  class B works fine with a forward
    > >> reference to A.  Now if you were trying to subclass A before defining
    > >> it, that'd be a problem.  Or if you were trying to make an instance of B
    > >> before defining A.

    >
    > >> Better put some code together with enough meat to actually show a
    > >> symptom.  And tell us what sys.version says.  I'm testing with   2.6.2
    > >> (r262:71605, Apr 14 2009, 22:40:02) [MSC v.1500 32 bit (Intel)], running
    > >> on Win XP.- Hide quoted text -

    >
    > >> - Show quoted text -

    >
    > > Thank you for your help: I'm working on a rather large source, but I
    > > think I have isolated the problem now.
    > > This listing generates an error:

    >
    > > -----------------------------------------------
    > > class BaseA(object):
    > >     def __init__(self):
    > >         return

    >
    > > class DebugA(BaseA):
    > >     def __init__(self):
    > >         return

    >
    > > class B(object):
    > >     def __init__(self,test=A()):
    > >         self.obj =()
    > >         return

    >
    > > if __name__ ="__main__":
    > > #    class A(BaseA): # Uncomment this for using BaseA objects
    > > #        pass
    > >      class A(DebugA): # Uncomment this for using DebugA objects
    > >          pass
    > > -----------------------------------------------

    >
    > > The error happens because Python apparently evaluates the named
    > > arguments before running the script.
    > > I think I have read something about this some (long) time ago but I
    > > can't find it anymore.

    >
    > > Suggestions?

    >
    > > BTW, my Python version is 2.6.1 (with latest PyDev).

    >
    > > Thx!
    > >Lorenzo

    >
    > This error is caused because a default argument uses class A.  Default
    > arguments of class methods are evaluated during the definition of the
    > class, and not later when the class is instantiated.  Thus the problem.
    >
    > To work around that specific problem, you may want to use the following:
    >
    > class B(object):
    >     def __init__(self,test=None):
    >         if test==None:
    >             test = A()
    >         self.obj =()
    >         return
    >
    > This is actually different than what you had, since what you had would
    > have used the same A() object for all instances of B that didn't supply
    > their own test() parameter.  Maybe that's what you wanted, and maybe
    > not, but default arguments set to mutable values are frequently a bug.
    >
    > But I'm wondering if you're just looking for problems.  Why not put the
    > commented switch early in the file, and test for it wherever you need to
    > use it?
    >
    > import  x, y, z
    > _debug = False
    > #_debug = True
    >
    > then as soon as  BaseA and DebugA are defined, do the following:
    >
    > if _debug:
    >     class A(DebugA):
    >         pass
    > else:
    >     class A(BaseA)
    >         pass- Zitierten Text ausblenden -
    >
    > - Zitierten Text anzeigen -


    I had also thought of using "None" (or whatever else) as a marker but
    I was curious to find out whether there are better ways to supply an
    object with standard values as a default argument.
    In this sense, I was looking for problems ;-)

    Of course the observation that "def" is an instruction and no
    declaration changes the situation: I would not have a new object being
    constructed for every instantiation with no optional argument, because
    __init__ gets executed on the instantiation but test=A() gets executed
    on reading 'def'.

    At this point I think there is no other way than using a marker as
    suggested above multiple times, if I want to supply a new object with
    default values for non-passed arguments.

    Anybody with a better idea?
    Lorenzo Di Gregorio, Jun 21, 2009
    #10
  11. Lorenzo Di Gregorio

    Lie Ryan Guest

    Lorenzo Di Gregorio wrote:
    > I had also thought of using "None" (or whatever else) as a marker but
    > I was curious to find out whether there are better ways to supply an
    > object with standard values as a default argument.
    > In this sense, I was looking for problems ;-)
    >
    > Of course the observation that "def" is an instruction and no
    > declaration changes the situation: I would not have a new object being
    > constructed for every instantiation with no optional argument, because
    > __init__ gets executed on the instantiation but test=A() gets executed
    > on reading 'def'.
    >
    > At this point I think there is no other way than using a marker as
    > suggested above multiple times, if I want to supply a new object with
    > default values for non-passed arguments.


    Using None as default for mutable default argument is the common idiom
    for the problem you're having.
    Lie Ryan, Jun 21, 2009
    #11
  12. On Sun, 21 Jun 2009 04:55:45 -0700 (PDT), Lorenzo Di Gregorio
    <> declaimed the following in
    gmane.comp.python.general:

    >
    > At this point I think there is no other way than using a marker as
    > suggested above multiple times, if I want to supply a new object with
    > default values for non-passed arguments.
    >

    Marker is needed if the default is to a mutable type (unless, now
    that you know the behavior, you have an explicit need for a shared
    "default").

    If the default is a numeric, tuple, or string, it is safe since
    nothing you do later in the code can change its "contents"
    --
    Wulfraed Dennis Lee Bieber KD6MOG

    HTTP://wlfraed.home.netcom.com/
    (Bestiaria Support Staff: )
    HTTP://www.bestiaria.com/
    Dennis Lee Bieber, Jun 21, 2009
    #12
  13. Piet van Oostrum a écrit :
    >>>>>> Steven D'Aprano <> (SD) wrote:

    (snip)
    >> SD> # A.__base__ = DebugA ## Uncomment this line for debugging.

    >
    >>>> A.__base__ = DebugA

    > TypeError: readonly attribute
    >
    > Make that: A.__bases__ = DebugA,



    or even better (readability-wise):

    A.__bases__ = (DebugA,)

    Just the same thing, but at least you wont neither miss the ',' no
    wonder wether it's a typo or the author really wanted a tuple.
    Bruno Desthuilliers, Jun 22, 2009
    #13
  14. Dave Angel a écrit :
    (snip
    > Default
    > arguments of class methods are evaluated during the definition of the
    > class


    <pedantic>
    Default arguments of functions are eval'd during the execution of the
    def statement.

    The fact that you use a def statement within a class statement's body is
    totally orthogonal - a def statement produces a function object, period.

    It's only when resolved as a class attribute that a function "becomes" a
    method object (thanks to the descriptor protocol).
    </pedantic>
    Bruno Desthuilliers, Jun 22, 2009
    #14
  15. On 21 Jun., 22:51, Scott David Daniels <> wrote:
    > LorenzoDiGregoriowrote:
    > > On 21 Jun., 01:54, Dave Angel <> wrote:
    > >> ...
    > >> class B(object):
    > >>     def __init__(self,test=None):
    > >>         if test==None:
    > >>             test = A()
    > >>         self.obj =()
    > >>         return

    > > ...
    > > I had also thought of using "None" (or whatever else) as a marker but
    > > I was curious to find out whether there are better ways to supply an
    > > object with standard values as a default argument.
    > > In this sense, I was looking for problems ;-)

    >
    > > Of course the observation that "def" is an instruction and no
    > > declaration changes the situation: I would not have a new object being
    > > constructed for every instantiation with no optional argument, because
    > > __init__ gets executed on the instantiation but test=A() gets executed
    > > on reading 'def'....

    >
    > If what you are worrying about is having a single default object, you
    > could do something like this:
    >
    >      class B(object):
    >          _default = None
    >
    >          def __init__(self, test=None):
    >              if test is None:
    >                  test = self._default
    >                  if test is None:
    >                      B._default = test = A()
    >              ...
    >
    > --Scott David Daniels
    > - Zitierten Text ausblenden -
    >
    > - Zitierten Text anzeigen -


    Well, I could also declare (ups, define ;-)) __init__(self,**kwargs)
    and within the __init__, if kwargs['test'] exists, do test = kwargs
    ['test'], if it does not exist, do test = A().

    The point is that it would have been cleaner to place it straight in
    the __init__, but due to the semantic of 'def' this does not seem
    possible.
    Lorenzo Di Gregorio, Jun 22, 2009
    #15
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Roger Leigh
    Replies:
    8
    Views:
    405
    Karl Heinz Buchegger
    Nov 17, 2003
  2. qazmlp
    Replies:
    1
    Views:
    575
    Jonathan Turkanis
    Feb 15, 2004
  3. Boris Du¹ek
    Replies:
    3
    Views:
    365
    Juha Nieminen
    May 2, 2009
  4. Lloyd Zusman

    Forward references?

    Lloyd Zusman, Jul 30, 2004, in forum: Ruby
    Replies:
    22
    Views:
    452
    Lloyd Zusman
    Aug 3, 2004
  5. prototypes and references

    , Jul 7, 2006, in forum: Javascript
    Replies:
    4
    Views:
    93
Loading...

Share This Page