Redesigning Common Lisp

Shibuya.lisp Tech Talk #8 Eitaro Fukamachi
Redesigning Common Lisp

I’m Eitaro Fukamachi
@nitro_idiot fukamachi

(and 'web-application-developer
'common-lisper)

GitHub product languages
Others
Clojure
Perl
Emacs Lisp
JavaScript
Common Lisp

Common Lisp is
the most powerful, expressive
and fast language ever.

Common Lisp is damn powerful
• First class functions + lexical closures
• Object system + multiple dispatch
• Metaobject protocol

Common Lisp is expressive
• Reader macros
• Macros

Common Lisp is fast
• (Optional) type declaration
• Inlining functions
• Compiler macros
• Disassembler included
• Free high-performance implementation

Is Common Lisp
attractive to young people?

Common Lisp is
not sophisticated
• too-long-wordy-name-for-common-macros
• append & nconc
• elt vs aref vs nth
• getf vs gethash
• map?? mapc?? dolist?? loop??
• Functional vs Procedual

Portability
8 Goals of
standardising Common Lisp
Commonality
Consistency
Expressiveness
Compatibility
Efficiency
Power
Stability
from Common Lisp the Language

Common Lisp is a compound of
MacLISP, Zetalisp,
Spice Lisp, NIL and S-1 Lisp.

Common Lisp was designed for
MacLISP, Zetalisp,
Spice Lisp, NIL and S-1 Lisp
users, not us.

Common Lisp = 30 years old
Ruby = 19 years old
JavaScript = 19 years old
Clojure = 7 years old

Common Lisp was designed for
people 30 years ago.

But it doesn’t mean
Common Lisp is obsolete.

Common Lisp is the best one,
but I’m still not fulfilled in it.

Let’s redesign Common Lisp
for the 21st century
by ourselves.

“Common Lisp
for the 21st century”

What is CL21?
• (One of) the next generation of
Common Lisp
• Bases on Common Lisp
• Designed for us
• Actual implementation
(not only discussions)

Consistency
Expressiveness
4 Goals of CL21
Compatibility
Efficiency

Consistency of CL21
• Naming convention
• Argument order

Consistency of CL21
Common Lisp
(reverse '(1 2 3))
(nreverse '(1 2 3))
!
(append '(1 2 3) '(a b c))
(nconc '(1 2 3) '(a b c))

Consistency of CL21
CL21
(reverse '(1 2 3))
(nreverse '(1 2 3))
!
(append '(1 2 3) '(a b c))
(nappend '(1 2 3) '(a b c))

Consistency of CL21
Common Lisp
(getf person :name)
(gethash :name person-hash)

Consistency of CL21
CL21
(getf person :name)
(gethash person-hash :name)

Expressiveness of CL21
• Specific vs Generic
• Delete useless symbols

(ed “~/.sbclrc”)

Are you crazy????
(ed “~/.sbclrc”)

Common Lisp
(append '(1 2 3) '(a b c))
(concatenate 'vector #(1 2 3) '())
(concatenate 'string "Hello, " name)

CL21
(append '(1 2 3) '(a b c))
(append #(1 2 3) '())
(append "Hello, " name)

Common Lisp
(mapcar #'1+ '(1 2 3))
(map 'vector #'1+ #(1 2 3))

CL21
(map #'1+ '(1 2 3))
(map #'1+ #(1 2 3))

Common Lisp
(format nil "Hello, World!~%")
(format nil "Hello, ~A~%" name)

CL21
"Hello, World!n"
#"Hello, ${name}n"

Common Lisp
(parse-integer "1984")
(symbol-name 'alien-technology)

CL21
(coerce "1984" 'integer)
(coerce 'alien-technology 'string)

(ql:quickload :cl-ppcre)
(use-package :cl-ppcre)
!
(scan-to-strings "^(d{4})-(d{2})-(d{2})$"
"2014-01-23")
(regex-replace-all "a" "Eitaro Fukamachi" "α"
:preserve-case nil)
Common Lisp

CL21
(use-package :cl21.re)
!
(#/^(d{4})-(d{2})-(d{2})$/ "2014-01-23")
(re-replace #/a/ig "Eitaro Fukamachi" "α")

CL21
!
!
(#/^(#/^(d{4})-(d{2})-(d{2})$/
"2014-01-23")
(re-replace #/a/ig
"Eitaro Fukamachi" "α")

CL21
!
!
(#/^(#/^(d{4})-(d{2})-(d{2})$/
"2014-01-23")
(re-replace #/a/ig
"Eitaro Fukamachi" "α")
Appliable Regex literal

Common Lisp
(ql:quickload :clazy)
(use-package :clazy)
!
(defun fib-seq ()
(labels ((rec (a b)
(clazy:lazily (cons a
(rec b (+ a b))))))
(rec 0 1)))
!
(head (tail (tail (tail (fib-seq)))))
(lazy-seq:take 5 (fib-seq))

CL21
(use-package :cl21.lazy)
!
(defun fib-seq ()
(labels ((rec (a b)
(lazy-sequence (cons a
(rec b (+ a b))))))
(rec 0 1)))
!
(first (rest (rest (rest (fib-seq)))))
(elt (fib-seq) 3)
(subseq (fib-seq) 0 5)

CL21
!
!
(defun fib-seq ()
(labels ((rec (a b)
Abstract sequence
(lazy-sequence
(cons a
(rec b (+ a b))))))
(rec 0 1)))
!
!
!
!
!
(first (rest (rest (rest (fib-seq)))))
(elt (fib-seq) 3)
(subseq (fib-seq) 0 5)

CL21
!
!
(defun fib-seq ()
(labels ((rec (a b)
Abstract sequence
(lazy-sequence
(cons a
(rec b (+ a b))))))
(rec 0 1)))
!
!
!
!
!
(first (rest (rest (rest
(fib-seq)))))
(elt
(fib-seq) 3)
(subseq
(fib-seq) 0 5)
Builtin sequence functions
are available

Compatibility of CL21
• Written in Common Lisp
• 100% compatible with Common Lisp
• All CL libraries are available

(defsystem my-cl21-app
:defsystem-depends-on (:cl21)
:class :cl21-system
:components ((:file "src/myapp")))

(!
defsystem my-cl21-app
:defsystem-depends-on (:cl21)
:class :cl21-system
:components ((:file "src/myapp")))

Efficiency of CL21
• (less important in CL21, though)
• Generic methods are slow
• Compiler macros

“syntax”
• CL21 has “syntax”
• “syntax” = readtable bound to a package

“syntax”
(defsyntax cl21.process
((## #`) #'run-process-reader))
!
(export-syntax 'cl21.process)
(use-package :cl21.process)
!
#`ls -l /Users`

Redesigning Common Lisp

More Related Content

Similar to Redesigning Common Lisp

More from fukamachi

Recently uploaded

Redesigning Common Lisp