@bodil

Bodil Stokke

@bodil

interface Function<F,T> {
    T apply(F input);
}

class SquareFunction implements Function<Long,Long> {
    Long apply(Long number) {
        return number * number;
    }
}

(defn square [number]
  (* number number))

Java Syntax

println("Hello sailor!");

Lisp Syntax

(println "Hello sailor!")

Lists

(println "Hello sailor!")

("Rainbow Dash" "Twilight Sparkle" "Pinkie Pie")

(0 1 1 2 3 5 8 13 21 34 55)

Homoiconic

Homoiconic

Data structures

;; List (linked list)
("Rainbow Dash" "Twilight Sparkle" "Pinkie Pie")

;; Vector (array list)
["Fluttershy" "Rarity" "Applejack"]

;; Map (hash map)
{"name" "Rainbow Dash", "type" "Pegasus pony"}

All the syntax you need

(println "Hello sailor!")

(println "2 + 2 = " (+ 2 2))

(defn add [number1 number2]
  (+ number1 number2))

Immutable Data Structures

Look ma, no mutation

(def primes [2 3 5 7 11 13])
(assoc primes 3 42)

Functions as values

(defn square [number]
  (* number number))

(def fibonacci [0 1 1 2 3 5 8 13 21 34 55])

Higher order functions

(defn plus-two [number]
  (+ 2 number))

(defn plus-something [something]
  (fn [number]
    (+ something number)))

Combinators

(defn function-plus-something [function]
  (fn [number]
    (+ something (function number))))

State gonna state

(def counter-state (atom 0))

(defn count-up []
  (swap! counter-state inc)
  @counter-state)

Threads so simple you could cry

(defn sum-to [n]
  (reduce + (range n)))

; (sum-to 250000000)

ClojureScript

bodil.org/ten-minute-clojure

github.com/bodil/clojurescript-all-the-way-down