structure-ext

# Tested.
* SBCL/2.1.7
* CCL/1.12.1
* CLISP/2.49
* ECL/21.2.1
* Allegro/10.1
* CMUCL/21D
* ABCL/1.8.0


structure-ext.as-class

structure-ext.left-arrow-accessors

structure-ext.make-instance

closer-mop

lambda-fiddle

resignal-bind

uiop

# STRUCTURE-EXT.AS-CLASS 0.0.6

## Current lisp world
Common Lisp has strong structure and class.

## Issues
In Common Lisp comunity, subject 'structure vs class' is issued sometimes.

Only structure can do is nothing.
Only class can do is Multiple inheritance. 

NOTE - Here, we ignores the thing which can not do but there is a way.
E.g. class is unreadable, but we can write reader macro.
E.g. structure does not have shared slot, but we can emulate it with symbol-plist.

So roughly, we can say 'if you need multiple inheritance, use class. otherwise structure. Because structure is fast.'

```Lisp
(defstruct foo slot)
(defclass bar () ((slot :initarg :slot :accessor bar-slot)))

;; constructor
(time (dotimes (x 1000) (make-foo :slot 0)))
=> 299,098 processor cycles
   16,376 bytes consed
(time (dotimes (x 1000) (make-instance 'bar :slot 0)))
=> 19,777,048 processor cycles
   187,400 bytes consed
;; 66 times faster, 11.5 times less consed.

;; accessor
(let ((s (make-foo :slot 0)))
  (time (dotimes (x 1000) (foo-slot s))))
=> 26,771 processor cycles
(let ((c (make-instance 'bar :slot 0)))
  (time (dotimes (x 1000) (bar-slot c))))
=> 143,488 processor cycles
;; 5.3 times faster.
```

## Proposal
DEFSTRUCT\* is almost same syntax with CL:DEFSTRUCT, but expanded into DEFCLASS and DEFMETHOD forms.
At first, start to write your application with CL:DEFSTRUCT.
If you need multiple inheritance, change CL:DEFSTRUCT to DEFSTRUCT\*, and add super class as :include option.
DEFSTRUCT\* can accept multiple :include options.

## Constraints
### Invalid options
Option :type, :named, and :initial-offset are invalid in DEFSTRUCT\*

### Uncompleteness of copier
The copy function which is made by DEFSTRUCT\* has some constraints.

* Any slots has CL:ERROR initform.
* All slots are not specified :READ-ONLY T.

Because, copier evaluates `CL:MAKE-INSTANCE` without any initargs,
then `CL:SETF` each slots.

## Usage

## From developer

* Product's goal - already?
* License - MIT
### Tested
* SBCL/2.0.2
* CCL/1.12
* CLISP/2.49
* ECL/20.4.24



jingoh

structure-ext.as-class.test

# STRUCTURE-EXT.LEFT-ARROW-ACCESSORS 0.0.6

## introduction
Any language has direction.
In this context, "direction" means order of explain.
For example, English has "from center to around" direction, and Japanese has "from around to center" direction.

E.g. person name.
In English notation, my name is written as 'Shinichi Sato'.
Shinichi is first name (of course center), and Sato is family name (of course around).
But in Japanese notation, my name is written as "佐藤 真一".
"佐藤" equals "Sato", and "真一" equals "Shinichi".

Also day unit.
In English notation, its written "Day Month Year".
It aims from small unit to bigger unit.
But in Japanese notation, its written "年月日".
"年" equals "year", "月" equals "month", and "日" equals "Day".
It aims from big unit to smaller unit.

Also address notations.
In English notation, its written from small place like town to huge place like prefecture, state, etc...
But in Japanese notation, its written from huge place like prefecture to small place like town, street etc...

Of course each language has inversion though.

Also programming language is one kind of language.
In such context, we can refer center as "return value", and around as "algorithm".
Roughly, we can say imperative language has Japanese style "from around to center" direction, and functional language has English style "from center to around" direction.

## Current lisp world
In lisp comunity, functional programming style is recommended.
Language is carefully designed to be able to write functional style easily.
For example, LET's binding is designed "from center to around"(var is center(It is what we want.), and init form is around.), METHOD's specializer is designed so too, WITH-SLOTS's alias is same, etc...

## Issues
But there is few "from around to center" rule in CL.
It is slot accessor or slot accessor style function name like CHAR-CODE.

## Proposal
Using left arrow instead of hyphen is proposed.
Do you think which code is easy to understand?

```lisp
(code-char n)
(char<=code n)
```
I bet it is almost same.
There is just small differences only.
But in many cases, we don't write such low level code as toplevel.
Usually we nests it.
So how below?

```lisp
(defun example1 (symbol)
  (let ((name (package-name (symbol-pakcage symbol))))
    ...))
(defun example2 (symbol)
  (let ((name (name<=package (package<=symbol symbol))))
    ...))
```
In former case, relational part appears alternately.
While reading code from left to right, the stack in your brain acting violently like seesaw but later case.

There is no probrem with class, because we can specify arbitraly name as readers/writers/accessors, but structure.

## Usage

```lisp
(defstruct foo bar)
(DEFINE-LEFT-ARROW-ACCESSORS foo bar)
(bar<=foo (make-foo :bar 0))
=> 0
```

## From developer

* Product's goal - already?
* License - MIT
### Tested
* SBCL/2.0.2
* CCL/1.12
* CLISP/2.49
* ECL/20.4.24


structure-ext.left-arrow-accessors.test

Method make-instance for construct structure.

structure-ext

Upstream URL

Author

License

Tested.

Dependencies (4)

Dependents (1)