translation challenge from PythonTranslator...

''Evil grin.'' OK, what about the following Scheme code.

'''Scheme'''

  ;;; Pointers in Scheme
  ;;; Adding pointer arithmetic is left as an exercise to the reader
  (define (make-pointer getter setter)
    (cons getter setter))

  (define (pointer-ref ptr)
    ((car ptr)))

  (define (pointer-set! ptr value)
    ((cdr ptr) value))

  (define-syntax address
    (syntax-rules ()
       ((address var)
        (make-pointer
          (lambda () var)
          (lambda (value) (set! var value))))))

  ;;; A few examples
  (define x 1)
  (define px (address x))
  (display (pointer-ref px))(newline)
  (pointer-set! px 2)
  (display (pointer-ref px))(newline)


'''Python'''

    # Take a first cut.  

    class Pointer:
        def __init__(self, var):
            self.var = var

        def set(self, val):
            self.var = val        

        def get(self):
            return self.var

    x = 1
    px = Pointer(x)
    print px.get()
    px.set(2)
    print px.get()

    # So far so good.  But then this breaks...

    y = 10
    py = Pointer(y)
    py.set(20)
    print y

    # When we print y, it's still 10.  The problem is, 
    # primitive types pass by value in Python.
    # So let's try making an Integer object.

    class Integer:
        def __init__(self, val):
            self.val = val

        def set(self, val):
            self.val = val

        def get(self):
            return self.val

    # And we can add a level of indirection.

    class Ptr:
        def __init__(self, var):
            self.var = var

        def set(self, val):
            self.var.set(val)

        def get(self):
            return self.var.get()

    print 'Test #2'
    y = Integer(10)
    print y.get()
    py = Ptr(y)
    py.set(20)
    print y.get()

    # And that seems to work.  


-- SteveHowell

----

''So pointer allows you to call get/set on anything that already has a get/set method?  So what's the point?  :-)''

----

Yep, it's kind of pointless to implement a pointer scheme in a language like Python, which solves problems just fine without them.  That's what made this particular challenge so ''sinister.''  Insidious, even.  -- SteveHowell

''Nevertheless, it is an interesting problem.  I explore a RubyLanguage version on the SinisterSchemeSampleInRuby page. -- JimWeirich''
----
For the interested, here is some background information on
the original Scheme code. The method outlined here to simulate
pointers in Scheme was used in an early C-to-Lisp compiler for the
MIT Lisp machine. (The C compiler on the later commercial Lisp
machine didn't use this trick; it generated machine-code for
the Lisp machine directly, just like a conventional C compiler.)
One can have more operations that just set and get; in particular,
one can implement pointer arithmetic. For this, the limitation in
the ANSI C standard that pointer arithmetic only works on pointers
that point into the same array is essential. 

The piece of memory
that contains the value of a variable is called a location in
Scheme. In effect, the above Scheme code makes locations
available as first-class values. We call this process reification.
Thus, the Scheme code implements reifiable locations, or
''locatives'' for short. Note that these locatives have unlimited
extent, unlike C pointers, which have dynamic extent.

There was a Scheme dialect called T that made heavy use of locatives.

So now you know why C "pointers" should really by called 
"first-class reified locations with dynamic extent." ;-)

-- StephanHouben

I think I might know how to do arithmetic.

     (def *heap* nil)
     (define (malloc ()
         (def lexvar nil)
         (let (a (address lexvar)
             (set! *heap* (cons a *heap*))
             a)))
Then do heap manipulations.  Can someone help with this?

...Oh, wait.  I see...

    (define (malloc (size)
        (if (= size 0)
            nil
            (cons nil (malloc (- size 1))))))
    (define (ptr+ (aConsCell num)
         (if (= num 0)
             aConsCell
             (ptr+ (cdr aConsCell) (- num 1)))))

     
----
CategoryPython