StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
1638263
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2009-10-28T16:08:09.643
FavoriteCount
0
LastActivityDate
2009-10-29T09:14:21.617
LastEditDate
2009-10-29T09:14:21.617
LastEditorUserId
128661
OwnerUserId
128661
ParentId
1637775
PostTypeId
2
Score
7
ViewCount
0
LastEditorDisplayName
text
Body
The code shows how you can generate an arbitrary sequence of numbers by means of 'generators'. generators are a popular tool in dynamic languages like python and enable one to iterate over an arbitrary long sequence without allocating the whole sequence at once. The tracking happens in the lines <pre><code>p->next = pow2next; p->continue_from = 0; </code></pre> Which tells p that it should call pow2next to obtain the next item in the sequence and continue_from = 0 to indicate that where at the start of the sequence. When you call p->next(p) it will in fact just call pow2next with p as it's parameter. For the first call this will simply return 1 and increment continue_from to 2. <pre><code>switch(p->continue_from) { case 0: p->continue_from = 1; return 1; /* ... */ </code></pre> On the second call (continue_from = 2) it will create a new map_gen structure working on a fresh struct pow2s and using the function times2: <pre><code>case 1: p->g = map(times2,pow2()) ; p->continue_from = 2; return p->g->next(p->g) ; /* ... */ </code></pre> All further calls go through p->g->next(p->g) which uses times2 and map_gen to retrieve the next value / create new map_gen structures as needed. All value tracking is done using the struct-member continue_from or by using return codes. While showing an interesting approach to generators in C I have to state that this code leaks memory! As you can see it allocates new structures using malloc but it never free's them. I hope this explanation is not to confusing even if you're just starting to learn C. If you really want to understand generators you may like to have a little python ex-course ;) UPDATE As you stated in your comment none of the generators ever seems to return a value > 2. The key to the increasing numbers lies in the function map_next: <pre><code>int map_next(struct mapgen *p) { return p->f(p->g->next(p->g)); } </code></pre> What this does is, instead of returning a fix, number it applies p->f() (in our case the function times2() to the result of p->g->next(p->g). This is a recursive call. It will continue to call map_next() on each map_gen in the list until it reaches the last one. This last element will return a fix value (either 1 or 2). Which is then passed back to the previous call which will apply times2() on it and return the result to it's caller, which in turn will apply times2() on it and return the result to it's caller.... (you get the idea). All these recursive calls sum up and form the final value. If you print out the result of each pow2next() call you will get this: <pre><code>/* first call */ 1 pow2next: returning 1 pow2next: returning 2 /* times2(1) */ 2 pow2next: returning 1 pow2next: returning 2 /* times2(1) */ pow2next: returning 4 /* times2(2) */ 4 pow2next: returning 1 pow2next: returning 2 /* times2(1) */ pow2next: returning 4 /* times2(2) */ pow2next: returning 8 /* times2(4) */ 8 pow2next: returning 1 pow2next: returning 2 /* times2(1) */ pow2next: returning 4 /* times2(2) */ pow2next: returning 8 /* times2(4) */ pow2next: returning 16 /* times2(8) */ 16 /* and so on */ </code></pre> You can see clearly how the result of the top most call is passed all the way back to the first call to form the result. 
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POGenerators in C
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USShirkrin
UserOwnerUserId
1. USShirkrin
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
1. COThanks for the clear explaination. This is what I understand. On creation of new pow2(), call next() -> returns 1, call next() -> p->g = map_gen1 with fresh pow2s, returns 2*1 call next() -> p->g = map_gen1, returns 2*2, creates map_gen2 with FRESH pow2s On next call, it seems to me that it'll call 2*1 again, but it doesn't seem so? At which point did I get it wrong?
 singulars
 PostPostId
 PO
 UserUserId
 USnubela
2. COI updated my answer to include your comment.
 singulars
 PostPostId
 PO
 UserUserId
 USShirkrin

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.