lfex/los

LFE Object System

LFE Object System

Introduction

LOS is inspired by CLOS. It may or may not provide macros for more than one object system. We shall see.

When referring to the plural form, we recommend the Spanish "los LOS". In the singular form, "el LOS", "the LOS" or just "LOS" are all acceptable. LFE LOS may have been named after the definite article, or the town in Sweden, or the crater on Mars.

Feel free to also make "loss" puns. These will be quite amusing for all, and apropos.

More seriously, the initial implementation will be taken from Peter Norvig's PAIP, Chapter 13 as well as ideas implemented in Clojure.

Why OOP?

Blame it on cadar; he made me do it. But before that, there was this, so I guess it can't all be laid at his feet.

Peter Norvig said it best (especially when we take it out of context):

"Object-oriented programming turns the world of computing on its side..."

And now that we've got a doubly-functional programming language (Lisp + Erlang), we're going to turn it over on its other side.

The reason this project is blamed on cadar is that he made a very good argument that 1) there are definitely valid use cases for OOP (or AOP), and 2) we should offer people that flexibility.

Features

Development Plan

First, we're going to start with a simple knock-off of CLOS as developed by Peter Norvig in PAIP, Chapter 13. This will be done using classic lambda closures. Next, we'll look at using processes instead of lambdas for closures. This is defnitely the more Erlang-y way to do it, but it may be more inefficient for many uses. Then, we may look at Clojure's protocols and add support for that. After this, the sky's the limit. Or maybe not. Who knows?

lambda Closures

• defclass -

Dependencies

This project assumes that you have rebar and lfetool installed somewhere in your $PATH.

Installation

Just add it to your rebar.config deps:

    {deps, [
        ...
        {los, ".*", {git, "[email protected]:lfex/los.git", "master"}}
      ]}.

And then do the usual for your lfetool-created project:

    $ rebar compile

This will automatically download the project deps and compile them before also compiling LOS.

Usage

To be done ...

References

• The Common Lisp Object System MetaObject Protocol
• Object Reorientation: Classes
• Fundamentals of CLOS
• A Brief Guide to CLOS
• Polymorphism in Clojure: Protocols and Multimethods

los's Issues

Implement a basic object system

Create defclass macro

This should be based on the example from Chapter 13, Section 4 of Peter Norvig's PAIP.

Discussion on polymorphism idioms in LFE

There was a blog post written about this topic here:

• http://blog.lfe.io/design/2015/07/11/1720-towards-multi-methods-in-lfe/

Code for exploring polymorphism continues to grow/adapt here:

• https://github.com/lfex/los/blob/master/examples/no-macros/polymorph.lfe

This issue was opened in particular due to a tantalizing comment made by @rvirding on the LFE mail list -- he may have some nice ideas for better LFE idioms:

• https://groups.google.com/d/msg/lisp-flavoured-erlang/nvAAOwE62n8/KEiZH7HbBAAJ

Add unit tests/examples for inheritance support

Add implementation for Clojure-like multi-methods

Usage should be something like this:

> (include-lib "los/include/multi-methods.lfe")
> (defmulti area 'type)
> (defmethod area 'rectangle
       ((`(#(length ,l) #(width ,w)))
         (* l w)))
> (area '(#(type triangle) #(base 2) #(height 4)))
  4.0

A non-macro version of this could be done in the following manner:

(defmodule polymorph
  (export all))

(defun area
  ((`(,type . ,rest))
   (dispatch 'area type rest)))

(defun dispatch
  ((fname `#(type ,type) args)
   (call (MODULE) (list_to_atom (++ (atom_to_list fname)
                                    "-"
                                    (atom_to_list type))) args)))

(defun area-triangle
  ((`(#(base ,b) #(height ,h)))
   (* b h (/ 1 2))))

(defun area-rectangle
  ((`(#(length ,l) #(width ,w)))
   (* l w)))

These could then be used in the following manner:

(c "examples/no-macros/polymorph.lfe")
#(module polymorph)
(slurp "examples/no-macros/polymorph.lfe")
#(module polymorph)
> (area '(#(type triangle) #(base 2) #(height 4)))
4.0
> (area '(#(type rectangle) #(length 2) #(width 4)))
8

Additional implementations could be added with ease:

(defun area-square
  ((`(#(side ,s)))
   (* s s)))

(defun area-circle
  ((`(#(radius ,r)))
   (* (math:pi) r r)))

Then use them:

> (area '(#(type square) #(side 2)))
  4
> (area '(#(type circle) #(radius 2)))
  12.566370614359172

See the following:

• https://github.com/clojure/clojure/blob/bdc752a7fefff5e63e0847836ae5e6d95f971c37/src/clj/clojure/core.clj#L1612

Add inheritance support

This is from section 6 of the same chapter as in issue #3.

Add unit tests/examples for defclass macro

Copy OOP Examples from LFE to LOS

There should be 3 files in lfe/examples that we should move here.

As progress is made on LOS, those examples will be updated to utilize LOS and its growing features.