StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
17651683
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
3
CommunityOwnedDate
CreationDate
2013-07-15T10:07:33.587
FavoriteCount
0
LastActivityDate
2013-07-15T12:09:20.687
LastEditDate
2013-07-15T12:09:20.687
LastEditorUserId
1598537
OwnerUserId
1598537
ParentId
17647280
PostTypeId
2
Score
8
ViewCount
0
LastEditorDisplayName
text
Body
It's good practice to be thinking about code reuse this way, and I'll get to that, but first: Using function composition to write more neatly Can I first point out as an aside that I would define your <code>oddOf</code> function more simply using existing functions: <pre><code>oddOf :: Eq a -> a -> [a] -> Bool oddOf value list = odd . length . filter (== value) $ list </code></pre> <code>f $ x = f x</code> but has low precedence, so that's a neater way of writing <code>(not . even . length . filter (== value) ) list</code>. This works by composing functions; we take the list and filter it so we get just the ones that equal the <code>value</code>, using partial application of <code>(==)</code> in the form of an 'operator section' <code>(== value) :: Eq a => a -> Bool</code>. Next we find the <code>length</code> of that, check if it's <code>even</code>, then finally negate the answer with <code>not</code>. This hints at a concise way of writing <code>evenOf</code>: <pre><code>evenOf :: Eq a -> a -> [a] -> Bool evenOf value list = even . length . filter (== value) $ list </code></pre> In fact, since the prelude defines <code>odd</code> as <code>not . even</code> it would be very slightly simpler to start with <code>evenOf</code> and define <code>oddOf</code> from that. Why <code>not . oddOf</code> isn't what you wanted Looking at types, you have <pre><code>not :: Bool -> Bool oddOf :: Eq a => a -> [a] -> Bool (.) :: (b -> bb) -> (a -> b) -> a -> bb -- function composition </code></pre> Now <code>-></code> associates to the right, which means that really, <pre><code>oddOf :: Eq a => a -> ([a] -> Bool) </code></pre> Secretly, that means that Haskell functions only ever take one argument! (What we think of as functions that take more than one argument are actually functions that take one argument then return a function that'll take another, etc...) Unfortunately that means we can't match the types up with <code>(.)</code> directly, because we'd need <code>b</code> to be <code>Bool</code>, not <code>[a] -> Bool</code>. <h2>Simple solutions to your problem</h2> OK, sorry I took a while to get to the answer you wanted, but I think that was all worth saying. <ul> <li>Simple solution 1 is writing <code>evenOf</code> with function composition as I showed you above. <pre><code>oddOf value list = odd . length . filter (== value) $ list evenOf value list = even . length . filter (== value) $ list </code></pre></li> <li>Simple solution 2 is writing <code>evenOf</code> directly from <code>oddOf</code> by supplying all the arguments: <pre><code>evenOf value list = not $ oddOf value list oddOf value list = odd . length . filter (== value) $ list </code></pre></li> <li>Simple solution 3 is writing <code>evenOf value</code> by composing <code>not</code> with <code>oddOf value</code> The only problem with <code>not.oddOf</code> was that <code>oddOf</code> doesn't return a <code>Bool</code> directly, it returns a <code>[a]->Bool</code>. We can fix this by supplying one of the arguments. Notice that <code>oddOf value</code> has type <code>Eq a => [a] -> Bool</code> so we can compose that with <code>not</code>, because it does return a <code>Bool</code>: <pre><code>evenOf value = not . oddOf value oddOf value list = odd . length . filter (== value) $ list </code></pre></li> <li>Simple solution 4 is putting together simple solutions 1 and 2 to write <code>oddOf</code> using <code>evenOf</code> instead: <pre><code>oddOf value list = not $ evenOf value list evenOf value list = even . length . filter (== value) $ list </code></pre> (You could, of course, do the same thing to simple solutions 1 and 3.)</li> </ul> <h1>Awesome brain-changing ways to solve the problem</h1> Every Haskell programmer should read Conal Elliott's excellent <a href="http://conal.net/blog/posts/semantic-editor-combinators">semantic editor combinators webpage/article</a>. In particular, you should read it since it answers your question title "Defining Functions In Relation To Other Functions Without Considering Implementation Details" in a very general way; "Semantic Editor Combinators" is Conal's phrase for exactly that concept. The main idea is that you can edit a function after it's written by writing a sort of path to the value you want to change in brackets, the function you want to apply at that point, then the original function. In this case, you need to apply <code>not</code> to the result (<code>::Bool</code>) of the result (<code>::Eq a => [a]->Bool</code>) of the original function (<code>:: Eq a => a -> [a] -> Bool</code>). So if you want to edit the result of the result with <code>not</code>, you do: <pre><code>oddOf = (result.result) not evenOf evenOf value list = even . length . filter (== value) $ list </code></pre> Conal Elliott defines <code>result = (.)</code> because it's conceptually easier, but you could define <pre><code>oddOf = ((.).(.)) not evenOf evenOf value list = even . length . filter (== value) $ list </code></pre> directly if you prefer. If you needed to change <code>more :: a -> b -> [a] -> [b] -> Bool</code>, you could use <pre><code>less = (result.result.result.result) not more </code></pre> or <pre><code>less = ((.).(.).(.).(.)) not more </code></pre> Using the same idea, you can change inside a list, part of a pair, one of the arguments,... Read the paper for a deeper and fuller explanation.
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. PODefining Functions In Relation To Other Functions Without Considering Implementation Details
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USAndrewC
UserOwnerUserId
1. USAndrewC
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. PODefining Functions In Relation To Other Functions Without Considering Implementation Details
 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.