StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
2813692
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
2
CommunityOwnedDate
CreationDate
2010-05-11T19:06:41.553
FavoriteCount
0
LastActivityDate
2010-05-11T19:06:41.553
LastEditDate
LastEditorUserId
0
OwnerUserId
333786
ParentId
2813484
PostTypeId
2
Score
1
ViewCount
0
LastEditorDisplayName
text
Body
The lowercase letters in the type declarations are type variables. This means that when there is an <code>a</code> this must be the same type. Bracketed (eg <code>(a -> b)</code>) subexpressions tend to mean that the function accepts a function as one of its parametres. Rectangular brackets indicate a list of something. So <code>map</code> accepts these arguments: <ul> <li><code>(a -> b)</code> a function that accepts one argument</li> <li><code>[a]</code> a list that the first argument function can act on</li> </ul> and produces <code>[b]</code> a list as a result. We can decode <code>(.)</code> the same way: <ul> <li><code>(a -> b)</code> is a function that accepts a single argument</li> <li><code>(c -> a)</code> is a function that produces the same typa as the argument to the first function</li> <li><code>c</code> an argument of the same type that the second function uses</li> </ul> However Haskell can do a neat thing and that is if you omit an argument it returns a function that has the remaining signature. So <code>(.)</code> is commonly used to chain functions. Let's say we have 2 functions <code>ord :: Char -> Int</code> which takes a character and returns it's integer representation and <code>add32 :: Int -> Int</code> that adds 32 to it's argument. When we write <code>upcaseVal = add32 . ord</code> the function upcaseVal now has the signature <code>upcaseVal :: Char -> Int</code> because the <code>(.)</code> function would have left it with <code>c -> b</code> and we substitue thes in the function definition. So <code>foldr map</code> would have to be like this: <ol> <li><code>foldr</code>'s first argument is a function that takes 2 arguments which <code>map</code> is.</li> <li>Since the functions output has to be of the same type as the second argument (<code>(a -> b -> b</code>) we see that in <code>map</code> <code>a = b</code></li> </ol> Thus the final type will be: <pre><code>(b -> b) -> [b] -> [b] -> b -> [b] -> b </code></pre> But I guess that doesn't have to bother you that much since the compiler deals with stuff like this most of the time.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POTypes in Haskell
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USJakub Hampl
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
CommentsPostId
1. COThough I might have gotten confused with the `foldr map` type - take it with a grain of salt.
 singulars
 PostPostId
 PO
 UserUserId
 USJakub Hampl
2. COThe type of `foldr map` is `[b] -> [b -> b] -> [b]`
 singulars
 PostPostId
 PO
 UserUserId
 USsepp2k

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.