[Camllist] Using zippers to handle huge trees
 Diego Olivier Fernandez Pons
[
Home
]
[ Index:
by date

by threads
]
[ Message by date: previous  next ] [ Message in thread: previous  next ] [ Thread: previous  next ]
[ Message by date: previous  next ] [ Message in thread: previous  next ] [ Thread: previous  next ]
Date:  20030411 (11:18) 
From:  Diego Olivier Fernandez Pons <DiegoOlivier.FERNANDEZPONS@c...> 
Subject:  [Camllist] Using zippers to handle huge trees 
Bonjour, On Wednesday, 09 Apr 2003, Yang Shouxun wrote: > I don't know how to write a tail recursive version to build trees. > If there are not that many continuous attributes and the dataset is > not so large, the tree stops growing before stack overflow. On Wednesday 09 April 2003, Markus Mottl wrote: > The trick is to use continuation passing style (CPS): you pass a > function closure (continuation) containing everything that's needed > in subsequent computations. Instead of returning a result, the > subfunction calls the continuation with the result, which makes the > functions tailrecursive. Zippers are a simple way to handle huge (in fact infinite) trees. 1. Explanation of zippers 2. Related work 3. Examples of code 1. Explanation of zippers Zippers may be seen as 'functional pointers' since they offer :  purely functional and typed operations  O(1) acces to the pointed element  O(1) pointer movements The restrictions are that only one pointer is allowed by data structure and every pointer movement allocates memory. Take a classical type declaration for binary search trees type 'a tree = E  N of 'a tree * 'a * 'a tree * int Consider a binary search tree and an inner node to which you want to point. To have a 0(1) acces to the pointed subtree, it has to be directly available from the base of the data structure. Then, the rest of the tree must be kept in a separate place. We will deconstruct it along the path from the root to the pointed node type 'a path =  Root  Left of 'a * 'a tree * 'a path  Right of 'a tree * 'a * 'a path type 'a zipper = 'a tree * 'a path The zipper contrains as annouced :  the pointed subtree  the rest of the tree breaked along the path to the root Then we define the pointer movements (one for each pointer in the data structure) : exception Bottom (* To be replaced by a balancing constructor *) let makeDTree = fun l v r > N (l, v, r, 0) let move_left = fun (tree, path) > match tree with  E > raise Bottom  N (l, v, r, _) > (l, Left (v, r, path)) let move_right = fun (tree, path) > match tree with  E > raise Bottom  N (l, v, r, _) > (r, Right (l, v, path)) let move_up = fun (tree, path) > match path with  Root > raise Top  Left (v, r, tail) > (makeDTree tree v r, tail)  Right (l, v, tail) > (makeDTree l v tree, tail) Now we can build an arbitrary large tree by the following procedure :  build a tree of bounded depth  choose the node which will be developped next  move the current pointer to that node  continue building the tree This procedure uses a bounded stack space 2. Related work Zippers were invented by Gérard Huet. There is a paper on the JFP G. Huet. The Zipper. J. Functional Programming, 7 (5), Sept 1997, pp. 549554. He uses nary trees and binary trees in his examples. The main difference is that in binary trees the pointers are not organized in the same way (his 'left' operation is what in Baire is (left o up)) Ralf Hinze has tried to give a general framework for functional pointers named a web (you give your data structure and the basic transformations and the data structure does the rest) Ralf Hinze and Johan Jeuring. Functional Pearl: Weaving a Web. Journal of Functional Programming, 11(6):681689, November 2001. Available on the net via Hinze's home page. In my opinion his article is not really convincing and not very clear. Several libraries already use zippers  Zen (Gérard Huet, Caml) uses zippers to handle acyclic automata minimization  SML/NJ Standard library (John Reppy) uses zippers to handle deletion in redblack trees  MetaPRL (Caml) uses zippers to handle insertion and deletion in splay and redblack trees  Grammatical Framework (Aarne Ranta, Haskell) uses zippers to navigate through nary trees. All this code is available on the web. 3. Examples of code Here are some examples of usual binary search trees operations made whith zippers (insert, delete, move_pointer_to, ...) extracted from Baire (current version 11 avril 2003, plenty of bugs and breaked code, you will find it in Baire's download pages) : let rec move_to_top = function ((tree, path) as pointer) > match path with  Root > pointer  Left (v, r, tail) > move_to_top (makeDTree tree v r, tail)  Right (l, v, tail) > move_to_top (makeDTree l v tree, tail) let rec move_to x = function ((tree, path) as pointer) > match tree with  E > (match path with  Right (_, rv, _) when x <= rv > move_to x (move_up pointer)  Left (lv, _, _) when x >= lv > move_to x (move_up pointer)  _ > pointer )  N (_, v, _, _) > match compare x v with  n when n < 0 > (match path with  Right (_, rv, _) when x < rv > move_to x (move_up pointer)  Right _  Root  Left _ > move_to x (move_left pointer) )  n when n > 0 > (match path with  Left (lv, _, _) when x > lv > move_to x (move_up pointer)  Left _  Root  Right _ > move_to x (move_right pointer) )  _ > pointer let rec member_path x = function  Right (l, v, tail) > (match compare x v with  n when n < 0 > member x l  0 > true  _ > member_path x tail )  Left (v, r, tail) > (match compare x v with  n when n > 0 > member x r  0 > true  _ > member_path x tail )  Root > false let rec zipper_member x = function (tree, path) > match tree with  E > member_path x path  N (l, v, r, _) > match compare x v with  n when n < 0 > (match path with  Right (_, rv, _) when x <= rv > member_path x path  Right _  Root  Left _ > member x l )  n when n > 0 > (match path with  Left (lv, _, _) when x >= lv > member_path x path  Left _  Root  Right _ > member x r )  _ > true let current_tree = function (tree, _) > tree let current_value = function (tree, _) > match tree with  E > None  N (_, v, _, _) > Some v let current_value' = function (tree, _) > match tree with  E > raise Empty  N (_, v, _, _) > v let rec zipper_insert x = function ((tree, path) as pointer) > match tree with  E > (match path with  Right (_, rv, _) when x <= rv > zipper_insert x (move_up pointer)  Left (lv, _, _) when x >= lv > zipper_insert x (move_up pointer)  _ > (makeTree E x E, path) )  N (_, v, _, _) > match compare x v with  n when n < 0 > (match path with  Right (_, rv, _) when x < rv > zipper_insert x (move_up pointer)  Right _  Root  Left _ > zipper_insert x (move_left pointer) )  n when n > 0 > (match path with  Left (lv, _, _) when x > lv > zipper_insert x (move_up pointer)  Left _  Root  Right _ > zipper_insert x (move_right pointer) )  _ > pointer let rec zipper_delete x = function ((tree, path) as pointer) > match tree with  E > (match path with  Right (_, rv, _) when x <= rv > zipper_delete x (move_up pointer)  Left (lv, _, _) when x >= lv > zipper_delete x (move_up pointer)  _ > pointer )  N (l, v, r, _) > match compare x v with  n when n < 0 > (match path with  Right (_, rv, _) when x < rv > zipper_delete x (move_up pointer)  Right _  Root  Left _ > zipper_delete x (move_left pointer) )  n when n > 0 > (match path with  Left (lv, _, _) when x > lv > zipper_delete x (move_up pointer)  Left _  Root  Right _ > zipper_delete x (move_right pointer) )  _ > move_to x (appendB l r, path) let rec path_to_list result = function  Root > result  Left (v, r, path) > path_to_list (result @ v :: to_ordered_list r) path  Right (l, v, path) > path_to_list (to_ordered_list_rec (v :: result) l) path let zipper_to_list = function (tree, path) > path_to_list (to_list tree) path Diego Olivier  To unsubscribe, mail camllistrequest@inria.fr Archives: http://caml.inria.fr Bug reports: http://caml.inria.fr/bin/camlbugs FAQ: http://caml.inria.fr/FAQ/ Beginner's list: http://groups.yahoo.com/group/ocaml_beginners