Potential Determining Ion - Revision history

en>Yobot: Tagging using AWB (10469)

2014-09-21T11:22:01Z

Tagging using AWB (10469)

← Older revision		Revision as of 13:22, 21 September 2014
Line 1:		Line 1:
	~~{{Wikibooks\|Haskell\|Zippers}}~~		Irwin Butts is what my wife enjoys to contact me although I don't really like being known as like that. North Dakota is our birth place. Playing baseball is over the counter std test ([http://kgmcscs.realmind.net/xe/467281 hop over to this site]) pastime he will by no means stop doing. Hiring is her working day job now but she's usually wanted her own business.

	~~A '''zipper'''~~ is a technique of representing an aggregate [[data structure]] so that it is convenient for writing programs that traverse the structure arbitrarily and update its contents, especially in [[purely functional\|purely]] [[functional programming language]]s. The zipper was described by [[Gérard Huet]] in 1997.<ref>{{harvnb\|Huet\|1997}}</ref> It includes and generalizes the [[gap buffer]] technique sometimes used with arrays.

	The zipper technique is general in the sense that it can be adapted to [[List (computing)\|lists]], [[Tree (data structure)\|trees]], and other [[Recursive data type\|recursively defined]] data structures.
	~~Such modified data structures are usually referred to as "a tree with zipper" or "a list with zipper"~~ to ~~emphasize that the structure is conceptually a tree or list, while the zipper is a detail of the implementation.~~

	~~A layman~~'s explanation for a tree with zipper would be an ordinary computer filesystem with operations to go to parent (often <code>cd ..</code>), and the possibility to go downwards (<code>cd subdirectory</code>). The zipper is the pointer to the current path. Behind the scenes the zippers are efficient when making (functional) changes to a data structure, where a new, slightly changed, data structure is returned from an edit operation (instead of making a change in the current data structure).

	~~==Example: Bidirectional list traversal==~~
	~~Many common data structures in computer science can be expressed~~ as ~~the structure generated by a few primitive [[constructor operation]]s or [[observer operation]]s.~~
	~~These include the structure of finite lists, which can be generated by two operations:~~

	*Empty: Constructs an empty list
	*Insert(x, L): Constructs a list by inserting value x in front of list L

	The list [1, 2, 3] is then constructed as Insert(1, Insert(2, Insert(3, Empty))). It is possible to describe the location of a value in a list as the number of steps from the front of the list to that value.
	~~More formally, a location is the number of additional Insert operations used to construct the whole list, after a particular value was inserted.~~

	~~A context for a location in the list is constructed by recording not just the number of Insert operations, but all of the other information about them—namely, the values that were inserted.~~
	~~These are represented in a separate list that is reversed from the order of the original data structure.~~
	~~Specifically, the context of "3" in the list [1, 2, 3] is represented as [2, 1].~~
	~~A list with a zipper represents the entire structure, and a location within the structure.~~
	~~This is a pair consisting of the location's context, and the part of the structure~~ that ~~begins at the location~~. ~~The list [1, 2, 3, 4] with a reference to the "3"~~ is ~~represented as ([2, 1], [3, 4])~~.

	~~With the list represented this way, it~~ is ~~easy to define efficient operations that move the location forward or backward and manipulate the list at that location, for example by inserting or removing items.~~
	~~Similarly, applying the zipper transformation to a tree makes it easy to insert or remove values at a particular location in~~ the ~~tree.~~

	~~==Uses==~~
	The zipper is often used where there is some concept of '[[Focus (computing)\|focus']] or of moving around in some set of data, since its semantics reflect that of moving around but in a functional non-destructive manner.

	~~The zipper has been used in~~
	* [[Xmonad]], to manage focus and placement of [[Window (~~computing)\|windows]] <!-- and focus in general? -->~~
	* Huet's papers cover a [[structural editor]]<ref>[http://~~citeseerx.ist~~.~~psu~~.~~edu~~/~~viewdoc~~/~~summary?doi=10.1.1.19.445 "Functional Pearl: Weaving a web"].</ref> based on zippers and a [[Automated theorem prover\|theorem prover]]~~
	* A [[filesystem]] (ZipperFS) written in [[Haskell (programming language)\|Haskell]] offering "...transactional semantics; undo of any file and directory operation; snapshots; statically guaranteed the strongest, repeatable read, isolation mode for clients; pervasive copy-on-write for files and directories; built-in traversal facility; and just the right behavior for cyclic directory references."<ref>[http://okmij.org/ftp/continuations/zipper.html#zipper-fs Generic Zipper: the context of a traversal]</ref>
	* [[Clojure]] has extensive support for zippers. <ref>{{cite web\|author=jafingerhut \|url=http://clojuredocs.org/clojure_core/clojure.zip/zipper \|title=clojure.zip/zipper \|publisher=ClojureDocs \|date=2010-10-22 \|accessdate=2013-06-15}}</ref>

	~~==Zipper contexts and differentiation==~~
	It has been shown that the type of the items in the context list produced by the zipper transformation is the "[[derivative (generalizations)#Type theory\|derivative]]" of the original type in a sense that is related to ~~[[derivative\|differentiation]] in [[calculus]] by [[decategorification]].~~
	~~Most datatypes are constructed from products and sums of datatypes; any given datatype looks like a [[polynomial]] or a [[Taylor series~~]], and the representation of the type of context items looks like the derivative of that polynomial or series.<ref>Joyal, André (1981), "Une théorie combinatoire des séries formelles", Advances in Mathematics 42:1-82.</ref><ref>McBride, Conor (2001), [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.8611 "The Derivative of a Regular Type is its Type of One-Hole Contexts"]</ref> In a recursive datatype like a list or a tree, the derivative is taken with respect to the recursion variable.

	~~Consider a recursive data structure like a binary tree labeled~~ by ~~data of type A.~~
	~~<div class="center" style="width:auto; margin-left:auto; margin-right:auto;"><math>T(A, R) = 1 + A\cdot R^2</math></div>~~
	~~That is, a tree is either empty, or a triple consisting of a value of type <math>A</math> and two subtrees of type <math>R</math>. The datatype of the context is~~
	~~<div class="center" style="width:auto; margin-left:auto; margin-right:auto;"><math>\frac{d T(A, R)}{d R} = A\cdot 2\cdot R~~.~~</math></div>~~
	~~By taking the fixed point <math>R = T(A, R),</math> we find that a zipper for a tree consists of a "path" and a downward subtree, where a path is a context list of triples consisting of~~

	* a value for the root of the tree (type A)
	* a choice of left or right subtree in which to find the hole (type 2), and
	* the value of the other subtree (type R).

	In general, then, a zipper for a datatype <math>T</math> parameterized by some other type <math>A</math> and a recursion variable <math>R</math> consists of two parts: a context list with items of type <math>\frac{d T(A, R)}{dR}\|_{R = T(A, R)}</math> and a copy of the downward substructure <math>T(A,R)\|_{R = T(A,R)}.</math>

	~~==Alternatives and extensions==~~
	~~===Direct modification===~~
	In a non-purely-functional programming language, it may be more convenient to simply traverse the original data structure and modify it directly (perhaps after [[object copy\|deep cloning]] it, to avoid affecting other code that might hold a reference to it).

	~~===Generic zipper===~~
	The Generic Zipper<ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip1/\|title=From walking to zipping, part 1\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref><ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip2/\|title=From walking to zipping, part 2\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref><ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip3/\|title=From walking to zipping, part 3\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref> is a technique to achieve the same goal as the conventional zipper by capturing the state of the traversal in a continuation while visiting each node. (The Haskell code given in the reference uses [[Generic programming#Generic programming in Haskell\|generic programming]] to generate a traversal function for any data structure, but ~~this is optional – any suitable traversal function can be used.)~~

	~~However, the Generic Zipper involves [[inversion of control]], so some uses of it require a [[state machine]] (or equivalent) to keep track of what to do next.~~

	~~==References==~~
	~~{{reflist\|2}}~~

	~~==Further reading==~~
	* {{cite journal\|last=Huet\|first=Gerard\|url=http://www.st.cs.uni-sb.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf\|title=Functional Pearl: The Zipper\|journal=Journal of Functional Programming\|volume=7\|issue=5\|pages=549–554\|date=September 1997\|year=1997\|ref=harv}}
	* Hinze, Ralf, et al. [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.1.6342 "Type-indexed data types"]. 23 July 2003

	~~==External links==~~
	* [http://www.haskell.org/haskellwiki/Zipper Zipper]
	* [http://en.wikibooks.org/wiki/Haskell/Zippers Theseus and the Zipper]
	* [http://donsbot.wordpress.com/2007/05/17/roll-your-own-window-manager-tracking-focus-with-a-zipper/7 "Roll Your Own Window Manager: Tracking Focus with a Zipper"]
	* [http://www.nist.gov/dads/HTML/zipper.html Definition]
	* [http://www.eecs.harvard.edu/~nr/pubs/zipcfg-abstract.html "An Applicative Control-Flow Graph Based on Huet's ~~Zipper"]~~
	* [http://sigfpe.blogspot.com/2006/09/infinitesimal-types.~~html Infinitesimal Types]~~
	~~{{Use dmy dates\|date=February 2011}}~~

	~~[[Category:Functional programming]]~~
	~~[[Category:Data structures]]~~

en>BG19bot: WP:CHECKWIKI error fix for #61. Punctuation goes before References. Do general fixes if a problem exists. - using AWB (9916)

2014-02-04T06:16:08Z

WP:CHECKWIKI error fix for #61. Punctuation goes before References. Do general fixes if a problem exists. - using AWB (9916)

← Older revision		Revision as of 08:16, 4 February 2014
Line 1:		Line 1:
	~~Greetings! I am Myrtle Shroyer~~. ~~California~~ is where I'~~ve always~~ been ~~living~~ and ~~I love each working day residing here~~. ~~Managing people~~ has been ~~his working day occupation for~~ a ~~while~~. The ~~preferred pastime~~ for ~~my children~~ and me is to ~~perform baseball but I haven't produced~~ a ~~dime~~ with it.<br><br>My blog ~~post~~: [http://~~Www~~.~~pinaydiaries~~.com/~~user~~/~~LConsiden~~ http://~~Www~~.~~pinaydiaries~~.com/~~user~~/~~LConsiden~~]		{{Wikibooks\|Haskell\|Zippers}}

			A '''zipper''' is a technique of representing an aggregate [[data structure]] so that it is convenient for writing programs that traverse the structure arbitrarily and update its contents, especially in [[purely functional\|purely]] [[functional programming language]]s. The zipper was described by [[Gérard Huet]] in 1997.<ref>{{harvnb\|Huet\|1997}}</ref> It includes and generalizes the [[gap buffer]] technique sometimes used with arrays.

			The zipper technique is general in the sense that it can be adapted to [[List (computing)\|lists]], [[Tree (data structure)\|trees]], and other [[Recursive data type\|recursively defined]] data structures.
			Such modified data structures are usually referred to as "a tree with zipper" or "a list with zipper" to emphasize that the structure is conceptually a tree or list, while the zipper is a detail of the implementation.

			A layman's explanation for a tree with zipper would be an ordinary computer filesystem with operations to go to parent (often <code>cd ..</code>), and the possibility to go downwards (<code>cd subdirectory</code>). The zipper is the pointer to the current path. Behind the scenes the zippers are efficient when making (functional) changes to a data structure, where a new, slightly changed, data structure is returned from an edit operation (instead of making a change in the current data structure).

			==Example: Bidirectional list traversal==
			Many common data structures in computer science can be expressed as the structure generated by a few primitive [[constructor operation]]s or [[observer operation]]s.
			These include the structure of finite lists, which can be generated by two operations:

			*Empty: Constructs an empty list
			*Insert(x, L): Constructs a list by inserting value x in front of list L

			The list [1, 2, 3] is then constructed as Insert(1, Insert(2, Insert(3, Empty))). It is possible to describe the location of a value in a list as the number of steps from the front of the list to that value.
			More formally, a location is the number of additional Insert operations used to construct the whole list, after a particular value was inserted.

			A context for a location in the list is constructed by recording not just the number of Insert operations, but all of the other information about them—namely, the values that were inserted.
			These are represented in a separate list that is reversed from the order of the original data structure.
			Specifically, the context of "3" in the list [1, 2, 3] is represented as [2, 1].
			A list with a zipper represents the entire structure, and a location within the structure.
			This is a pair consisting of the location's context, and the part of the structure that begins at the location. The list [1, 2, 3, 4] with a reference to the "3" is represented as ([2, 1], [3, 4]).

			With the list represented this way, it is easy to define efficient operations that move the location forward or backward and manipulate the list at that location, for example by inserting or removing items.
			Similarly, applying the zipper transformation to a tree makes it easy to insert or remove values at a particular location in the tree.

			==Uses==
			The zipper is often used where there is some concept of '[[Focus (computing)\|focus']] or of moving around in some set of data, since its semantics reflect that of moving around but in a functional non-destructive manner.

			The zipper has been used in
			* [[Xmonad]], to manage focus and placement of [[Window (computing)\|windows]] <!-- and focus in general? -->
			* Huet's papers cover a [[structural editor]]<ref>[http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.19.445 "Functional Pearl: Weaving a web"].</ref> based on zippers and a [[Automated theorem prover\|theorem prover]]
			* A [[filesystem]] (ZipperFS) written in [[Haskell (programming language)\|Haskell]] offering "...transactional semantics; undo of any file and directory operation; snapshots; statically guaranteed the strongest, repeatable read, isolation mode for clients; pervasive copy-on-write for files and directories; built-in traversal facility; and just the right behavior for cyclic directory references."<ref>[http://okmij.org/ftp/continuations/zipper.html#zipper-fs Generic Zipper: the context of a traversal]</ref>
			* [[Clojure]] has extensive support for zippers. <ref>{{cite web\|author=jafingerhut \|url=http://clojuredocs.org/clojure_core/clojure.zip/zipper \|title=clojure.zip/zipper \|publisher=ClojureDocs \|date=2010-10-22 \|accessdate=2013-06-15}}</ref>

			==Zipper contexts and differentiation==
			It has been shown that the type of the items in the context list produced by the zipper transformation is the "[[derivative (generalizations)#Type theory\|derivative]]" of the original type in a sense that is related to [[derivative\|differentiation]] in [[calculus]] by [[decategorification]].
			Most datatypes are constructed from products and sums of datatypes; any given datatype looks like a [[polynomial]] or a [[Taylor series]], and the representation of the type of context items looks like the derivative of that polynomial or series.<ref>Joyal, André (1981), "Une théorie combinatoire des séries formelles", Advances in Mathematics 42:1-82.</ref><ref>McBride, Conor (2001), [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.8611 "The Derivative of a Regular Type is its Type of One-Hole Contexts"]</ref> In a recursive datatype like a list or a tree, the derivative is taken with respect to the recursion variable.

			Consider a recursive data structure like a binary tree labeled by data of type A.
			<div class="center" style="width:auto; margin-left:auto; margin-right:auto;"><math>T(A, R) = 1 + A\cdot R^2</math></div>
			That is, a tree is either empty, or a triple consisting of a value of type <math>A</math> and two subtrees of type <math>R</math>. The datatype of the context is
			<div class="center" style="width:auto; margin-left:auto; margin-right:auto;"><math>\frac{d T(A, R)}{d R} = A\cdot 2\cdot R.</math></div>
			By taking the fixed point <math>R = T(A, R),</math> we find that a zipper for a tree consists of a "path" and a downward subtree, where a path is a context list of triples consisting of

			* a value for the root of the tree (type A)
			* a choice of left or right subtree in which to find the hole (type 2), and
			* the value of the other subtree (type R).

			In general, then, a zipper for a datatype <math>T</math> parameterized by some other type <math>A</math> and a recursion variable <math>R</math> consists of two parts: a context list with items of type <math>\frac{d T(A, R)}{dR}\|_{R = T(A, R)}</math> and a copy of the downward substructure <math>T(A,R)\|_{R = T(A,R)}.</math>

			==Alternatives and extensions==
			===Direct modification===
			In a non-purely-functional programming language, it may be more convenient to simply traverse the original data structure and modify it directly (perhaps after [[object copy\|deep cloning]] it, to avoid affecting other code that might hold a reference to it).

			===Generic zipper===
			The Generic Zipper<ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip1/\|title=From walking to zipping, part 1\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref><ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip2/\|title=From walking to zipping, part 2\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref><ref>{{cite web\|url=http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WalkZip3/\|title=From walking to zipping, part 3\|author=Chung-chieh Shan, Oleg Kiselyov\|date=17 August 2008\|accessdate=29 August 2011}}</ref> is a technique to achieve the same goal as the conventional zipper by capturing the state of the traversal in a continuation while visiting each node. (The Haskell code given in the reference uses [[Generic programming#Generic programming in Haskell\|generic programming]] to generate a traversal function for any data structure, but this is optional – any suitable traversal function can be used.)

			However, the Generic Zipper involves [[inversion of control]], so some uses of it require a [[state machine]] (or equivalent) to keep track of what to do next.

			==References==
			{{reflist\|2}}

			==Further reading==
			* {{cite journal\|last=Huet\|first=Gerard\|url=http://www.st.cs.uni-sb.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf\|title=Functional Pearl: The Zipper\|journal=Journal of Functional Programming\|volume=7\|issue=5\|pages=549–554\|date=September 1997\|year=1997\|ref=harv}}
			* Hinze, Ralf, et al. [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.1.6342 "Type-indexed data types"]. 23 July 2003

			==External links==
			* [http://www.haskell.org/haskellwiki/Zipper Zipper]
			* [http://en.wikibooks.org/wiki/Haskell/Zippers Theseus and the Zipper]
			* [http://donsbot.wordpress.com/2007/05/17/roll-your-own-window-manager-tracking-focus-with-a-zipper/7 "Roll Your Own Window Manager: Tracking Focus with a Zipper"]
			* [http://www.nist.gov/dads/HTML/zipper.html Definition]
			* [http://www.eecs.harvard.edu/~nr/pubs/zipcfg-abstract.html "An Applicative Control-Flow Graph Based on Huet's Zipper"]
			* [http://sigfpe.blogspot.com/2006/09/infinitesimal-types.html Infinitesimal Types]
			{{Use dmy dates\|date=February 2011}}

			[[Category:Functional programming]]
			[[Category:Data structures]]

141.114.195.211 at 20:44, 19 October 2009

2009-10-19T20:44:23Z

New page

Greetings! I am Myrtle Shroyer. California is where I've always been living and I love each working day residing here. Managing people has been his working day occupation for a while. The preferred pastime for my children and me is to perform baseball but I haven't produced a dime with it.<br><br>My blog post: [http://Www.pinaydiaries.com/user/LConsiden http://Www.pinaydiaries.com/user/LConsiden]