Clojure 3 Recursion, Higher-order-functions 27-Aug-15

Running Clojure C:\Users\Dave>cd C:\Programs\clojure C:\Programs\clojure-1.2.0>java -cp clojure.jar clojure.main Clojure user=> (load-file "E:/Programming/Clojure programs on E/test.clj") #'user/fruit user=> The response, #'user/fruit, is because “fruit” was the last thing defined on this file Although jEdit has a clojure mode, I don’t like it Syntax coloring is good, but indentation is strange (buggy?) and agressive The lisp mode doesn’t syntax color as well, but indents properly Comments: A “doc” string is a string that goes just before the parameter list Other comments start with a semicolon ( ; ) and extend to the end of the line

3 Functions The syntax to define a named function is: (defn function_name docstring? [ arguments ] expressions ) The value of the function is the value of the last expression evaluated The syntax of a function call is ( function arguments ) Notice that the function being called is the first thing inside the parentheses This need not be the name of a function; it can be any expression that results in a function A Clojure function can be overloaded (have different bodies for different parameter lists) Syntax: (defn function_name docstring? ([ arguments ] expressions )... ([ arguments ] expressions ) )

Tail recursion A recursive function is one that calls itself A recursive function typically has three parts: 1.One or more base cases that solve the simplest cases of the problem without recurring 2.Recursive calls to solve subproblems that are simpler but of the same type as the given problem 3.Code to augment solutions to subproblems into solutions of the given problem A function is tail recursive if the recursive call is the very last thing that the function does In other words, part 3 above is empty—no additional work need be done If the function has multiple exits, it is tail recursive only if every recursive call returns without doing additional work

Façades A façade is a function that provides a different (usually better) interface to another function Often this means supplying arguments that are only used for initialization In Clojure it’s easy to define a function within another function This allows an “uglier” version of the function to be hidden Functions can also be overloaded 5

Tail recursion (Erlang) Non-tail recursive function to find the length of a list: len([]) -> 0; len([_ | T]) -> 1 + len(T). Tail recursive function to find the length of a list: len(L) -> len(0, L). len(N, []) -> N; len(N, [_ | T]) -> len(N + 1, T).

Tail recursion (Clojure) Non-tail recursive function to find the length of a list: (defn len-1 [lst] (if (empty? lst) 0 (inc (len-1 (rest lst))) ) ) Tail recursive function to find the length of a list: (defn len-2 ([lst] (len-2 0 lst)) ([n lst] (if (empty? lst) n (len-2 (inc n) (rest lst)) ) ) )

recur The previous function, len-2, is tail-recursive, but the compiler doesn’t optimize it into a loop Clojure runs on the JVM, which doesn’t optimize tail recursion Workaround: (defn len-2 ([lst] (len-2 0 lst)) ([n lst] (if (empty? lst) n (recur (inc n) (rest lst))) ) )

Tail recursion (Erlang) Non-tail recursive function to find the factorial: factorial(1) -> 1; factorial(N) -> N * factorial(N - 1). Tail recursive function to find the factorial: factorial(N) -> factorial(1, N). factorial(Acc, 1) -> Acc; factorial(Acc, N) -> factorial(N * Acc, N - 1).

Tail recursion (Clojure) Non-tail recursive function to find the factorial: (defn factorial-1 [n] (if (= n 1) 1 (* n (factorial-1 (dec n))) ) Tail recursive function to find the factorial: (defn factorial-2 ([n] (factorial-2 1 n)) ([acc n] (if (= n 1) acc (recur (* n acc) (dec n)) ) ) )

Functions that take functions Functional programming languages allow you to use a function as a parameter to another function Almost all functional programming languages provide these three extremely useful functions: map applies a function to every element of a sequence, giving a sequence of the results filter applies a predicate to every element of a sequence, giving a sequence of the results reduce (or fold) applies a binary operation “between” each pair of elements, giving a single (non-sequence) result There are often different versions for left- and right-associative operations, and for providing or not providing an initial value 11

map (def fruit '((apple red) (banana yellow) (cherry red))) user=> (map first fruit) (apple banana cherry) (defn my-map [f lst] (if (empty? lst) () (cons (f (first lst)) (my-map f (rest lst))) ) ) user=> (map my-first fruit) (apple banana cherry)

Anonymous functions An anonymous function has the syntax: (fn [ parameters ] body ) Example: (fn [x] (* x x)) Anonymous functions are used when The function body is short and simple, and It is only needed in one place

filter (def fruit '((apple red) (banana yellow) (cherry red))) user=> (filter (fn [x] (= (second x) 'red)) fruit) ((apple red) (cherry red)) (defn my-filter [p lst] (cond (empty? lst) () (p (first lst)) (cons (first lst) (my-filter p (rest lst))) :else (my-filter p (rest lst)) ) ) user=> (my-filter (fn [x] (= (second x) 'red)) fruit) ((apple red) (cherry red))

Speaking of maps… A map or hash is a sequence of key/value pairs, enclosed in braces, for example, {:ace 1, :deuce 2, "trey" 3} Elements are separated by whitespace or commas It is helpful to use commas between key/value pairs A map is also a function: user=> (def cards {:ace 1, :deuce 2, "trey" 3}) #'user/cards user=> (cards :deuce) 2 Keywords are also functions: user=> (:deuce cards) 2

reduce user=> (defn my-reduce [f init lst] (cond (empty? lst) init :else (recur f (f init (first lst)) (rest lst)) ) ) #'user/my-reduce user=> (my-reduce + 0 '( )) 66 user=> (my-reduce * 1 '(2 3 4)) 24

Functions that return functions A closure is a function that contains and works with, not only its parameters, but values from the scope in which it was defined Currying creates a new function with fewer arguments than the original function Function composition combines two or more functions into a new function 17

Closures I user=> (defn rangechecker [min max] (fn [num] (and (>= num min) (<= num max))) ) #'user/rangechecker user=> (def in-range? (rangechecker 0 100)) #'user/in-range? user=> (in-range? 75) true user=> (in-range? 101) false

Closures II user=> (defn adjust-range [min max] (fn [num] (cond ( num max) max :else num )) ) #'user/adjust-range user=> (def adjust (adjust-range 0 100)) #'user/adjust user=> (adjust 75) 75 user=> (adjust 101) 100

Partial functions (currying) (partial f arg1 arg2 arg3 & more ) Takes a function f and fewer than the normal arguments to f, and returns a fn that takes a variable number of additional args. When called, the returned function calls f with args + additional args. user=> (def hundred-times (partial * 100)) #'user/hundred-times user=> (hundred-times 5) 500

Function composition user=> (def negtimes (comp - *)) #'user/negtimes user=> (negtimes 5 3) -15 user=> (def third (comp first rest rest)) #'user/third user=> (third [ ]) 33 user=> (third '(:a :b :c :d)) :c

The End