Xml in Lisp

(defpackage :xml-example
  (:use :cl :cl-xml)
  (:export :main))

(in-package :xml-example)

(defclass plant ()
  ((id :initarg :id :accessor plant-id)
   (name :initarg :name :accessor plant-name)
   (origin :initarg :origin :accessor plant-origin))
  (:documentation "Plant will be mapped to XML."))

(defmethod print-object ((obj plant) stream)
  (print-unreadable-object (obj stream :type t)
    (format stream "id=~a, name=~a, origin=~a"
            (plant-id obj)
            (plant-name obj)
            (plant-origin obj))))

(defun main ()
  (let ((coffee (make-instance 'plant
                               :id 27
                               :name "Coffee"
                               :origin '("Ethiopia" "Brazil"))))
    ;; Emit XML representing our plant
    (let ((xml-string (with-output-to-string (s)
                        (encode coffee s))))
      (format t "~a~%" xml-string)
      
      ;; To add a generic XML header to the output, prepend it explicitly
      (format t "<?xml version=\"1.0\" encoding=\"UTF-8\"?>~%~a~%" xml-string)
      
      ;; Use parse to convert XML string back into a plant object
      (let ((parsed-plant (parse xml-string)))
        (format t "~a~%" parsed-plant)))
    
    (let ((tomato (make-instance 'plant
                                 :id 81
                                 :name "Tomato"
                                 :origin '("Mexico" "California"))))
      
      ;; Create a nested structure
      (let ((nesting `(nesting
                       (parent
                        (child
                         ,(encode coffee)
                         ,(encode tomato))))))
        (let ((nested-xml (with-output-to-string (s)
                            (encode nesting s))))
          (format t "~a~%" nested-xml))))))

This Lisp code demonstrates XML handling using a hypothetical cl-xml package. Here’s a breakdown of the translation:

We define a plant class to represent the XML structure.
The print-object method is defined to provide a string representation of plant objects.
In the main function, we create coffee and tomato instances.
We use a hypothetical encode function to convert objects to XML strings.
For parsing, we use a hypothetical parse function to convert XML strings back to objects.
To demonstrate nesting, we create a nested structure and encode it to XML.

Note that Lisp doesn’t have built-in XML support like Go does, so we’re using a hypothetical cl-xml package. In a real Lisp project, you’d need to choose and install an appropriate XML library.

Also, Lisp’s natural list structure makes it easy to represent nested XML-like structures, as shown in the nesting example.

To run this program, you would save it in a file (e.g., xml-example.lisp), ensure you have a Lisp implementation and the necessary XML library installed, then load and run the file in your Lisp environment.

Json in Lisp

Time in Lisp

Learn X By Example

Title here

Xml in Lisp