StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
8286651
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
6
CommunityOwnedDate
CreationDate
2011-11-27T15:31:02.520
FavoriteCount
0
LastActivityDate
2011-11-27T16:44:10.600
LastEditDate
2011-11-27T16:44:10.600
LastEditorUserId
828361
OwnerUserId
828361
ParentId
8286443
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
Will this do? <pre><code>flip . (evalState .) . traverse . traverse . const . state $ head &&& tail </code></pre> EDIT: let me expand on the construction... The essential centre of it is <code>traverse . traverse</code>. If you stare at the problem with sufficiently poor spectacles, you can see that it's "do something with the elements of a container of containers". For that sort of thing, <code>traverse</code> (from <code>Data.Traversable</code>) is a very useful gadget (ok, I'm biased). <pre><code>traverse :: (Traversable f, Applicative a) => (s -> a t) -> f s -> a (f t) </code></pre> or, if I change to longer but more suggestive type variables <pre><code>traverse :: (Traversable containerOf, Applicative doingSomethingToGet) => (s -> doingSomethingToGet t) -> containerOf s -> doingSomethingToGet (containerOf t) </code></pre> Crucially, <code>traverse</code> preserves the structure of the container it operates on, whatever that might be. If you view <code>traverse</code> as a higher-order function, you can see that it gives back an operator on containers whose type fits with the type of operators on elements it demands. That's to say <code>(traverse . traverse)</code> makes sense, and gives you structure-preserving operations on two layers of container. <pre><code>traverse . traverse :: (Traversable g, Traversable f, Applicative a) => (s -> a t) -> g (f s) -> a (g (f t)) </code></pre> So we've got the key gadget for structure-preserving "do something" operations on lists of lists. The <code>length</code> and <code>splitAt</code> approach works fine for lists (the structure of a list is given by its length), but the essential characteristic of lists which enables that approach is already pretty much bottled by the <code>Traversable</code> class. Now we need to figure out how to "do something". We want to replace the old elements with new things drawn successively from a supply stream. If we were allowed the side-effect of updating the supply, we could say what to do at each element: "return <code>head</code> of supply, updating supply with its <code>tail</code>". The <code>State s</code> monad (in <code>Control.Monad.State</code> which is an instance of <code>Applicative</code>, from <code>Control.Applicative</code>) lets us capture that idea. The type <code>State s a</code> represents computations which deliver a value of type <code>a</code> whilst mutating a state of type <code>s</code>. Typical such computations are made by this gadget. <pre><code>state :: (s -> (a, s)) -> State s a </code></pre> That's to say, given an initial state, just compute the value and the new state. In our case, <code>s</code> is a stream, <code>head</code> gets the value, <code>tail</code> gets the new state. The <code>&&&</code> operator (from <code>Control.Arrow</code>) is a nice way to glue two functions on the same data to get a function making a pair. So <pre><code>head &&& tail :: [x] -> (x, [x]) </code></pre> which makes <pre><code>state $ head &&& tail :: State [x] x </code></pre> and thus <pre><code>const . state $ head &&& tail :: u -> State [x] x </code></pre> explains what to "do" with each element of the old container, namely ignore it and take a new element from the head of the supply stream. Feeding that into <code>(traverse . traverse)</code> gives us a big mutatey traversal of type <pre><code>f (g u) -> State [x] (f (g x)) </code></pre> where <code>f</code> and <code>g</code> are any <code>Traversable</code> structures (e.g. lists). Now, to extract the function we want, taking the initial supply stream, we need to unpack the state-mutating computation as a function from initial state to final value. That's what this does: <pre><code>evalState :: State s a -> s -> a </code></pre> So we end up with something in <pre><code>f (g u) -> [x] -> f (g x) </code></pre> which had better get flipped if it's to match the original spec. tl;dr The <code>State [x]</code> monad is a readymade tool for describing computations which read and update an input stream. The <code>Traversable</code> class captures a readymade notion of structure-preserving operation on containers. The rest is plumbing (and/or golf).
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. PO"Zipping" a plain list with a nested list
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USpigworker
UserOwnerUserId
1. USpigworker
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.