程序代写代做代考 data structure Haskell Clojure Clash Course

Clojure Clash Course
====================

Syntax
——

Like Lisp and Scheme, syntax is in prefix notation with parentheses to specify
beginnings and ends.

(what-to-do operand1 operand2 …)

(what-to-do) if no operand at all

var if you want the value of a variable; no parentheses
literal e.g., 5, “hello”, true

Examples (Haskell-like on the left, Clojure on the right):

x>0 (> x 0)

2-x*3 (- 2 (* x 3))

if x>0 (if (> x 0)
then 2-x*3 (- 2 (* x 3))
else 4*y (* 4 y))

\x y -> if x>0 (fn [x y] (if (> x 0)
then 2-x*3 (- 2 (* x 3))
else 4*x (* 4 y)))

#(if (> %1 0)
(- 2 (* %1 3))
(* 4 %2))

f x y = if x>0 (defn f [x y]
then 2-x*3 (if (> x 0)
else 4*x (- 2 (* x 3))
(* 4 x)))

four = 2+2 (def four (+ 2 2))

f 5 6 (f 5 6)
Note: Can’t have (f 5).

let x=5 (let [x 5 y 1]
y=6 (+ x x y))
in x+x+y Note: On the upside, varargs supported!

[1, 2, 3] ‘(1 2 3)
Note: (1 2 3) would mean that 1 is what to do.

1 : 2 : 3 : [] (cons 1 (cons 2 (cons 3 () )))

Homoiconic
———-

Notice how list syntax is almost the same as code syntax. In fact there is an
“eval” function to take a list and run it as code, e.g.:

‘(+ 3 5) is a list, but then you can do

(eval ‘(+ 3 5))
-> (+ 3 5)
-> 8

“Homoiconic” refers to having the same format for both code and data (lists
here). You can now build a list (that will become code later), store it
somewhere, then later retrieve it and run it.

Semantics
———

Also like Lisp and Scheme.

Typing: Dynamic typing.

(if (> 1 0) “hello” 4)

is legal.

‘(1 “hello” true)

is legal.

Evaluation: Like most languages, not lazy.

(f (g 1 2) (h 3 4))

(g 1 2) and (h 3 4) evaluated until values known before calling f. (If f is a
function, not “if”, “let”, etc.)

However, a lazy list type called “sequence” is provided.

There is also a macro system for defining your own constructs.

Thread-safe mutable variables
—————————–

Most standard library types and data structures are immutable.

However, thread-safe mutable cells are available. Imagine a mutable pointer
that you can change what it points to; but still point it to immutable data.