From Emacs-Lisp to Clojure

class: center, middle

# From Emacs-Lisp to Clojure

Yen-Chin, Lee

---

# Agenda

-   A simple tutorial on emacs-lisp

-   About Clojure

-   Clojure by example

-   Clojure's building system

-   ClojureScript

-   Resources

---
class: center, middle, inverse

# Emacs-Lisp Tutorial

---

## S-Expression is simple

- Use `C-x C-e` to eval S-Expression
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">;; S-Expression
 (SYMBOL PARAMETER1 PARAMETER2 ...)
 
 ;; 1 + 2 + 3 + 4
 (+ 1 2 3 4) ; => 10
 
 ;; (1 + 2) * (3 + 4)
 (* (+ 1 2)
 (+ 3 4)) ; => 21
 
 ;; show "Hello LISP!" in emacs
 (message "Hello LISP!") ; => Hello LISP!
 
 ;; `quote' means not eval it
 '(1 2 3 4) ; => (1 2 3 4)
 (quote (1 2 3 4)) ; => (1 2 3 4)
 
 ;; t is `true', nil is `false'
 (if t "true" "false") ; => true
 (if nil "true" "false") ; => false
 </pre>
 </div>

---

## Create a library

-   Assume you create a library call `aa.el`

-   You got the namespace `aa`

- All function/variable should start with `aa-`
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(require 'cl) ; import library `cl.el'
 
 (defvar aa--count 0
 "A private variable to store current count value.")
 
 (defun aa-add (a b)
 "Return A + b."
 (+ a b))
 
 (defun aa-add-to (a)
 "Add a to count, return count."
 (let ((s (+ aa--count a)))
 (setq aa--count s)))
 
 (provide 'aa)
 ;; aa.el ends here
 </pre>
 </div>

---

## Find function/variable doc

-   Find function doc with `M-x describe-function`

-   Find variable doc with `M-x describe-variable`

---
class: center, middle, inverse

# Clojure

---

## Clojure - A LISP dialect on JVM

-   Functional programming language (immutability) create in 2007

-   Host on JVM

-   A LISP dialect (LISP-1)  (`Emacs-Lisp is LISP-2`)

-   Open Source under Eclipse Public License

- Create by <a href="https://github.com/richhickey">Rich Hickey</a>

---

## LISP trending akas why Clojure

---

## Clojure and it's dialect

- <a href="http://clojure.org/">Clojure</a> (JVM)

- <a href="https://github.com/clojure/clojurescript">ClojureScript</a> (Javascript)

- <a href="https://github.com/clojure/clojure-clr">ClojureCLR</a> (.NET)

---
class: center, middle, inverse

# Clojure vs Emacs-Lisp

<a href="http://www.tryclj.com/">http://www.tryclj.com/</a>

---

## Boolean

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">t ; => true
 nil ; => false
 ;; `nil' is null in emacs-lisp
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">true ; => true
 false ; => false
 nil ; => nil
 
 (= nil false) ; => false
 </pre>
 </div>

---

## Numbers

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">1 ; => 1
 1.2 ; => 1.2
 1e6 ; => 1000000.0
 ;; different from clojure
 #b101 ; => 5
 #x12 ; => 18
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">;; same as emacs-lisp
 1 ; => 1
 1.2 ; => 1.2
 1e6 ; => 1000000.0
 ;; different from emacs-lisp
 2r101 ; => 5
 25/3 ; => 25/3
 0x12 ; => 18
 </pre>
 </div>

---

## String

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">"Hello LISP!" ; => "Hello LISP!"
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">"Hello LISP!" ; => "Hello LISP!"
 </pre>
 </div>

---

## Characters

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">?a ; a => 97
 ?A ; A => 65
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">\a ; a => 97
 \A ; A => 65
 </pre>
 </div>

---

## Lists

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">'(1 2 3 4 5) ; => (1 2 3 4 5)
 
 (nth 2 '(1 2 3 4 5)) ; => 3
 (length '(1 2 3 4 5)) ; => 5
 
 (cons '3 '(1 2)) ; (3 1 2)
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">'(1 2 3 4 5) ; => (1 2 3 4 5)
 
 (nth '(1 2 3 4 5) 2) ; => 3
 (count '(1 2 3 4 5)) ; => 5
 
 (conj '(1 2) 3) ; (3 1 2)
 </pre>
 </div>

---

## Vectors

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">'[3 4 5] ; => [3 4 5]
 (vector 3 4 5) ; => [3 4 5]
 
 (length (vector 3 4 5)) ; => 3
 (elt '[3 4 5] 1) ; => 4
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">[3 4 5] ; => [3 4 5]
 (vector 3 4 5) ; => [3 4 5]
 
 (count [3 4 5]) ; => 3
 (nth [3 4 5] 1) ; => 4
 </pre>
 </div>

---

## Sets

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">;; seems like emacs-lisp doesn't has `hash-set' ?
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">#{1 2 3} ; => #{1 2 3}
 (hash-set 1 2 3) ; => #{1 2 3}
 (hash-set 1 2 3 3) ; => #{1 3 2}
 </pre>
 </div>

---

## Map

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">'(:Apple "Mac" :Microsoft "Windows") ; => (:Apple "Mac" :Microsoft "Windows")
 
 (plist-get '(:Apple "Mac" :Microsoft "Windows") :Apple) ; => "Mac"
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">{:Apple "Mac" :Microsoft "Windows"} ; => {:Apple "Mac" :Microsoft "Windows"}
 
 (:Apple {:Apple "Mac" :Microsoft "Windows"}) ; => "Mac"
 ({:Apple "Mac" :Microsoft "Windows"} :Apple) ; => "Mac"
 </pre>
 </div>

---

## Variables

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(defvar hello "hi"
 "variable doc") ; => "hi"
 
 (setq hello "world") ; => "world"
 
 hello ; => "world"
 </pre>
 </div>

---

## Local Variables

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(let ((x 1)
 (y 2))
 (+ x y)) ; => 3
 (defvar a 1)
 (let ((hello "hi"))
 (setq hello "world")
 hello) ; => "world"
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(let [x 1
 y 2]
 (+ x y)) ; => 3
 
 (with-local-vars [hello "hi"]
 (var-set hello "world")
 @hello) ; => world
 </pre>
 </div>

---

## If … Else

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(if "foo" "truthy" "falsey") ;=> "truthy"
 (if 0 "truthy" "falsey") ;=> "truthy"
 (if [] "truthy" "falsey") ;=> "truthy"
 (if nil "truthy" "falsey") ;=> "falsey"
 
 (if t (progn
 (print "print-true")
 "true")
 "false")
 </pre>
 </div>
 
 Only `nil` acts as `false`.

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(if "foo" "truthy" "falsey") ;=> "truthy"
 (if 0 "truthy" "falsey") ;=> "truthy"
 (if [] "truthy" "falsey") ;=> "truthy"
 (if false "truthy" "falsey") ;=> "falsey"
 (if nil "truthy" "falsey") ;=> "falsey"
 
 (if t (do
 (println "print-true")
 "true")
 "false")
 </pre>
 </div>
 
 Everything except `nil` and `false` acts as `true`.

---

## Loop

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(require 'cl) ; for `cl-loop'
 
 (let ((i 1))
 (cl-loop (print (format "hello: %d" i))
 (if (> i 10)
 (return)
 (setq i (+ i 1)))))
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(loop [i 1]
 (println (str "hello: " i))
 (if (10)
 (recur (inc i)))) ; tail recursion
 </pre>
 </div>

---

## Functions

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(defun add (x y &optional z)
 "Function Doc."
 (+ x y (or z 0)))
 
 (add 1 2) ; => 3
 (add 1 2 3) ; => 6
 
 (defun sum (x y &rest args)
 (+ x y (apply '+ args)))
 
 (sum 1 2 3 4 5 6) ; => 21
 </pre>
 </div>

---

## Functions Destructuring

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(defun logarithm
 (&key number &key base)
 (if base
 (/ (log number) (log base))
 (log number)))
 
 ;; order significant, not key names:
 (logarithm :foo 8 :bar 2) ; => 3.0
 (logarithm :bar 2 :foo 8) ; => 0.3333333
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(defn logarithm
 [{x :number b :base}]
 (/ (Math/log x) (Math/log b)))
 
 (defn logarithm* ; same as `logarithm'
 [{:keys [number base]}]
 (/ (Math/log number) (Math/log base)))
 
 ;; Order is not importent
 (logarithm {:base 2 :number 8}) ; => 3.0
 (logarithm {:number 8 :base 2}) ; => 3.0
 
 (logarithm* {:base 2 :number 8}) ; => 3.0
 (logarithm* {:number 8 :base 2}) ; => 3.0
 </pre>
 </div>

---

## Anoymouse Function

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">((lambda (a b) (+ a b)) 1 2) ; => 3
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">((fn [a b] (+ a b)) 1 2) ; => 3
 
 (#(+ %1 %2) 1 2) ; => 3
 (#(+ 2 %) 1) ; => 3
 </pre>
 </div>

---

## Import libraries

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(require '[clojure.string :as str])
 
 (str/trim " Hello ") ; => "Hello"
 (clojure.string/trim " Hello ") ; => "Hello"
 </pre>
 </div>

---

## Atoms

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(def aa (atom nil))
 
 (reset! aa 123) ; => aa becomes `123'
 @aa ; => 123
 (swap! aa inc) ; => aa becomes `124'
 
 (def bb (atom {:a "aaa" :b "bbb"}))
 @bb ; => {:a "aaa" :b "bbb"}
 (swap! bb assoc-in [:b] 1) ; => bb becomes `{:a "aaa" :b 1}'
 @bb ; => {:a "aaa" :b 1}
 
 (def bb (atom {:b {:c 12}})) ; => {:b {:c 12}}
 (swap! bb assoc-in [:b :c] 1) ; => bb becomes `{:b {:c 1}}'
 @bb ; => {:b {:c 1}}
 </pre>
 </div>

---

## Threads

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">;; Emacs-Lisp doesn't has `thread' support
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(do
 (Thread/sleep 3000)
 (println "hello"))
 
 ;; Wait for 3 sec and then "hello" is printed
 
 (do
 (future
 (Thread/sleep 3000)
 (println "after sleep"))
 (println "hello"))
 
 ;; hello
 ;; nil
 ;; after sleep
 </pre>
 </div>

---

## Macro

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(defmacro infix (expr)
 (list (cadr expr) (car expr) (caddr expr)))
 
 (macroexpand-1 '(infix (1 + 3))) ; => (+ 1 3)
 
 (infix (1 + 3)) ; => 4
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(defmacro infix [expr]
 (list (second expr) (first expr) (nth expr 2)))
 
 (macroexpand-1 '(infix (1 + 3))) ; => (+ 1 3)
 
 (infix (1 + 3)) ; => 4
 
 (defmacro when
 "Evaluates test. If logical true, evaluates body in an implicit do."
 {:added "1.0"}
 [test & body]
 (list 'if test (cons 'do body)))
 </pre>
 </div>

---

## Thread first Macro ->

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(require 'dash) ; https://github.com/magnars/dash.el
 
 (-> 2 (+ 3) (- 4) (* 5) (- 3)) ; => 2
 
 (macroexpand-all
 '(-> 2 (+ 3) (- 4) (* 5) (- 3))) ; => (- (* (- (+ 2 3) 4) 5) 3)
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(-> 2 (+ 3) (- 4) (* 5) (- 3)) ; => 2
 
 (first (.split (.replace (.toUpperCase "a b c d") "A" "X") " "))
 
 (-> "a b c d"
 .toUpperCase
 (.replace "A" "X")
 (.split " ")
 first) ; => "X"
 </pre>
 </div>

---

## Thread last Macro ->>

- Emacs-Lisp
 
 <div class="org-src-container">
 
 <pre class="src src-emacs-lisp">(require 'dash) ; https://github.com/magnars/dash.el
 
 (->> 5 (+ 3) (/ 2) (- 1)) ; => 1
 
 (macroexpand-all
 '(->> 5 (+ 3) (/ 2) (- 1))) ;; => (- 1 (/ 2 (+ 3 5)))
 </pre>
 </div>

- Clojure
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(reduce +
 (take 10
 (filter even?
 (map #(* % %)
 (range)))))
 
 (->> (range)
 (map #(* % %))
 (filter even?)
 (take 10)
 (reduce +)) ; => 1140
 </pre>
 </div>

---
class: center, middle, inverse

# Clojure Java Interop

<a href="http://clojure.org/reference/java_interop">http://clojure.org/reference/java_interop</a>

---

## Class Import

<pre class="src src-clojure">(import [java.util ArrayList])

(def foo (ArrayList. [1 2 3 4])) ; => [1 2 3 4]

(.containsAll foo [2 3 4]) ; => true
</pre>
</div>

---

## Member Access

<pre class="src src-clojure">(.toUpperCase "fred") ; => "FRED"

(.getName String) ; => java.lang.String

(.x (java.awt.Point. 1 2)) ; => 1

(System/getProperty "java.vm.version") ; => "25.51-b03"

Math/PI ; => 3.141592653589793
</pre>
</div>

---

## doto Macro

<pre class="src src-clojure">(doto (new java.util.HashMap)
 (.put "a" 1)
 (.put "b" 2)) ; => {"a" 1, "b" 2}

(let [h (new java.util.HashMap)]
 (.put h "a" 1)
 (.put h "b" 2)
 h) ; => {"a" 1, "b" 2}
</pre>
</div>

---
class: center, middle, inverse

# Hello, Clojure

---

## Clojure's Building System

---

## Leinigen

- Download <a href="https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein">lein script</a> and install to your system

- Use `lein` to create new project
 
 <div class="org-src-container">
 
 <pre class="src src-sh">coldnew@Sara ~ $ lein new nice-project
 Generating a project called nice-project based on the 'default' template.
 The default template is intended for library projects, not applications.
 To see other templates (app, plugin, etc), try `lein help new`.
 </pre>
 </div>
 
 <div class="org-src-container">
 
 <pre class="src src-sh">.
 ├── CHANGELOG.md
 ├── LICENSE
 ├── README.md
 ├── doc
 │   └── intro.md
 ├── project.clj
 ├── resources
 ├── src
 │   └── nice_project
 │   └── core.clj
 └── test
 └── nice_project
 └── core_test.clj
 </pre>
 </div>

---

## Leinigen (cont'd)

- Edit `project.clj` to add new dependancies or future
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(defproject nice-project "0.1.0-SNAPSHOT"
 :description "FIXME: write description"
 :url "http://example.com/FIXME"
 :license {:name "Eclipse Public License"
 :url "http://www.eclipse.org/legal/epl-v10.html"}
 :dependencies [[org.clojure/clojure "1.8.0"]])
 </pre>
 </div>

- You can find clojure libraries in <a href="https://clojars.org/">Clojars</a>

---

## Leinigen (cont'd)

- Edit `src/nice_project/core.clj`
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(ns nice-project.core)
 
 (defn add-3
 "Return x + 3"
 [x]
 (+ x 3))
 
 (defn -main []
 (println "Hello CLojure!"))
 </pre>
 </div>

- Use `lein run` to execute main function
 
 <div class="org-src-container">
 
 <pre class="src src-sh">coldnew@Sara ~ $ lein run -m nice-project.core
 Hello CLojure!
 </pre>
 </div>

---

## Leinigen (cont'd)

- Edit `test/nice_project/core_test.clj`
 
 <div class="org-src-container">
 
 <pre class="src src-clojure">(ns nice-project.core-test
 (:require [clojure.test :refer :all]
 [nice-project.core :refer :all]))
 
 (deftest add-3-test
 (testing "I will success."
 (is (= (add-3 10) 13))))
 
 (deftest add-3-test-failed
 (testing "I fail."
 (is (= (add-3 10) 10))))
 </pre>
 </div>

- Use `lein test` to execute test
 
 <div class="org-src-container">
 
 <pre class="src src-sh">coldnew@Sara ~ $ lein test nice-project.core-test
 
 lein test :only nice-project.core-test/add-3-test-failed
 
 FAIL in (add-3-test-failed) (core_test.clj:11)
 I fail.
 expected: (= (add-3 10) 10)
 actual: (not (= 13 10))
 
 Ran 2 tests containing 2 assertions.
 1 failures, 0 errors.
 Tests failed.
 </pre>
 </div>

---
class: center, middle, inverse

# ClojureScript

<a href="http://clojurescript.net/">http://clojurescript.net/</a>

---

## About ClojureScript

-   Clojure dialect compile to javascript

- Compiled by <a href="https://developers.google.com/closure/compiler/">Google's Closure Compiler</a>
 - Compile ClojureScript to Javascript
 
 - Minification and Optimization
 - none, whitespace, simple, advanced optimization

- Mantained by <a href="https://github.com/swannodette">David Nolen</a>

---
class: center, middle, inverse

# ☛ TODO Hello, ClojureScript

---

## Create project by Leinigen

-   TODO

---
class: center, middle, inverse

# ☛ TODO When ClojureScript meet React

---
class: center, middle, inverse

# Resources

<a href="http://clojure.org/community/resources">http://clojure.org/community/resources</a>

---

## Clojure Books (1/3)

---

## Clojure Books (2/3)

---

## Clojure Books (3/3)

---

## ClojureScript Books

- <a href="https://github.com/magomimmo/modern-cljs">modern-cljs</a>
 
 A series of tutorials on ClojureScript

- <a href="https://github.com/funcool/clojurescript-unraveled">clojurescript-unraveled</a>
 
 An open source book about ClojureScript. <a href="http://funcool.github.io/clojurescript-unraveled/">(read online)</a>

---

## Conference

- <a href="http://clojurewest.org/">Clojure/West</a> (usually in March)
 
 Youtube: <a href="https://www.youtube.com/watch?v=6DaBmz_6y0s&list=PLZdCLR02grLrKAOj8FJ1GGmNM5l7Okz0a">2015</a> <a href="https://www.youtube.com/watch?v=axztcYJUN4I&list=PLZdCLR02grLp__wRg5OTavVj4wefg69hM">2014</a>

- <a href="http://clojure-conj.org/">Clojure/conj</a> (usually in November)
 
 Youtube: <a href="https://www.youtube.com/watch?v=Y2jQe8DFzUM&list=PLZdCLR02grLrl5ie970A24kvti21hGiOf">2015</a> <a href="https://www.youtube.com/watch?v=BNkYYYyfF48&list=PLZdCLR02grLoc322bYirANEso3mmzvCiI">2014</a>

- <a href="http://euroclojure.com/">EuroClojure</a> (usually mid-year)
 
 Youtube: <a href="https://www.youtube.com/watch?v=ByNs9TG30E8&list=PLZdCLR02grLoBx0Y5ZrpdmLxc160PIwzQ">2015</a>

- <a href="http://www.clojurebridge.org/">ClojureBridge</a> - beginner workshops for women

- <a href="http://lanyrd.com/search/?context=future&q=clojure&type=conference">Clojure Events</a>

---

## Exercise

- <a href="https://www.4clojure.com/">4Clojure</a>

- <a href="http://clojurekoans.com/">Clojure Koans</a>

- <a href="https://projecteuler.net/">Project Euler</a>

---

## Find Jobs

- <a href="https://weworkremotely.com/">https://weworkremotely.com/</a>

- <a href="http://careers.stackoverflow.com/jobs/remote">http://careers.stackoverflow.com/jobs/remote</a>

- <a href="http://www.indeed.com/l-Remote-jobs.html">http://www.indeed.com/l-Remote-jobs.html</a>

- <a href="https://remoteok.io/">https://remoteok.io/</a>

- <a href="https://functionaljobs.com/">https://functionaljobs.com/</a>

- <a href="http://jobs.functionalworks.com/">http://jobs.functionalworks.com/</a>

- <a href="https://lispjobs.wordpress.com/">https://lispjobs.wordpress.com/</a>

- <a href="https://www.linkedin.com/groups/6620522">Clojure Jobs on Linkedin</a>

---
class: center, middle

# Q & A