Temporary Files And Directories in Lisp

In Lisp, we can create temporary files and directories using functions from the uiop system, which is part of ASDF (Another System Definition Facility). This system provides cross-implementation portable filesystem operations.

(defpackage :temp-files-and-dirs
  (:use :cl :uiop))

(in-package :temp-files-and-dirs)

(defun check (condition)
  (when condition
    (error condition)))

(defun main ()
  ;; Create a temporary file
  (multiple-value-bind (stream filename)
      (uiop:with-temporary-file (:prefix "sample" :want-stream-p t)
        ;; Display the name of the temporary file
        (format t "Temp file name: ~A~%" filename)
        
        ;; Write some data to the file
        (write-sequence #(1 2 3 4) stream)
        
        (values stream filename))
    
    ;; The file will be automatically deleted when the stream is closed
    (close stream))
  
  ;; Create a temporary directory
  (let ((temp-dir (uiop:ensure-directory-pathname
                   (uiop:with-temporary-file (:prefix "sampledir" :type "d")))))
    (format t "Temp dir name: ~A~%" temp-dir)
    
    ;; Create a file in the temporary directory
    (let ((file-path (merge-pathnames "file1" temp-dir)))
      (with-open-file (stream file-path :direction :output 
                                        :element-type '(unsigned-byte 8))
        (write-sequence #(1 2) stream)))
    
    ;; The directory and its contents will be automatically deleted
    ;; when it goes out of scope
    ))

(main)

In this Lisp version:

1. We use the uiop:with-temporary-file function to create temporary files and directories. This function automatically handles cleanup when the file or directory goes out of scope.

2. For writing to files, we use write-sequence instead of a specific Write method.

3. Instead of os.MkdirTemp, we use uiop:with-temporary-file with :type "d" to create a temporary directory.

4. We use merge-pathnames to join directory and file names, which is similar to filepath.Join in the original code.

5. Error handling is simplified. In a more robust implementation, you might want to use condition handling (Lisp’s exception system) for better error management.

To run this program, save it as temp-files-and-dirs.lisp and execute it using your Lisp implementation. For example, with SBCL:

$ sbcl --script temp-files-and-dirs.lisp
Temp file name: /tmp/sample1234567890
Temp dir name: /tmp/sampledir1234567890/

Note that the exact output will vary depending on your system and the specific temporary names generated.

This Lisp version provides similar functionality to the original code, creating temporary files and directories that are automatically cleaned up after use.