Unifying dynamic and static types with LFE

In my last post I described how to use LFE to overcome some of the weaknesses of parameterized modules. Unfortunately, all is not rosy yet in the land of LFE types. Parameterized modules allow you to create only static types. The compiler doesn't do static type checking, but you have to define the properties of your types at compile time. This works in many cases, but sometimes you want totally dynamic containers that map keys to values. In Erlang, this is typically done with dicts. We could still use them with LFE, but I don't like having different methods of accessing the properties of objects depending on whether their types were defined at run time or compile time.

Let's use macros to solve the problem.

In my last post, I relied on the build-in 'call' function to access the properties of static objects. Let's create a wrapper to 'call' that lets us access the properties of dicts in exactly the same manner as we do properties of other objects:

	(defmacro dot
	((obj prop . tl)
	`(let ((obj ,obj))
	(case (element 1 obj)
	('dict
	,(case tl
	(()
	`(case (: dict find ,prop obj)
	('error 'undefined)
	((tuple 'ok valx) valx)))
	(_ `(: dict store ,prop ,(hd tl) obj))))
	(_ (call obj ,prop ,@tl))))))

view raw gistfile1.lisp hosted with ❤ by GitHub

We can use 'dot' to get and set the properties of both dicts and static objects:

	(defun test ()
	(let* ((dog1 (: dog new))
	(dog2 (: dict new))
	(dog1_2 (dot dog1 'name 'lola))
	(dog2_2 (dot dog2 'name 'rocky)))
	(list (dot dog1_2 'name)
	(dot dog2_2 'name))))

view raw gistfile1.lisp hosted with ❤ by GitHub


> (: dog test)
(lola rocky)

I think this is kinda of cool, though to be honest I'm not entirely sure it's a great idea to obfuscate in the code whether we're dealing with dicts or static objects.