Adztec Independent - Blog » lisp

Clojure

Christopher — Sat, 24 Jan 2009 00:56:55 +0000

I’ve been trying out Clojure lately. Clojure is a new lisp dialect, that is hosted on the JVM and interoperates nicely with it. You can easily use Java methods, classes and libraries. I’ve been using it a little bit, watching some videos about it on blip.tv by it’s author, Rich Hickey, which really is a brilliant guy. You should check them out as well, they give you a pretty good introduction to the language.

Compared to Common Lisp, which I really like allot as well, Clojure does feel a little bit more modern. For example, being not limited to reader support for lists, but also having maps and vectors (like arrays) as first class citizens, is really nice. And then theres the huge emphasis on multithreading support in a really nice way without locks and condition variables but with a stm (software transactional memory). Clojure is a functional language and focuses on immutability of data structures compared to Common Lisp, which also allows a more imperative style, if you want to. In Clojure, you’re forced to a functional style, which might seem like a downside at first, but which makes it possible to have some pretty neat features concerning multithreaded programming support. Since all the datastructures are immutable, there’s no need do use locks when having multiple threads sharing them. I suggest checking out the videos and to give Clojure a try. It seems very promising and it’s having quite a publicity boost right now. Just google for it, take a look on some mailinglists or checkout reddit etc. You’ll find plenty comments, links and blogposts about it (like this one ).

So since I thought it’s always nice to try to port an existing little application from a language I already know to a new one I want to learn, I tried to port a very small programm CallToPower, a collegue from university, wrote and posted on his website. I pretty much copied it straightly to Clojure, changing some parts.

Now I know this might not be the best way to write it in Clojure. But it was my real first (although very small) programm in Clojure and I wanted to make it as close to the original, as possible. Basically, what it does is display some values of some system properties you can choose by pressing the appropriate. Nothing fancy, but it shows some Clojure related stuff pretty well.

So here’s the code, use it as you like:

^?View Code LISP

(ns sysinfo
  (:gen-class)
  (:import (java.awt BorderLayout
		     GridLayout)
	   (java.awt.event ActionEvent
			   ActionListener)
	   (javax.swing JFrame
			JPanel
			JLabel
			JButton)))
 
(def *x-coord* 30)
(def *y-coord* 30)
(def *width* 800)
(def *height* 230)
(def *prog-name* "SysInfo 1.0 [Clojure]")
(def *visible* true)
(def *resizable* true)
(def *frame* nil)
 
(def *label-property-mappings*
     { "OS Name" "os.name",
       "OS Architecture" "os.arch",
       "Java Classpath" "java.class.path",
       "Java Version" "java.version",
       "Current working directory" "user.dir",
       "Resize to default" "Resize to default",
       "Clear" " "})
 
(defn resize-frame
  [frame a b awidth bheight]
  (doto frame
    (.setBounds a b awidth bheight)))
 
 
(defn set-label-text [label text]
  (doto label
    (.setText text)))
 
(defn button-listener
  "Returns a ActionListener, which sets the text of the content label (label-content)
  to the appropriate system property (System.getProperty)."
  [property label frame]
  (proxy [ActionListener] []
    (actionPerformed [evt]
		     (let [system-property-value (. System getProperty property)]
		       (if (not (.equalsIgnoreCase property "Resize to default"))
			 (if (not (.equalsIgnoreCase property " "))
			   (set-label-text label (str (.getActionCommand evt) ": \n" system-property-value))
			   (set-label-text label property))
			 (resize-frame frame *x-coord* *y-coord* *width* *height*))))))
 
 
(defmacro doto-each
  "Macro, that works like doto-macro, only that it does it for each object in objects.
  varname is bound to each object in turn inside of the body (forms) and can be used to access the current
  object, if needed."
  [[varname [& objects]] & forms]
  `(do
     ~@(map (fn [f] `(let [~varname ~f]
		       (doto ~f
			 ~@forms)))
	    objects)))
 
(defmacro add-each
  "Macro, that calls .add on to-object with each object in objects."
  [to-object [& objects]]
  `(do
     ~@(map (fn [o] `(.add ~to-object ~o))
	    objects)))
 
(defn create-new-sysinfo-window
  "Creates the main form and returns it. Mainly GUI-related stuff (javax.swing)."
  []
  (let [frame (JFrame. "Adztec-Independent.de: SysInfo Clojure-style!")
	panel-header (JPanel.)
	panel-main (JPanel. (BorderLayout.))
	panel-left (JPanel. (GridLayout. 6 1))
	panel-south (JPanel. (GridLayout. 1 1))
	;; labels
	label-header (JLabel. "System Information")
	label-blank (JLabel. " ")
	label-content (JLabel. " ")
	label-adztec-indep (JLabel. "by www.adztec-independent.de")]
 
    (.setHorizontalAlignment label-blank (JLabel/CENTER))
    (.setHorizontalAlignment label-adztec-indep (JLabel/CENTER))
 
    ;; buttons
    (let [btn-java-cp (JButton. "Java Classpath")
	  btn-java-version (JButton. "Java Version")
	  btn-os-name (JButton. "OS Name")
	  btn-os-arch (JButton. "OS Architecture")
	  btn-current-working-dir (JButton. "Current working directory")
	  btn-resize-to-default (JButton. "Resize to default")
	  btn-clear-all (JButton. "Clear")]
      (do
	;; add button-listener to all buttons
	(doto-each  [btn [btn-java-cp
			  btn-java-version
			  btn-os-name
			  btn-os-arch
			  btn-current-working-dir
			  btn-resize-to-default
			  btn-clear-all]]
 
		      ;; add listener to button
		    (.addActionListener
		     (button-listener (get *label-property-mappings* (.getText btn)) label-content frame))))
 
	;; add buttons to panel
	(add-each panel-left
		  [btn-java-cp
		   btn-java-version
		   btn-os-name
		   btn-os-arch
		   btn-current-working-dir])
	(add-each panel-south
		  [btn-resize-to-default
		   btn-clear-all])
 
	;; add labels to panel
	(add-each panel-header
		  [label-header
		   label-blank])
	(.add panel-south label-adztec-indep)
 
	;; pack on frame
	(let [content-pane (.getContentPane frame)]
	  (add-each content-pane
		    [panel-main
		     label-content])
	  (doto content-pane
	    (.add BorderLayout/NORTH panel-header)
	    (.add BorderLayout/WEST panel-left)
	    (.add BorderLayout/SOUTH panel-south)))
	(doto frame
	  (.pack)
	  (.setTitle *prog-name*)
	  (resize-frame *x-coord* *y-coord* *width* *height*)
	  (.setVisible *visible*)
	  (.setResizable *resizable*)
	  (.setDefaultCloseOperation JFrame/HIDE_ON_CLOSE)))
    frame)) ;; return frame
 
 
(defn -main
  "Main function. Gets called by the system, if used as an executable .jar file."
  []
  (let [*frame* (create-new-sysinfo-window)]
       (. Thread (sleep 100))))

Lisp macros revisited

Christopher — Tue, 16 Dec 2008 10:56:14 +0000

Since my first posts on my own little control macros (while, foreach etc.) I’ve learned quite a bit and so here are my revised versions of some of them, since not all of them would work outside of an interpreter, since they were recursive macros.
A better, and also non recursive way to write macros is to either use exisiting macros (as done with my for macro) or for example by using the tagbody & go constructs of lisp (similar to a goto in C):

new while macro

^?View Code LISP

;; while macro with tagbody & go.
(defmacro while-new (condition &body body)
  (let ((tag-name (gensym)))
    `(tagbody
      ,tag-name
      ,@body
      (when ,condition
	(go ,tag-name)))))

Thanks again to the anonymous commenter ‘foo’, who made it clear, that the previous version (without gensymed-symbols) could make trouble in the case of a caller having symbols defined with the same name (in this case tag-name).

I also changed the foreach-macro to use gensymed symbols:

new foreach macro

^?View Code LISP

;; foreach macro with tagbody & go.
(defmacro foreach-new ((var list) &body body)
  (let ((tmp-list (gensym)) (start-tag (gensym)))
    `(let* ((,tmp-list ,list) (,var nil) (rest (cdr ,tmp-list)))
       (tagbody
	  ,start-tag
	  (if (null ,tmp-list)
	      nil
	      (progn
		(setf ,var (car ,tmp-list))
		(setf rest (cdr ,tmp-list))
		(if ,var
		  (progn ,@body
			 (setf ,tmp-list rest)
			 (go ,start-tag))
		  nil)))))))

new until macro

^?View Code LISP

;; until macro reusing new while macro.
(defmacro until-new (cond &body body)
  `(while-new (not ,cond)
     ,@body))

Also, thanks to ‘foo’, who pointed this out in some comments.
I’ve known about this fact for little while already, but haven’t thought about posting it here. Since some people might be reading this and wondering, why they don’t seem to work, they now should have some working samples.

Lisp labels and anonymous functions

Christopher — Tue, 16 Dec 2008 02:08:20 +0000

I was playing around with Lisp some more in the last few weeks, and today i came across a little problem with anonymous functions (or lambdas, if you want to).

The problem with anonymous lambda functions is, that they can’t call themselves recursively, since – well they’re anonymous and hence don’t have a name. To get passed this problem, you can let it have an additional function parameter which it will call in place where the recursion would normally take place.

An example for a reverse function, which reverses the elements of its argument (a list) with the help of an accumulator list (which holds the reversed list) could be written like this, without using an additional function:

^?View Code LISP

(defun myreverse (list &optional (acc nil))
  (let ((head (car list)) (rest (cdr list)))
    (cond
      (head
       (cond
	 ((atom head)
	  (myreverse rest (cons head acc)))
	 (t
	  (myreverse rest (cons (myreverse head) acc)))))
      (t
       acc))))

But, as you can see, the accumulator list is part of the function’s argument list, although optional. To make this function a little bit ’safer’, it shouldn’t be part of the ‘public interface’ of the function. So you’d probably come up with something like this, where you’d use an anonymous helper function, which takes the additional accumulator list and returns it when it’s done reversing the original list:

^?View Code LISP

(defun myreverse (list)
  (let ((reverse-acc #'(lambda (func list acc)
			(let ((head (car list)) (rest (cdr list)))
			  (cond (head
				 (cond ((atom head)
					(funcall func func rest (cons head acc)))
				       (t
					(funcall func func rest (cons (funcall func func head nil) acc)))))
				(t
				 acc))))))
    (funcall reverse-acc reverse-acc list nil)))

But, as you can see, since anonymous functions can’t call themselves recursively, you need to give it another extra parameter, a function object, which actually gets filled with the anonymous function itself, so it can call itself inside its body. But, fortunately, theres an even better version how to do exactly this in lisp: With the labels special operator, which defines local functions with a given name (like normal functions) which can then get called inside the function body itself and in the body-form of the macro:

^?View Code LISP

(defun myreverse (list)
  (labels ((myreverse-acc (list acc)
	     (let ((head (car list)) (rest (cdr list)))
	       (cond (head
		      (cond ((atom head)
			     (myreverse-acc rest (cons head acc)))
			    (t
			     (myreverse-acc rest (cons (myreverse-acc head nil) acc)))))
		     (t
		      acc)))))
    (myreverse-acc list nil)))

As you can see, this version is nicer than the first or the second, since it hides the fact, that the reverse function uses an accumulator list and that it is also easier to understand, since you can use an actual name for the function instead of passing the function as an argument to itself, in ordner to make a recursive call. So basically, you can think of a function defined with the labels special operator as a local defun, which I think is really nice.

Language creation

Christopher — Tue, 02 Dec 2008 21:41:38 +0000

I recently started thinking about creating a programming language from scratch, but obviously heavily inspired by existing programming languages out there.

I don’t have anything concrete yet but these are the main principles I came up with for the language:

Somewhat functional (but not purely functional). So side-effects should be more or less easily possible within non side-effecting code. Mainly for reasons regarding the process of actually building the compiler / interpreter and that it should be a dynamic language. Especially the last point makes it pretty obvious that since there is no static typechecking, making it purely functional would be kind of hard to realise (although possible i guess).
Garbage-collected / automatic memory management. Kind of makes sense with a functional language and who really wants another assembly-like, low-level language?
An easy way to extend the language in itself (as in Lisp, for example, with macros or some similar meta-programming capability).
Dynamically typed (like Lisp or Ruby for example)
Small, in the sense that the language itself should not be bloated and most of the value of it shouldn’t be part of the language itself, but implemented in it. By that I don’t only mean the standard library, where this usually is the case already, but also those things, often considered part of the language (or “built-in”) in other languages. Haskell is a good example of operators and data types not being tied completely into the language, but rather implemented in it. A good example is the Boolean data type, which is merely defined in Haskell itself (and if it hadn’t been, it would be trivial to come up with your own). This works because Haskell uses some very nice pattern matching with its algebraic datatypes and I could imagine something similar for my language.

That are my main concerns this far. Obviously theres still much to decide, mainly syntax and semantics. Compelling are Haskell’s typesystem with its really powerful, yet simple datatypes and pattern matching. On the other hand there’s Lisp with its macros and Ruby with its also powerful meta-programming mechanisms.

Let’s see, where this will go