Lambda the Ultimate

This seems off topic for LtU. A Lisp discussion group would be more appropriate.

I agree that a Lisp forum would be more appropriate but there is something "meta" about the verbosity that tries to creep into Lisp programs that use structures and classes. Having to read and write prefixes like editor-env- several times in every small function is just silly.

I don't know a really good and canonical solution but here are some code snippets that might be stimulate some ideas.

First just a basic tweak:

(defun rowcol->screen (row col)
  "Return the X and Y coordinates of ROW and COL as values."
  (values (+ (editor-env-left *env*) (* col (editor-env-font-dx *env*))))
          (+ (editor-env-top *env*) (* row (editor-env-font-dy *env*))))

Then one option would be to unpack the fields of *env* into their own special variables:

(defun rowcol->screen (row col)
  (values (+ *left* (* col *font-dx*))
          (+ *top* (* row *font-dy*))))

Or to use WITH-SLOTS which SBCL supports on structures:

(defun rowcol->screen (row col)
  (with-slots (left top font-dx font-dy) *env*
      (values (+ left (* col font-dx))
              (+ top (* row font-dy)))))

Or use CLOS'ish short-named generic functions for accessors as you get from DEFCLASS instead of DEFSTRUCT:

(defun rowcol->screen (row col)
  (values (+ (left *env*) (* col (font-dx *env*))))
          (+ (top *env*) (* row (font-dy *env*))))

The Tutorial on Good Lisp Programming Style may provide inspiration too. Otherwise there's a lot of Lisp code on the 'net where you can see how other people write code in practice (e.g. common-lisp.net) but don't expect to find only one answer with Lisp. :-)

In CLOS I am using the convention slot-of for accessors, e.g. left-of, which was suggested on comp.lang.lisp some time ago.

I'd love to have the dot notation, too.

My mistake... I don't think I have quite appreciated the 'intent' of this forum.

Thanks for the quality replies, I have already been enlightened by what is possible.

So, where can I find a good lisp forum... comp.lang.lisp... I don't seem to be able to find a Usenet system... any ideas ?

Luke Gorrie has pretty much covered this, but the simple answer is that you could define a macro to execute some code within an editing environment:

(defmacro with-editor-env ((env) &body body)
  `(with-slots (buf top left row col row-max col-max csr-char paper ink font font-dx font-dy) ,env
     ,@body))

You could then write code like this:

(with-editor-env ((make-editor-env :buf 4 :ink :foo))
  (setf col 42)
  (values buf col ink))

Brace yourself, because I'm going to make this relevant to programming language design. This with-editor-env macro is leading toward something important: the notion of the current environment. If you have multiple environments -- say, multiple files open -- then I think it's worthwhile to structure your code as switching between environments rather than always specifying which environment your code is acting upon in every bit of code that performs an action.

This is very similar to the way you actually use a text editor, so there's a lot less mismatch between what you expect to program and what you actually end up programming. Check out this example, some emacs lisp code I wrote yesterday:

(defun picflow-show-in-c-buffer (args)
  (save-excursion
    (pop-to-buffer "*picflow-output*")
    (delete-region (point-min) (point-max))
    (insert (read (remove 13 (cadr args)))) ; insert c code
    (goto-char (point-min))
    (c-mode)))

This switches to a new buffer (creating it if it doesn't exist), deletes any current contents, inserts some text, goes to the beginning of the buffer, and then turns on C mode for that buffer so it gets proper syntax highlighting. Importantly, it then restores the context in which the user was working -- this is handled by the save-excursion special form.

This code would have been longer if emacs made me pass around environment variables all the time, but more crucially it would have been less obvious how to write it. The language's editing constructs very closely approximate the commands available to the user.

I think this is interesting as an example of a situation in which imperative, very stateful programming is actually the Right Thing to do.

import Control.Applicative

data EditorEnv = EditorEnv {
    buf::String,
    top::Int,
    left::Int,
    row::Int,
    col::Int
    -- etc.
}

env = EditorEnv { buf = "",top = 1,left = 2,row = 3,col = 4 }
-- We'd like to write: example = (top+row,col+left) but we have to use:
example = pure (,) <*> (pure (+) <*> top <*> row) <*> (pure (+) <*> col <*> left)