StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
11228880
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
0
CommunityOwnedDate
CreationDate
2012-06-27T14:45:49.863
FavoriteCount
0
LastActivityDate
2012-06-27T14:56:55.570
LastEditDate
2012-06-27T14:56:55.570
LastEditorUserId
546084
OwnerUserId
546084
ParentId
11226338
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
You do give everything the return type of <code>Reader Env a</code>, although this isn't as bad as you think. The reason that everything needs this tag is that if <code>f</code> depends on the environment: <pre><code>type Env = Int f :: Int -> Reader Int Int f x = do env <- ask return (x + env) </code></pre> and <code>g</code> calls <code>f</code>: <pre><code>g x = do y <- f x return (x + y) </code></pre> then <code>g</code> also depends on the environment - the value bound in the line <code>y <- f x</code> can be different, depending on what environment is passed in, so the appropriate type for <code>g</code> is <pre><code>g :: Int -> Reader Int Int </code></pre> This is actually a good thing! The type system is forcing you to explicitly recognise the places where your functions depend on the global environment. You can save yourself some typing pain by defining a shortcut for the phrase <code>Reader Int</code>: <pre><code>type Global = Reader Int </code></pre> so that now your type annotations are: <pre><code>f, g :: Int -> Global Int </code></pre> which is a little more readable. <hr> The alternative to this is to explicitly pass the environment around to all of your functions: <pre><code>f :: Env -> Int -> Int f env x = x + env g :: Env -> Int -> Int g x = x + (f env x) </code></pre> This can work, and in fact syntax-wise it's not any worse than using the <code>Reader</code> monad. The difficulty comes when you want to extend the semantics. Say you also depend on having an updatable state of type <code>Int</code> which counts function applications. Now you have to change your functions to: <pre><code>type Counter = Int f :: Env -> Counter -> Int -> (Int, Counter) f env counter x = (x + env, counter + 1) g :: Env -> Counter -> Int -> (Int, Counter) g env counter x = let (y, newcounter) = f env counter x in (x + y, newcounter + 1) </code></pre> which is decidedly less pleasant. On the other hand, if we are taking the monadic approach, we simply redefine <pre><code>type Global = ReaderT Env (State Counter) </code></pre> The old definitions of <code>f</code> and <code>g</code> continue to work without any trouble. To update them to have application-counting semantics, we simply change them to <pre><code>f :: Int -> Global Int f x = do modify (+1) env <- ask return (x + env) g :: Int -> Global Int g x = do modify(+1) y <- f x return (x + y) </code></pre> and they now work perfectly. Compare the two methods: <ul> <li>Explicitly passing the environment and state required a complete rewrite when we wanted to add new functionality to our program.</li> <li>Using a monadic interface required a change of three lines - and the program continued to work even after we had changed the first line, meaning that we could do the refactoring incrementally (and test it after each change) which reduces the likelihood that the refactor introduces new bugs.</li> </ul>
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POAccess environment in a function
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USChris Taylor
UserOwnerUserId
1. USChris Taylor
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POAccess environment in a function
 singulars
 PostTypePostTypeId
 PTQuestion
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. This table or related slice is empty.

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.