anchor.diff:      #'(lambda (glist)
   	(unwind-protect
   	     (map-glist 'list #'identity glist element-type)
  -	  (glist-free glist)))))
  +	  (destroy-glist glist element-type)))))
  +
  +(defmethod copy-from-alien-form (glist (type (eql 'glist)) &rest args)
  +  (declare (ignore type))
  +  (destructuring-bind (element-type) args
  +    `(map-glist 'list #'identity ,glist ',element-type)))
  +
  +(defmethod copy-from-alien-function ((type (eql 'glist)) &rest args)
  +  (declare (ignore type))
  +  (destructuring-bind (element-type) args
  +    #'(lambda (glist)
  +	(map-glist 'list #'identity glist element-type))))
   
   (defmethod cleanup-form (glist (type (eql 'glist)) &rest args)
  -  (declare (ignore type args))
  -  `(glist-free ,glist))
  +  (declare (ignore type))
  +  (destructuring-bind (element-type) args
  +    `(destroy-glist ,glist ',element-type)))
   
   (defmethod cleanup-function ((type (eql 'glist)) &rest args)
     (declare (ignore type args))
  -  #'glist-free)
  -
  +  (destructuring-bind (element-type) args
  +    #'(lambda (glist)
  +	(destroy-glist glist element-type))))
   
   
   ;;;; Single linked list (GSList)
   
   (deftype gslist (type) `(or (null (cons ,type list))))
   
  -(defbinding (%gslist-prepend-unsigned "g_slist_prepend") () pointer
  +(defbinding (%gslist-prepend "g_slist_prepend") () pointer
     (gslist pointer)
  -  (data unsigned))
  -
  -(defbinding (%gslist-prepend-signed "g_slist_prepend") () pointer
  -  (gslist pointer)
  -  (data signed))
  -
  -(defbinding (%gslist-prepend-sap "g_slist_prepend") () pointer
  -  (gslist pointer)
  -  (data pointer))
  +  (nil null))
   
   (defun make-gslist (type list)
  -  (let ((new-element (ecase (alien-type type)
  -		       (system-area-pointer #'%gslist-prepend-sap)
  -		       ((signed-byte c-call:short c-call:int c-call:long)
  -			#'%gslist-prepend-signed)
  -		       ((unsigned-byte c-call:unsigned-short 
  -			 c-call:unsigned-int c-call:unsigned-long)
  -			#'%gslist-prepend-unsigned)))
  -	(to-alien (to-alien-function type)))
  -    (loop
  -     for element in (reverse list)
  -     as gslist = (funcall new-element (or gslist (make-pointer 0)) 
  -		  (funcall to-alien element))
  -     finally (return gslist))))
  +  (loop
  +   with writer = (writer-function type)
  +   for element in (reverse list)
  +   as gslist = (%gslist-prepend (or gslist (make-pointer 0)))
  +   do (funcall writer element gslist)
  +   finally (return gslist)))
   
   (defbinding (gslist-free "g_slist_free") () nil
     (gslist pointer))
   
  +(defun destroy-gslist (gslist element-type)
  +  (loop
  +   with destroy = (destroy-function element-type)
  +   as tmp = gslist then (glist-next tmp)
  +   until (null-pointer-p tmp)
  +   do (funcall destroy tmp 0))
  +  (gslist-free gslist))
   
   (defmethod alien-type ((type (eql 'gslist)) &rest args)
     (declare (ignore type args))
  
positive.code:     `(let ((gslist ,gslist))
        (unwind-protect
  	   (map-glist 'list #'identity gslist ',element-type)
  	(gslist-free gslist)))))
  
  (defmethod from-alien-function ((type (eql 'gslist)) &rest args)
    (declare (ignore type))
  
negative.code: (defbinding (glist-free "g_list_free") () nil
    (glist pointer))
  
  (defun destroy-glist (glist element-type)
    (loop
     with destroy = (destroy-function element-type)
     as tmp = glist then (glist-next tmp)
     until (null-pointer-p tmp)
     do (funcall destroy tmp 0))
    (glist-free glist))
  
  (defmethod alien-type ((type (eql 'glist)) &rest args)
    (declare (ignore type args))
  