Emergency Elisp

From Steve Yegge

(setq foo "bar")  ; setq means "set quoted"

(foo-bar "flim" "flam")

(% (* #x15 (+ 8.2 (lsh 7 3))) 2)

1. Put your cursor after the last close-paren and type C-j (control + j)
   
2. Put your cursor inside the expression and type M-C-x (alt + control + x)
   
3. Put your cursor after the last close-paren and type C-x C-e
   

Lexical Stuff

(blah blah blah)   ;  I am a comment

"He's said: \"Emacs Rules\" one time too many."

"Oh Argentina!
Your little tin of pink meat
Soars o'er the Pampas"

• ?x is the syntax for an ASCII character: ? followed by the character.


• e.g.: ?a is ascii 97 ('a'), ? (that is, question-mark space) is ascii 32 (' ').


• Some need to be escaped, such as ?\(, ?\) and ?\\


• Emacs 22+ has unicode support. Out of scope for this primer.

• Integers are 29 bits of precision (not the usual 32). -32, 0, 157, etc.


• Binary: start with #b, e.g. #b10010110


• Octal: #o[0-7]+, e.g. #o377


• Hexadecimal: start with #x, e.g. #xabcd, #xDEADBEE


• Floating-point: the usual. -10.005, 0.0, 3.14159265 (64 bits of precision.)


• Scientific: the usual. 6.02e23, 5e-10

[-2 0 2 4 6 8 10]
["No" "Sir" "I" "am" "a" "real" "horse"]
["hi" 22 120 89.6 2748 [3 "a"]]

(quote (1 2 3)) ; produces the list (1 2 3) with no list-element evaluation

'(1 2 3)  ; apostrophe is shorthand for (quote (...))
          ; note that it goes _outside_ the left-paren

(list 1 (+ 1 1) 3) ; also produces (1 2 3), since it evaluates the elements first

`(1 ,(+ 1 1) 3)  ; another (1 2 3) via a template system called "backquote"

'( (apple . "red")
   (banana . "yellow")
   (orange . "orange") )

Operators

(equal '(1 2 (3 4)) (list 1 2 (list 3 (* 2 2))))  ; true

(concat "foo" "bar" "baz")  ; yields "foobarbaz"

(string= "foo" "baz")  ; yields nil (false).  Can also use equal.

(substring "foobar" 0 3) ; yields "foo"

(upcase "foobar")  ; yields "FOOBAR"

Statements

(if (>= 3 2)
  (message "hello there"))

(if (today-is-friday)         ; test-expr
    (message "yay, friday")   ; then-expr
  (message "boo, other day")) ; else-expr

(if (zerop 0)
    (progn
      (do-something)
      (do-something-else)
      (etc-etc-etc)))

(if (today-is-friday)
    (message "yay, friday")
  (message "not friday!")
  (non-friday-stuff)
  (more-non-friday-stuff))

(if 'sunday
    (message "sunday!")      ; then-expr
  (if 'saturday              ; else-if
      (message "saturday!")  ; next then-expr
    (message ("weekday!")))) ; final else

(when (> 5 1)
  (blah)
  (blah-blah)
  (blah blah blah))

(unless (weekend-p)
  (message "another day at work")
  (get-back-to-work))

(cond
  (test-1
    do-stuff-1)
  (test-2
    do-stuff-2)
  ...
  (t
    do-default-stuff))

(cond
 ((equal value "foo")  ; case #1 – notice it's a function call to `equal' so it's in parens
  (message "got foo")  ; action 1
  (+ 2 2))             ; return value for case 1
 ((equal value "bar")  ; case #2 – also a function call (to `+')
  nil)                 ; return value for case 2
 (t                    ; default case – not a function call, just literal true
  'hello))             ; return symbol 'hello

(case 12
  (5 "five")
  (1 "one")
  (12 "twelve")
  (otherwise
   "I only know five, one and twelve."))  ; result:  "twelve"

(setq x 10
      total 0)
(while (plusp x)  ; while x is positive
  (incf total x)  ; add x to total
  (decf x))       ; subtract 1 from x

(setq x 0 total 0)
(catch 'break
  (while t
    (incf total x)
    (if (> (incf x) 10)
        (throw 'break total))))

var x = total = 0;
while (true) {
  total += x;
  if (x++ > 10) {
    break;
  }
}

(setq x 0 total 0)
(while (< x 100)
  (catch 'continue
    (incf x)
    (if (zerop (% x 5))
        (throw 'continue nil))
    (incf total x)))

var x = total = 0;
while (x < 100) {
  x++;
  if (x % 5 == 0) {
    continue;
  }
  total += x;
}

(setq x 0 total 0)
(catch 'break
  (while t
    (catch 'continue
      (incf x)
      (if (>= x 100)
          (throw 'break nil))
      (if (zerop (% x 5))
          (throw 'continue nil))
      (incf total x))))

var x = total = 0;
while (true) {
  x++;
  if (x >= 100) {
    break;
  }
  if (x % 5 == 0) {
    continue;
  }
  total += x;
}

(require 'cl)  ; get lots of Common Lisp goodies

(loop do
      (setq x (1+ x))
      while
      (< x 10))

// JavaScript
var result = [];
for (var i = 10, j = 0; j <= 10; i--, j += 2) {
  result.push(i+j);
}

(loop with result = '()         ; one-time initialization
      for i downfrom 10         ; count i down from 10
      for j from 0 by 2         ; count j up from 0 by 2
      while (< j 10)            ; stop when j >= 10
      do
      (push (+ i j) result)     ; fast-accumulate i+j
      finally
      return (nreverse result)) ; reverse and return result

(loop for i in '(1 2 3 4 5 6)
      collect (* i i))           ; yields (1 4 9 16 25 36)

(defun square (x)
  "Return X squared."
  (* x x))

(defun hello ()
  "Print the string `hello' to the minibuffer."
  (message "hello!"))

(let ((name1 value1)
      (name2 value2)
      name3
      name4
      (name5 value5)
      name6
      ...))

(defun foo ()
  (let ((x 6))  ; define a local (i.e., stack) variable x initialized to 6
    (bar)       ; call bar
    x))         ; return x

(defun bar ()
  (setq x 7))   ; finds and modifies x in the caller's stack frame

(require 'calendar)

(defun day-name ()
  (let ((date (calendar-day-of-week
               (calendar-current-date))))
    (if (= date 0)
        "Sunday"
      (if (= date 6)
          "Saturday"
        "weekday"))))

function dayName() {
  var date = new Date().getDay();
  switch (date) {
    case 0:
      return "Sunday";
    case 6:
      return "Saturday";
    default:
      return "weekday";
  }
}

(defun day-name ()
  (let ((date (calendar-day-of-week
               (calendar-current-date))))  ; 0-6
    (catch 'return
      (case date
        (0
         (throw 'return "Sunday"))
        (6
         (throw 'return "Saturday"))
        (t
         (throw 'return "weekday"))))))

(condition-case nil
    (progn
      (do-something)
      (do-something-else))
  (error
   (message "oh no!")
   (do-recovery-stuff)))

try {
  doSomething();
  doSomethingElse();
} catch (Throwable t) {
  print("uh-oh");
  doRecoveryStuff();
}

(ignore-errors
  (do-something)
  (do-something-else))

(unwind-protect
    (progn
      (do-something)
      (do-something-else))
  (first-finally-expr)
  (second-finally-expr))

try {
  doSomething();
  doSomethingElse();
} finally {
  firstFinallyExpr();
  secondFinallyExpr();
}

(unwind-protect                 ; finally
    (condition-case nil         ; try
        (progn                  ; {
          (do-something)        ;   body-1
          (do-something-else))  ;   body-2 }
      (error                    ; catch
       (message "oh no!")       ; { catch 1
       (poop-pants)))           ;   catch 2 }
  (first-finally-expr)          ; { finally 1
  (second-finally-expr))        ;   finally 2 }

Classes

(require 'cl)  ; top of file
          

(defstruct person
  "A person structure."
  name
  (age 0)
  (height 0.0))

/* A Person class */
class Person {
  String name;
  int age;
  double height;
  public Person() {}
  public Person(String name) {
    this(name, 0, 0);
  }
  public Person(int age) {
    this(null, age, 0);
  }
  public Person(double height) {
    this(null, 0, height);
  }
  public Person(String name, int age) {
    this(name, age, 0);
  }
  public Person(String name, double height) {
    this(name, 0, height);
  }
  public Person(int age, double height) {
    this(null, age, height);
  }
  public Person(String name, int age, double height) {
    this.name = name;
    this.age = age;
    this.height = height;
  }
}

(make-person)  ; new Person()
(make-person :age 39)  ; new Person(39)
(make-person :name "Steve" :height 5.83 :age 39)  ; new Person("Steve", 39, 5.83)

(defstruct (employee
            (:include person))
  "An employee structure."
  company
  (level 1)
  (title "n00b"))

/* An Employee class */
class Employee extends Person {
  String company;
  int level = 1;
  String title = "n00b";
  public Employee() {
  }
  public Employee(String name,
                  String company) {
    super(name);
    this.company = company;
  }
  public Employee(String name,
                  int age,
                  String company) {
    super(name, age);
    this.company = company;
  }
  public Employee(String name,
                  int age,
                  double height,
                  String company) {
    super(name, age, height);
    this.company = company;
  }
  public Employee(String name,
                  int age,
                  String company,
                  int level) {
    super(name, age);
    this.company = company;
    this.level = level;
  }
  public Employee(String name,
                  int age,
                  String co,
                  int lvl,
                  String title) {
    super(name, age);
    this.company = co;
    this.level = lvl;
    this.title = title;
  }
  // (remaining 150 overloaded constructors elided for brevity)
}

(person-p (make-person))
t
(employee-p (make-person))
nil
(employee-p (make-employee))
t
(person-p (make-employee))  ; yes, it inherits from person
t

(setq e (make-employee))
(setf (employee-name e) "Steve"
      (employee-age e) 39
      (employee-company e) "Google"
      (employee-title e) "Janitor")

Employee e = new Employee();
e.name = "Steve";
e.age = 39;
e.company = "Google";
e.title = "Janitor";

(setf (js2-compiler-data-current-script-or-function compiler-data) current-script
      (js2-compiler-data-line-number compiler-data) current-line
      (js2-compiler-data-allow-member-expr-as-function-name compiler-data) allow
      (js2-compiler-data-language-version compiler-data) language-version)

(person-name steve)  ; yields "Steve"

Variables

(defconst pi 3.14159 "A gross approximation of pi.")

Further reading