Data Structures in Functional Languages

Transcription

1 Data Structures in Functional Languages Performance Better than log Binary trees provide lg n performance B-trees provide log t n performance Can the performance be better than that? High branching factor can give you better performance (B-trees have this) 2

2 Tries (not Trees) Tries have a very high branching factor (32 or more) Use a special property to organize the keys Keys at each level differ by one bit Only when there is a collision you move to next level The location of the key is determined by its path (nodes don t store keys, their position is their key) Performance still log 32 n which is not really constant, but close to constant for reasonable values 3 Tries

3 Tries Another way to look at this a i f m n a i f m t s n m e an it is in im me 5 Immutability Functional programming style promotes immutability Objects can t be modified once you create them This helps preserve referential integrity (easy to prove correctness and to move around computations) This in turn favors concurrency 6

4 Collections and Immutability Collections hold several objects Mutable collections provide fairly good performance but suffer greatly when it comes to concurrency If you make a data structure immutable, you then have no issue of concurrency, but... If you re not careful, it can suffer from copy-overhead performance when you want to make changes 7 Persistent Data Structures Name is misleading Persistent here does not mean stored on disk Persistence here means preserves its contents when changed, meaning it does not change and you can make copies of it when you need to change The immutability promote sharing among instances of data structures Does not make full copy, so preserves performance for most part 8

5 Let s Explore Persistent DS Traditional arrays are not immutable array[i] = 4 They are not persistent, either How to insert and element? shift all elements before the insertion point to right and then insert, not very efficient You can make a copy, still the same efficiency (or lack of) 9 List Creation How do you create a list of 1, 2, 3? List(1, List(2, List(3, EMPTY))) 10

6 Consider an Immutable List list1 You want to prefix an element to the list1 list2 = elem :: list1 But how to do this efficiently? list2 This is why lists in functional languages often allow operations around the head and tail (rest) 11 Erlang List Access #!/usr/bin/env escript main(_) -> io:format("~p", [max([1, 2, 5, 7, 2, 4, 2, 1])]). max([h []]) -> H; max([h T]) -> max2(h, max(t)). max2(a, B) when A > B -> A; max2(_, B) -> B. 12

7 Erlang Creating a List #!/usr/bin/env escript main(_) -> List = [1, 2, 7, 8, 9, 2, 4, 6], {Even, Odd} = get_even_odd(list, [], []), io:format("~p\n", [Even]), io:format("~p", [Odd]). get_even_odd([h T], Even, Odd) -> case (H rem 2) of 1 -> get_even_odd(t, Even, [H Odd]); 0 -> get_even_odd(t, [H Even], Odd) end; get_even_odd([], Even, Odd) -> {Even, Odd}. 13 List Comprehension #!/usr/bin/env escript main(_) -> List = [5, 2, 9, 1, 5, 4, 3], SortedList = sort(list), io:format("~p\n", [SortedList]). sort([h T]) -> sort([x X <- T, X < H]) ++ [H] ++ sort([x X <- T, X >= H]); 14

8 Creating List in Scala val list1 = List(1, 2, 3) println(list1) val list2 = 0 :: list1 println(list2) val list3 = list1 ::: List(4) println(list3) 15 Scala Splitting List val list1 = List(1, 2, 3, 4) println(list1.head) println(list1.tail) println(list1(3)) list1 match { } case head :: tail => println(head) println(tail) case _ => println("empty") 16

9 List Concatenation list1 list2 list3 17 What about a Tree? 1 t2 t How to insert 8 below 4? By selective copying 18

10 Lazy Sequence A Lazy sequence is a sequence in which elements are not added until really needed You can easily postpone computations that may not be needed You can work with huge data structures that may not fit into the memory all at one time Clojure readily supports this 19 Lazy Infinite Sequence (defn integers ([] (concat [0] (integers 1))) ([n] (lazy-seq (cons n (integers (+ n 1)))))) (println (take 10 (integers))) 20

11 Finding factorial for n terms (defn fact ([] (concat [1] (fact 1 2))) ([p n] (let [prod (* p n)] (let [nextvalue (+ n 1)] (lazy-seq (cons prod (fact prod nextvalue))))))) (println (take 10 (fact))) 21 References Making Data Structures Persistent: Rich Hickey - creator of Clojure has an excellent presentation, a must view: Rich Hickey on Persistent Data Structures and Managed Reference: Identity-State-Rich-Hickey Programming Clojure, Stuart Halloway, Pragmatic Programmers,