我从Practical Common Lisp学习Common Lisp。它有一个辅助函数的例子,用于在第24章中读取和写入二进制文件。这里有一个例子:
(defun read-u2 (in)
(+ (* (read-byte in) 256) (read-byte in)))
我也可以编写用于读取其他类型二进制数的函数。但我认为这样做违反了DRY原则。此外,这些函数将是类似的,所以我尝试用宏生成函数。
(defmacro make-read (n be)
`(defun ,(intern (format nil "READ~d~:[L~;B~]E" n be))
(&optional (stream *standard-input*))
(logior ,@(loop for i from 0 below n collect
`(ash (read-byte stream)
,(* 8 (if be (- n 1 i) i)))))))
(defmacro make-read-s (n be)
`(defun ,(intern (format nil "READ~d~:[L~;B~]E-S" n be))
(&optional (stream *standard-input*))
(let ((a (,(intern (format nil "READ~d~:[L~;B~]E" n be)) stream)))
(if (zerop (logand a ,(ash 1 (1- (* 8 n)))))
a
(logior a ,(ash -1 (* 8 n)))))))
(defmacro make-write (n be)
`(defun ,(intern (format nil "WRITE~d~:[L~;B~]E" n be))
(n &optional (stream *standard-output*))
(setf n (logand n ,(1- (ash 1 (* 8 n)))))
,@(loop for i from 0 below n collect
`(write-byte (ldb (byte 8 ,(* 8 (if be (- n 1 i) i))) n)
stream))))
(eval-when (:compile-toplevel :load-toplevel :execute)
(dolist (cat '("READ" "READ-S" "WRITE"))
(dolist (be '(nil t))
(dolist (n '(1 2 4 8))
(eval `(,(intern (format nil "MAKE-~a" cat)) ,n ,be))))))
有效。它生成用于读取和写入大小为1,2,4和8的无符号和有符号整数的函数.SLIME理解它。但我想知道是否有更好的方法。
在Common Lisp中编写一堆类似函数的最佳方法是什么?
答案 0 :(得分:9)
此代码存在一些问题,尽管使用宏生成函数的一般方法很好。
<强>命名强>
宏不应该命名为make-...
,因为它们不是创建某些东西的函数,而是定义函数的宏。
代码生成
EVAL-WHEN ... EVAL
代码非常糟糕,不应该以这种方式使用。
更好的方法是使用函数定义编写扩展为progn
的宏。
如果我想使用EVAL
,那么我不需要编写代码生成宏,而只需编写代码生成函数。但是我不想使用EVAL
,我想直接为编译器创建代码。如果我有代码生成宏,那么我不需要EVAL
。
EVAL
不是一个好主意,因为不清楚代码是否会被编译 - 这将取决于实现。评估也将在编译时和加载时进行。最好在编译时编译函数,只在加载时加载它们。文件编译器也可能错过对已评估函数的可能优化。
(defmacro def-read-fun (n be)
`(defun ,(intern (format nil "READ~d~:[L~;B~]E" n be))
(&optional (stream *standard-input*))
(logior ,@(loop for i from 0 below n collect
`(ash (read-byte stream)
,(* 8 (if be (- n 1 i) i)))))))
(defmacro def-read-s-fun (n be)
`(defun ,(intern (format nil "READ~d~:[L~;B~]E-S" n be))
(&optional (stream *standard-input*))
(let ((a (,(intern (format nil "READ~d~:[L~;B~]E" n be)) stream)))
(if (zerop (logand a ,(ash 1 (1- (* 8 n)))))
a
(logior a ,(ash -1 (* 8 n)) )))))
(defmacro def-write-fun (n be)
`(defun ,(intern (format nil "WRITE~d~:[L~;B~]E" n be))
(n &optional (stream *standard-output*))
(setf n (logand n ,(1- (ash 1 (* 8 n)))))
,@(loop for i from 0 below n collect
`(write-byte (ldb (byte 8 ,(* 8 (if be (- n 1 i) i))) n)
stream))))
我们定义另一个宏而不是EVAL-WHEN ... EVAL
,然后我们稍后再使用它:
(defmacro def-reader/writer-functions (cat-list be-list n-list)
`(progn
,@(loop for cat in cat-list append
(loop for be in be-list append
(loop for n in n-list
collect `(,(intern (format nil "DEF-~a-FUN" cat))
,n
,be))))))
现在我们可以使用上面的宏来生成所有函数:
(def-reader/writer-functions
("READ" "READ-S" "WRITE")
(nil t)
(1 2 4 8))
你可以在这里看到扩展:
CL-USER 173 > (pprint (macroexpand-1 '(def-reader/writer-functions
("READ" "READ-S" "WRITE")
(nil t)
(1 2 4 8))))
(PROGN
(DEF-READ-FUN 1 NIL)
(DEF-READ-FUN 2 NIL)
(DEF-READ-FUN 4 NIL)
(DEF-READ-FUN 8 NIL)
(DEF-READ-FUN 1 T)
(DEF-READ-FUN 2 T)
(DEF-READ-FUN 4 T)
(DEF-READ-FUN 8 T)
(DEF-READ-S-FUN 1 NIL)
(DEF-READ-S-FUN 2 NIL)
(DEF-READ-S-FUN 4 NIL)
(DEF-READ-S-FUN 8 NIL)
(DEF-READ-S-FUN 1 T)
(DEF-READ-S-FUN 2 T)
(DEF-READ-S-FUN 4 T)
(DEF-READ-S-FUN 8 T)
(DEF-WRITE-FUN 1 NIL)
(DEF-WRITE-FUN 2 NIL)
(DEF-WRITE-FUN 4 NIL)
(DEF-WRITE-FUN 8 NIL)
(DEF-WRITE-FUN 1 T)
(DEF-WRITE-FUN 2 T)
(DEF-WRITE-FUN 4 T)
(DEF-WRITE-FUN 8 T))
然后将每个子表单扩展为函数定义。
这样编译器就可以运行宏来在编译时生成所有代码,然后编译器就可以为所有函数生成代码。
效率/默认值
在最低级别的功能中,我可能不想使用&optional
参数。默认调用将从动态绑定中获取值,更糟糕的是,*standard-input*
/ *standard-output*
可能不是READ-BYTE
或WRITE-BYTE
工作的流。不是在每个实现中都可以使用标准输入/输出流作为二进制流。
LispWorks:
CL-USER 1 > (write-byte 13 *standard-output*)
Error: STREAM:STREAM-WRITE-BYTE is not implemented for this stream type: #<SYSTEM::TERMINAL-STREAM 40E01D110B>
1 (abort) Return to level 0.
2 Restart top-level loop.
我也可能想要声明所有生成的函数都是内联的。
类型声明是另一件需要考虑的事情。
Summmary :不要使用EVAL。
答案 1 :(得分:2)
通常,我更愿意将要读取的字节数添加为函数的另一个参数:
(defun read-integer (stream bytes)
(check-type bytes (integer 1 *))
(loop :repeat bytes
:for b := (read-byte stream)
:for n := b :then (+ (* n 256) b)
:finally (return n)))
可以添加签名和字节顺序作为关键字参数。这种编程方式适用于易于理解的代码,也可以通过SLIME等工具轻松导航。
通过宏展开这是一种有效的优化策略,我推迟到Rainer's answer。
在从流中读取数字的特定情况下,从一开始就优化可能是一个有效的目标,因为这会在紧密循环中被大量使用。
但是,如果这样做,您还应该彻底记录生成的内容。如果代码的读者看到了运算符read8bes
,他就无法轻易找到它的定义位置。你需要帮助他。