StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
5932839
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
6
CommunityOwnedDate
CreationDate
2011-05-09T05:22:00.783
FavoriteCount
0
LastActivityDate
2011-05-09T05:22:00.783
LastEditDate
LastEditorUserId
0
OwnerUserId
83805
ParentId
5932682
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
The key step you're going to have to make is to think inductively. Your current solution: <pre><code>and :: [Bool] -> Bool and [] = True and [True, True] = True and [False, False] = True and [True, False] = False </code></pre> enumerates some of the possibilities, but it obviously doesn't work for all lists. So how to write one that will work for lists of any length? In Haskell, you can usually write your functions by taking apart a data type. In this case, lists. Lists are defined as: <pre><code>data [a] = [] | a : [a] </code></pre> So, lists have two cases: either the empty list, or a one element with a tail. Let's start writing your <code>and</code> function then, so that it matches those two cases for lists: <pre><code>and [] = True and (a:as) = ... </code></pre> So, the "base case", the empty list, is <code>True</code>. But what should we do for the case of a list with one element, and some tail? Well, we already have the <code>&&</code> function in Haskell: <pre><code>> True && True True > True && False False > False && True False > False && False False </code></pre> Interesting! So, <code>&&</code> takes two arguments, and correctly determines if both arguments are True. And we are currently have a list with one element, and a list for a tail. And at the same time, we're defining the <code>and</code> function, that results in a single boolean value when applied to a list. So we can make the inductive step and use the function we're defining, <code>and</code>, together with the <code>&&</code> binary operator, to finish our definition: <pre><code>and [] = True and (a:as) = a && (and as) </code></pre> So we evaluate the tail of the list to some value (recursively), and use the <code>&&</code> operator to combined that value with the current value, and that's our function written. Recursion and induction, driven by the recursive structure of the lists, are the key technique to learn in programming. If you can write this, you're making a big step forward.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POWriting a recursive function on lists in Haskell
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. This table or related slice is empty.
UserOwnerUserId
1. USDon Stewart
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. POWriting a recursive function on lists in Haskell
 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

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.