diff --git a/calculus/monte-carlo.lisp b/calculus/monte-carlo.lisp
index 7734714db71e5633424293622863863f7f2e9426..25b9557092d8a487463dafc3e5bc35ef26cc7f6e 100644
--- a/calculus/monte-carlo.lisp
+++ b/calculus/monte-carlo.lisp
@@ -1,6 +1,6 @@
 ;; Monte Carlo Integration
 ;; Liam Healy Sat Feb  3 2007 - 17:42
-;; Time-stamp: <2011-08-16 23:54:40EDT monte-carlo.lisp>
+;; Time-stamp: <2011-10-30 10:01:57EDT monte-carlo.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -58,7 +58,7 @@
    (result (:pointer :double)) (abserr (:pointer :double)))
   :inputs (lower-limits upper-limits)
   :callbacks
-  (callback fnstruct-dimension (dimension)
+  (callback (:struct fnstruct-dimension) (dimension)
 	    (function :double (:input :double :cvector dim0) :slug))
   :callback-dynamic (((dim0 lower-limits)) (function scalars))
   :documentation			; FDL
@@ -119,7 +119,7 @@
    (result (:pointer :double)) (abserr (:pointer :double)))
   :inputs (lower-limits upper-limits)
   :callbacks
-  (callback fnstruct-dimension (dimension)
+  (callback (:struct fnstruct-dimension) (dimension)
 	    (function :double (:input :double :cvector dim0) :slug))
   :callback-dynamic (((dim0 lower-limits)) (function scalars))
   :documentation			; FDL
@@ -180,7 +180,7 @@
    (result (:pointer :double)) (abserr (:pointer :double)))
   :inputs (lower-limits upper-limits)
   :callbacks
-  (callback fnstruct-dimension (dimension)
+  (callback (:struct fnstruct-dimension) (dimension)
 	    (function :double (:input :double :cvector dim0) :slug))
   :callback-dynamic (((dim0 lower-limits)) (function scalars))
   :documentation			; FDL
diff --git a/calculus/numerical-differentiation.lisp b/calculus/numerical-differentiation.lisp
index 83623f54014ad62fdc409fca2787d10bb2d2728d..0ae630901c61e9ba3e8c5a51c97b6b80fedb58be 100644
--- a/calculus/numerical-differentiation.lisp
+++ b/calculus/numerical-differentiation.lisp
@@ -1,8 +1,8 @@
 ;; Numerical differentiation.                
 ;; Liam Healy Mon Nov 12 2007 - 22:07
-;; Time-stamp: <2009-12-27 09:42:10EST numerical-differentiation.lisp>
+;; Time-stamp: <2011-10-30 10:27:07EDT numerical-differentiation.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -27,7 +27,7 @@
   ((callback :pointer) (x :double) (step :double)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the numerical derivative of the function
@@ -50,7 +50,7 @@
   ((callback :pointer) (x :double) (step :double)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the numerical derivative of the function
@@ -75,7 +75,7 @@
   ((callback :pointer) (x :double) (step :double)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the numerical derivative of the function at the point x
diff --git a/calculus/numerical-integration-with-tables.lisp b/calculus/numerical-integration-with-tables.lisp
index 5f4b4010aba0acffbeb17b082ff9882b409b323c..746de276a4cd64f8d1b9c250e5cfce77c731d691 100644
--- a/calculus/numerical-integration-with-tables.lisp
+++ b/calculus/numerical-integration-with-tables.lisp
@@ -1,8 +1,8 @@
 ;; Numerical integration techniques that require tables
 ;; Liam Healy 2009-04-04 15:24:05EDT 
-;; Time-stamp: <2010-08-07 21:41:16EDT numerical-integration-with-tables.lisp>
+;; Time-stamp: <2011-10-30 10:27:27EDT numerical-integration-with-tables.lisp>
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -65,7 +65,7 @@
    (limit sizet) ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the integral of the function f(x) over the interval (a,b)
@@ -123,7 +123,7 @@
    ((mpointer table) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Use an adaptive algorithm to compute the integral of f over (a,b)
@@ -167,7 +167,7 @@
    ((mpointer table) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "This function attempts to compute a Fourier integral of the
diff --git a/calculus/numerical-integration.lisp b/calculus/numerical-integration.lisp
index e398b2b1a2e05889d52fe42b3aaddb8b4bf3ecaf..606f7d93d7859f91166ffe9cf111e8033250ab95 100644
--- a/calculus/numerical-integration.lisp
+++ b/calculus/numerical-integration.lisp
@@ -1,6 +1,6 @@
 ;; Numerical integration
 ;; Liam Healy, Wed Jul  5 2006 - 23:14
-;; Time-stamp: <2011-01-10 17:59:21EST numerical-integration.lisp>
+;; Time-stamp: <2011-10-30 10:01:11EDT numerical-integration.lisp>
 ;;
 ;; Copyright 2006, 2007, 2008, 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -52,7 +52,7 @@
    (result (:pointer :double)) (abserr (:pointer :double))
    (neval (:pointer sizet)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Apply the Gauss-Kronrod 10-point, 21-point, 43-point and
@@ -92,7 +92,7 @@
    (limit sizet) (method integrate-method) ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Apply an integration rule adaptively until an estimate
@@ -129,7 +129,7 @@
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Apply the Gauss-Kronrod 21-point integration rule
@@ -163,7 +163,7 @@
    (result (:pointer :double)) (abserr (:pointer :double)))
   :inputs (points)
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Apply the adaptive integration algorithm QAGS taking
@@ -193,7 +193,7 @@
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the integral of the function f over the
@@ -218,7 +218,7 @@
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the integral of the function f over the
@@ -239,7 +239,7 @@
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the integral of the function f over the
@@ -265,7 +265,7 @@
    ((mpointer workspace) :pointer)
    (result (:pointer :double)) (abserr (:pointer :double)))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :callback-dynamic (nil (function))
   :documentation			; FDL
   "Compute the Cauchy principal value of the integral of
diff --git a/chebyshev.lisp b/chebyshev.lisp
index f17eca4bba256f5c1c15f0a5169339a218b7f41a..6eeab490148a3cc22682860ff9487f2bc5a06dc9 100644
--- a/chebyshev.lisp
+++ b/chebyshev.lisp
@@ -1,8 +1,8 @@
 ;; Chebyshev Approximations
 ;; Liam Healy Sat Nov 17 2007 - 20:36
-;; Time-stamp: <2010-06-29 21:47:34EDT chebyshev.lisp>
+;; Time-stamp: <2011-10-30 10:25:39EDT chebyshev.lisp>
 ;;
-;; Copyright 2007, 2008, 2009, 2010 Liam M. Healy
+;; Copyright 2007, 2008, 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -32,7 +32,7 @@
   :documentation			; FDL
   "Make a Chebyshev series of specified order."
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :initialize-suffix "init"
   :initialize-args
   ((callback :pointer) (lower-limit :double) (upper-limit :double))
diff --git a/data/foreign-array.lisp b/data/foreign-array.lisp
index 8ebf9e681c340889213c6d815c982e0ef82ebe97..0d12ea8cd5cd0253216611bad585a4ef4afee09a 100644
--- a/data/foreign-array.lisp
+++ b/data/foreign-array.lisp
@@ -1,6 +1,6 @@
 ;; A grid:foreign-array with added metadata for GSL.
 ;; Liam Healy 2008-04-06 21:23:41EDT
-;; Time-stamp: <2011-01-12 00:34:42EST foreign-array.lisp>
+;; Time-stamp: <2011-10-30 09:45:20EDT foreign-array.lisp>
 ;;
 ;; Copyright 2008, 2009, 2010, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -53,7 +53,10 @@
 	 ;; from the block to the vector/matrix; we must do that manually here
 	 (cffi:foreign-slot-value
 	  array-struct
-	  (if (typep object 'grid:matrix) 'gsl-matrix-c 'gsl-vector-c) 'data)
+	  (if (typep object 'grid:matrix)
+	      '(:struct gsl-matrix-c)
+	      '(:struct gsl-vector-c))
+	  'data)
 	 (grid:foreign-pointer object))
 	(tg:finalize object
 		     (lambda ()
@@ -77,8 +80,7 @@
 (defun make-foreign-array-from-mpointer
     (mpointer
      &optional (element-type 'double-float) (category-or-rank 'vector) finalize)
-  "Make the foreign array when a GSL pointer to a
-   gsl-vector-c or gsl-matrix-c is given."
+  "Make the foreign array when a GSL pointer to a gsl-vector-c or gsl-matrix-c is given."
   (let* ((category
 	  (case category-or-rank
 	    ((vector :vector 1) 'vector)
@@ -86,8 +88,8 @@
 	    (t (error "Unrecognized category ~a" category-or-rank))))
 	 (cstruct
 	  (case category
-	    (vector 'gsl-vector-c)
-	    (grid:matrix 'gsl-matrix-c)))
+	    (vector '(:struct gsl-vector-c))
+	    (grid:matrix '(:struct gsl-matrix-c))))
 	 (fa
 	  (grid:make-grid
 	   (case category
diff --git a/histogram/ntuple.lisp b/histogram/ntuple.lisp
index a0ce201ab5bf46eec12c3bfb311d277cab28e42b..f451960519bd81fd1a6827ee6bb5912a8716bf9f 100644
--- a/histogram/ntuple.lisp
+++ b/histogram/ntuple.lisp
@@ -1,6 +1,6 @@
 ;; N-tuples
 ;; Liam Healy Sat Feb  3 2007 - 12:53
-;; Time-stamp: <2011-08-19 09:44:16EDT ntuple.lisp>
+;; Time-stamp: <2011-10-30 10:09:06EDT ntuple.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -90,7 +90,7 @@
   :callbacks
   ;; (valfn fnstruct nil (value-function :pointer (:input :pointer) :slug))
   ;; Need a second cbstruct definition:
-  (selfn fnstruct nil (select-function :pointer (:input :pointer) :slug))
+  (selfn (:struct fnstruct) nil (select-function :pointer (:input :pointer) :slug))
   ;;:callback-dynamic (nil (value-function))
   :callback-dynamic (nil (select-function))
   :documentation			; FDL
@@ -115,7 +115,7 @@
    select-function returns zero are ignored.  New entries are added to
    the histogram, so subsequent calls can be used to accumulate further
    data in the same histogram."
-    (WITH-FOREIGN-OBJECTS ((VALFN 'FNSTRUCT) (SELFN 'fnstruct))
+    (WITH-FOREIGN-OBJECTS ((VALFN '(:struct FNSTRUCT)) (SELFN '(:struct fnstruct)))
       (SETF PROJECT-NTUPLE-DYNFN0
 	    (MAKE-COMPILED-FUNCALLABLE
 	     VALUE-FUNCTION
@@ -124,8 +124,8 @@
 	    (MAKE-COMPILED-FUNCALLABLE
 	     SELECT-FUNCTION
 	     '(FUNCTION :boolean (:INPUT :POINTER) :SLUG) NIL (LIST)))
-      (SET-CBSTRUCT VALFN 'FNSTRUCT NIL (LIST 'FUNCTION 'PROJECT-NTUPLE-CBFN0))
-      (SET-CBSTRUCT SELFN 'FNSTRUCT NIL (LIST 'FUNCTION 'PROJECT-NTUPLE-CBFN1))
+      (SET-CBSTRUCT VALFN '(:struct FNSTRUCT) NIL (LIST 'FUNCTION 'PROJECT-NTUPLE-CBFN0))
+      (SET-CBSTRUCT SELFN '(:struct FNSTRUCT) NIL (LIST 'FUNCTION 'PROJECT-NTUPLE-CBFN1))
       (LET ((CRETURN
 	     (FOREIGN-FUNCALL "gsl_ntuple_project" :POINTER
 			      (MPOINTER HISTOGRAM) :POINTER NTUPLE
@@ -178,16 +178,16 @@
 
 (defun make-ntuple-example-data
     (&optional (filename *ntuple-example-data-file*))
-  (cffi:with-foreign-object (data 'ntuple-data)
-    (let ((ntuple (create-ntuple filename data 'ntuple-data))
+  (cffi:with-foreign-object (data '(:struct ntuple-data))
+    (let ((ntuple (create-ntuple filename data '(:struct ntuple-data)))
 	  (answer (make-array 100 :element-type 'fixnum :initial-element 0)))
       (dotimes (row 1000)
 	(multiple-value-bind (xi yi zi)
 	    (ntuple-example-values row)
-	  (setf (cffi:foreign-slot-value data 'ntuple-data 'num) row
-		(cffi:foreign-slot-value data 'ntuple-data 'x) xi
-		(cffi:foreign-slot-value data 'ntuple-data 'y) yi
-		(cffi:foreign-slot-value data 'ntuple-data 'z) zi)
+	  (setf (cffi:foreign-slot-value data '(:struct ntuple-data) 'num) row
+		(cffi:foreign-slot-value data '(:struct ntuple-data) 'x) xi
+		(cffi:foreign-slot-value data '(:struct ntuple-data) 'y) yi
+		(cffi:foreign-slot-value data '(:struct ntuple-data) 'z) zi)
 	  (when (< (* xi *ntuple-example-scale*) 0.1d0)
 	    (incf (aref answer (truncate (* 100 *ntuple-example-scale* (+ xi yi zi)))))))
 	(bookdata-ntuple ntuple))
@@ -195,37 +195,37 @@
       answer)))
 
 (defun ntuple-example-read (&optional (filename *ntuple-example-data-file*))
-  (cffi:with-foreign-object (data 'ntuple-data)
-    (let ((ntuple (open-ntuple filename data 'ntuple-data)))
+  (cffi:with-foreign-object (data '(:struct ntuple-data))
+    (let ((ntuple (open-ntuple filename data '(:struct ntuple-data))))
       (prog1
 	  (dotimes (row 1000 t)
 	    (multiple-value-bind (xi yi zi)
 		(ntuple-example-values row)
 	      (read-ntuple ntuple)
 	      (unless
-		  (and (eql row (cffi:foreign-slot-value data 'ntuple-data 'num))
-		       (eql xi (cffi:foreign-slot-value data 'ntuple-data 'x))
-		       (eql yi (cffi:foreign-slot-value data 'ntuple-data 'y))
-		       (eql zi (cffi:foreign-slot-value data 'ntuple-data 'z)))
+		  (and (eql row (cffi:foreign-slot-value data '(:struct ntuple-data) 'num))
+		       (eql xi (cffi:foreign-slot-value data '(:struct ntuple-data) 'x))
+		       (eql yi (cffi:foreign-slot-value data '(:struct ntuple-data) 'y))
+		       (eql zi (cffi:foreign-slot-value data '(:struct ntuple-data) 'z)))
 		(return nil))))
 	(close-ntuple ntuple)))))
 
 (defun ntuple-example-sel-func (ntuple-data)
-  (< (* (cffi:foreign-slot-value ntuple-data 'ntuple-data 'x)
+  (< (* (cffi:foreign-slot-value ntuple-data '(:struct ntuple-data) 'x)
 	 *ntuple-example-scale*)
       0.1d0))
 
 (defun ntuple-example-val-func (ntuple-data)
-  (* (+ (cffi:foreign-slot-value ntuple-data 'ntuple-data 'x)
-	(cffi:foreign-slot-value ntuple-data 'ntuple-data 'y)
-	(cffi:foreign-slot-value ntuple-data 'ntuple-data 'z))
+  (* (+ (cffi:foreign-slot-value ntuple-data '(:struct ntuple-data) 'x)
+	(cffi:foreign-slot-value ntuple-data '(:struct ntuple-data) 'y)
+	(cffi:foreign-slot-value ntuple-data '(:struct ntuple-data) 'z))
      *ntuple-example-scale*))
 
 (defun ntuple-example-histogramming
     (&optional (filename *ntuple-example-data-file*))
-  (cffi:with-foreign-object (data 'ntuple-data)
+  (cffi:with-foreign-object (data '(:struct ntuple-data))
     (let ((histo (make-histogram 100))
-	  (ntuple (open-ntuple filename data 'ntuple-data))
+	  (ntuple (open-ntuple filename data '(:struct ntuple-data)))
 	  (answer (make-ntuple-example-data filename)))
       (set-ranges-uniform histo 0.0d0 1.0d0)
       (project-ntuple
diff --git a/ordinary-differential-equations/stepping.lisp b/ordinary-differential-equations/stepping.lisp
index 6efc6754ce7a17a897607d1a55c0bc3d9c8f05a7..e03a55ab1f71f8eca5c4feeb01b4c5a9147e0963 100644
--- a/ordinary-differential-equations/stepping.lisp
+++ b/ordinary-differential-equations/stepping.lisp
@@ -1,6 +1,6 @@
 ;; Stepping functions for ODE systems.
 ;; Liam Healy, Mon Sep 24 2007 - 21:33
-;; Time-stamp: <2011-01-10 17:59:27EST stepping.lisp>
+;; Time-stamp: <2011-10-30 09:55:50EDT stepping.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -33,7 +33,7 @@
    continuation of a previous step."
   :superclasses (callback-included-cl)
   :callbacks
-  (callback ode-system
+  (callback (:struct ode-system)
 	    (dimension)
 	    (function :success-failure
 		      (:input :double)	; t (independent variable)
diff --git a/series-acceleration.lisp b/series-acceleration.lisp
index 3d1cb8729c06c998b062def645ae7323020042c8..dc82d42b81d2a8275bf90d155c9ce00c1400c778 100644
--- a/series-acceleration.lisp
+++ b/series-acceleration.lisp
@@ -1,6 +1,6 @@
 ;; Series acceleration.
 ;; Liam Healy, Wed Nov 21 2007 - 18:41
-;; Time-stamp: <2011-05-26 12:37:29EDT series-acceleration.lisp>
+;; Time-stamp: <2011-10-30 09:55:05EDT series-acceleration.lisp>
 ;;
 ;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -27,7 +27,7 @@
 ;;;;****************************************************************************
 
 (defun levin-value (levin slot)
-  (cffi:foreign-slot-value (mpointer levin) 'levin-c slot))
+  (cffi:foreign-slot-value (mpointer levin) '(:struct levin-c) slot))
 
 (defmobject levin "gsl_sum_levin_u"
   ((order sizet))
diff --git a/solve-minimize-fit/minimization-multi.lisp b/solve-minimize-fit/minimization-multi.lisp
index f2c2d78b5364ea170dbe2f87977f38db1b2e6abe..90f984e56d4d6d1f57f519c8760f51859edc5172 100644
--- a/solve-minimize-fit/minimization-multi.lisp
+++ b/solve-minimize-fit/minimization-multi.lisp
@@ -1,6 +1,6 @@
 ;; Multivariate minimization.
 ;; Liam Healy  <Tue Jan  8 2008 - 21:28>
-;; Time-stamp: <2011-09-28 13:30:49EDT minimization-multi.lisp>
+;; Time-stamp: <2011-10-30 10:03:24EDT minimization-multi.lisp>
 ;;
 ;; Copyright 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -53,7 +53,7 @@
    of the initial trial steps is given in vector step-size. The
    precise meaning of this parameter depends on the method used."
   :callbacks
-  (callback fnstruct-dimension (dimension)
+  (callback (:struct fnstruct-dimension) (dimension)
 	    (function :double (:input :double :foreign-array dim0) :slug))
   :initialize-suffix "set"
   :initialize-args ;; Could have one fewer argument: dimension=(dim0 initial)
@@ -76,7 +76,7 @@
    function g is orthogonal to the current search direction p to a
    relative accuracy of tolerance, where dot(p,g) < tol |p| |g|."
   :callbacks
-  (callback fnstruct-dimension-fdf (dimension)
+  (callback (:struct fnstruct-dimension-fdf) (dimension)
 	    (function :double (:input :double :foreign-array dim0) :slug)
 	    (df :void
 		(:input :double :foreign-array dim0) :slug
diff --git a/solve-minimize-fit/minimization-one.lisp b/solve-minimize-fit/minimization-one.lisp
index 03812d96c416717faea072f3f321fd1bc8f2f6b3..36860cf2a381c0b43c8befcd2c5438324cdc0154 100644
--- a/solve-minimize-fit/minimization-one.lisp
+++ b/solve-minimize-fit/minimization-one.lisp
@@ -1,8 +1,8 @@
 ;; Univariate minimization
 ;; Liam Healy Tue Jan  8 2008 - 21:02
-;; Time-stamp: <2010-08-07 21:41:13EDT minimization-one.lisp>
+;; Time-stamp: <2011-10-30 10:31:55EDT minimization-one.lisp>
 ;;
-;; Copyright 2008, 2009 Liam M. Healy
+;; Copyright 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -37,7 +37,7 @@
    (x-minimum x-lower x-upper) and optionally 
    function values at those points (f-minimum f-lower f-upper)."
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :initialize-suffix ("set" "set_with_values")
   :initialize-args
   (((callback :pointer) (x-minimum :double)
diff --git a/solve-minimize-fit/nonlinear-least-squares.lisp b/solve-minimize-fit/nonlinear-least-squares.lisp
index 77649fb1faa9b7b9fdf1ad418801bf5fb63e5897..6adcd3413f427a5c50bf201bffb5c078265a7730 100644
--- a/solve-minimize-fit/nonlinear-least-squares.lisp
+++ b/solve-minimize-fit/nonlinear-least-squares.lisp
@@ -1,6 +1,6 @@
 ;; Nonlinear least squares fitting.
 ;; Liam Healy, 2008-02-09 12:59:16EST nonlinear-least-squares.lisp
-;; Time-stamp: <2011-08-17 00:50:45EDT nonlinear-least-squares.lisp>
+;; Time-stamp: <2011-10-30 10:02:12EDT nonlinear-least-squares.lisp>
 ;;
 ;; Copyright 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -37,7 +37,7 @@
   :documentation			; FDL
   "The number of observations must be greater than or equal to parameters."
   :callbacks
-  (callback fnstruct-fit
+  (callback (:struct fnstruct-fit)
 	    (number-of-observations number-of-parameters)
 	    (function
 	     :success-failure
@@ -68,7 +68,7 @@
   "The number of observations must be greater than or
    equal to parameters."
   :callbacks
-  (callback fnstruct-fit-fdf
+  (callback (:struct fnstruct-fit-fdf)
 	    (number-of-observations number-of-parameters)
 	    (function :success-failure
 		      (:input :double :foreign-array dim1)
diff --git a/solve-minimize-fit/roots-multi.lisp b/solve-minimize-fit/roots-multi.lisp
index ae019827cb20c1d2aa9e3f1efb941035a57645ed..84129ae7fc3371a1de12576bb94ccd5f5bb45847 100644
--- a/solve-minimize-fit/roots-multi.lisp
+++ b/solve-minimize-fit/roots-multi.lisp
@@ -1,6 +1,6 @@
 ;;; Multivariate roots.                
 ;;; Liam Healy 2008-01-12 12:49:08
-;;; Time-stamp: <2011-08-16 23:58:35EDT roots-multi.lisp>
+;;; Time-stamp: <2011-10-30 10:02:55EDT roots-multi.lisp>
 ;;
 ;; Copyright 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
@@ -44,7 +44,7 @@
   :initialize-suffix "set"
   :initialize-args ((callback :pointer) ((mpointer initial) :pointer))
   :callbacks
-  (callback fnstruct-dimension (dimension)
+  (callback (:struct fnstruct-dimension) (dimension)
 	    (function
 	     :success-failure
 	     (:input :double :foreign-array dim0) :slug
@@ -71,7 +71,7 @@
   :initialize-suffix "set"
   :initialize-args ((callback :pointer) ((mpointer initial) :pointer))
   :callbacks
-  (callback fnstruct-dimension-fdf (dimension)
+  (callback (:struct fnstruct-dimension-fdf) (dimension)
 	    (function :success-failure
 		      (:input :double :foreign-array dim0)
 		      :slug
@@ -206,7 +206,7 @@
 ;;; to discriminate on mfsolver vs. mfdfsolver.
 
 (defun multiroot-slot (solver slot)
-  (cffi:foreign-slot-value (mpointer solver) 'gsl-multiroot-fsolver slot))
+  (cffi:foreign-slot-value (mpointer solver) '(:struct gsl-multiroot-fsolver) slot))
 
 (defmfun multiroot-test-delta (solver absolute-error relative-error)
   "gsl_multiroot_test_delta"
diff --git a/solve-minimize-fit/roots-one.lisp b/solve-minimize-fit/roots-one.lisp
index 8774769689842f3c89a0c5d47151bd0e20a25438..2660fc4e46d976e79c5dd56a98ba4109516bf81c 100644
--- a/solve-minimize-fit/roots-one.lisp
+++ b/solve-minimize-fit/roots-one.lisp
@@ -1,8 +1,8 @@
 ;; One-dimensional root solver.
 ;; Liam Healy 
-;; Time-stamp: <2009-12-27 10:05:31EST roots-one.lisp>
+;; Time-stamp: <2011-10-30 10:34:42EDT roots-one.lisp>
 ;;
-;; Copyright 2009 Liam M. Healy
+;; Copyright 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -32,7 +32,7 @@
   :initialize-suffix "set"
   :initialize-args ((callback :pointer) (lower :double) (upper :double))
   :callbacks
-  (callback fnstruct nil (function :double (:input :double) :slug))
+  (callback (:struct fnstruct) nil (function :double (:input :double) :slug))
   :singular (function))
 
 (defmobject one-dimensional-root-solver-fdf "gsl_root_fdfsolver"
@@ -41,7 +41,7 @@
   :initialize-suffix "set"
   :initialize-args ((callback :pointer) (root-guess :double))
   :callbacks
-  (callback fnstruct-fdf nil
+  (callback (:struct fnstruct-fdf) nil
 	    (function :double (:input :double) :slug)
 	    (df :double (:input :double) :slug)
 	    (fdf :void (:input :double) :slug
diff --git a/solve-minimize-fit/simulated-annealing.lisp b/solve-minimize-fit/simulated-annealing.lisp
index cd195ebf9a528be06f992a01d28a8e90688e358e..31396b38be4a5e8b559dfc6e700dea4ad17a53ac 100644
--- a/solve-minimize-fit/simulated-annealing.lisp
+++ b/solve-minimize-fit/simulated-annealing.lisp
@@ -1,8 +1,8 @@
 ;; Simulated Annealing
 ;; Liam Healy Sun Feb 11 2007 - 17:23
-;; Time-stamp: <2011-10-23 22:15:00EDT simulated-annealing.lisp>
+;; Time-stamp: <2011-10-30 09:40:23EDT simulated-annealing.lisp>
 ;;
-;; Copyright 2007, 2008, 2009 Liam M. Healy
+;; Copyright 2007, 2008, 2009, 2011 Liam M. Healy
 ;; Distributed under the terms of the GNU General Public License
 ;;
 ;; This program is free software: you can redistribute it and/or modify
@@ -160,7 +160,13 @@
     (setf cl-generator generator)
     (let ((x0-p (make-new-sa-state state-values)))
       (simulated-annealing-int
-       (list n-tries iterations-fixed-T step-size k t-initial mu-t t-min)
+       (list 'n-tries n-tries
+	     'iterations-fixed-T iterations-fixed-T
+	     'step-size step-size
+	     'k k
+	     't-initial t-initial
+	     'mu-t mu-t
+	     't-min t-min)
        generator
        x0-p
        'sa-energy-function