[Haskell-beginners] HLint fails to give suggestions
irfan hudda
huddairfan at gmail.com
Wed May 15 20:21:20 CEST 2013
Because the code
fun1 :: Int -> String
fun1 1 = "hell"
fun1 2 = 3
has obvious errors I was expecting HLint to display those errors.
On Wed, May 15, 2013 at 11:38 PM, <beginners-request at haskell.org> wrote:
>
> Send Beginners mailing list submissions to
> beginners at haskell.org
>
> To subscribe or unsubscribe via the World Wide Web, visit
> http://www.haskell.org/mailman/listinfo/beginners
> or, via email, send a message with subject or body 'help' to
> beginners-request at haskell.org
>
> You can reach the person managing the list at
> beginners-owner at haskell.org
>
> When replying, please edit your Subject line so it is more specific
> than "Re: Contents of Beginners digest..."
>
>
> Today's Topics:
>
> 1. Re: Diagrams brain twister (Brent Yorgey)
> 2. Re: How to improve lazyness of a foldl (and memory
> footprint) (Brent Yorgey)
> 3. find by (Julian Arni)
> 4. find by (Julian Arni)
> 5. Re: find by (Brent Yorgey)
> 6. HLint fails to give suggestions (irfan hudda)
> 7. Re: HLint fails to give suggestions (Darren Grant)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Wed, 15 May 2013 12:21:50 -0400
> From: Brent Yorgey <byorgey at seas.upenn.edu>
> Subject: Re: [Haskell-beginners] Diagrams brain twister
> To: beginners at haskell.org
> Cc: diagrams-discuss at googlegroups.com
> Message-ID: <20130515162150.GA17348 at seas.upenn.edu>
> Content-Type: text/plain; charset=us-ascii
>
> On Wed, May 15, 2013 at 11:06:28AM +0800, Adrian May wrote:
> > Hi all,
> >
> > I'm trying to draw a picture with diagrams (this isn't the gantt chart I
> > was talking about before.)
> >
> > I have a load of objects strewn around a diagram according to their own
> > sweet logic, and for *some* of them, I want to draw a horizontal line
going
> > from the right hand edge of the object to some globally fixed x
coordinate,
> > call it the "margin". So those lines are all different lengths because
the
> > objects are all over the place, but their right-hand ends should all be
> > aligned vertically.
> >
> > This seems quite hard, because that sweet logic is already quite
> > complicated and local to a set of objects in the immediate
neighbourhood of
> > the object in question. Somehow I have to tease out a selection of them
and
> > process each of them into this line whose properties depend on where the
> > object is from the global perspective.
>
> Hi Adrian,
>
> Actually, diagrams provides some tools specifically for accomplishing
> this kind of thing, so it is not that bad. (This question would
> probably be more appropriate on the diagrams mailing list---it has to
> do with the workings of diagrams in particular and not much to do with
> Haskell in general---so I'm also cc'ing that mailing list. Luckily I
> am subscribed to both. =)
>
> The key is that you can give names to subparts of your diagram,
> combine them using whatever arbitrarily complicated logic you want,
> and then later learn some things about where they ended up in the
> overall diagram. Here is an example:
>
> > {-# LANGUAGE NoMonomorphismRestriction #-}
> >
> > import Data.Maybe (fromMaybe)
> > import Diagrams.Backend.SVG.CmdLine -- or Cairo, etc.
> > import Diagrams.Prelude
> >
> > -- We can "mark" things just by giving them the name ()
> > mark = named ()
> >
> > -- A bunch of stuff, each positioned according to its own sweet logic,
> > -- some of which are marked. Note, it's critical that we mark each
> > -- subdiagram *after* any transformations which we want to affect how
> > -- its "right edge" is determined (e.g. the scaleX on the circle
> > -- below), but *before* any transformations which serve to position it
> > -- in the overall diagram (e.g. the translations of the pentagon and
> > -- square).
> > stuff = ( triangle 3 # mark
> > ===
> > circle 1
> > )
> > |||
> > ( pentagon 2 # mark # translateY 5
> > ===
> > circle 0.5 # scaleX 3 # mark
> > )
> > |||
> > ( square 2 # mark # translateY 2 )
> >
> > -- Draw horizontal lines extending from the right edges of any marked
> > -- subdiagram to the given x-coordinate. Extract all the marked
> > -- subdiagrams using 'withNameAll ()', turn each into a function to
> > -- draw the required line, and apply all of them.
> > drawLinesTo x = withNameAll () $ \subs -> applyAll (map drawLineFrom
subs)
> > where
> > drawLineFrom sub = atop (edgePt ~~ xPoint)
> > where
> > -- Compute the point on the right edge of the subdiagram. This
> > -- is a little ugly at the moment; I hope to add combinators
> > -- to make this nicer.
> > edgePt = fromMaybe origin (maxTraceP (location sub) unitX sub)
> > -- Compute the other endpoint of the segment.
> > y = snd (unp2 (location sub))
> > xPoint = p2 (x,y)
> >
> > main = defaultMain (stuff # drawLinesTo 13 # centerXY # pad 1.1)
>
> which produces this output:
>
> http://www.cis.upenn.edu/~byorgey/hosted/Adrian.pdf
>
> The code of this example is also available here:
> https://github.com/byorgey/diagrams-play/blob/master/Adrian.hs .
>
> Hope this helps! If you have more questions feel free to ask on the
> diagrams mailing list or in the #diagrams IRC channel on freenode.
>
> -Brent
>
>
>
> ------------------------------
>
> Message: 2
> Date: Wed, 15 May 2013 12:27:09 -0400
> From: Brent Yorgey <byorgey at seas.upenn.edu>
> Subject: Re: [Haskell-beginners] How to improve lazyness of a foldl
> (and memory footprint)
> To: beginners at haskell.org
> Message-ID: <20130515162709.GB17348 at seas.upenn.edu>
> Content-Type: text/plain; charset=us-ascii
>
> For any associative binary operator (+) with an identity element z, foldl
and
> foldr are equivalent, that is,
>
> foldl (+) z === foldr (+) z
>
> The first yields something like
>
> ((z + a) + b) + c
>
> whereas the second yields
>
> a + (b + (c + z))
>
> but with associativity and the fact that z is an identity it is not
> hard to see that these are equal. However, as you found out, that
> does not necessarily mean they have the same performance!
>
> Since atop is associative you could just replace foldl with foldr. In
> fact, atop is the binary operation for the Monoid instance of
> diagrams, so you can just write 'mconcat' in place of 'foldr atop
> mempty'.
>
> -Brent
>
> On Wed, May 15, 2013 at 09:35:34AM +0200, Giacomo Tesio wrote:
> > Thanks a lot!
> >
> > Yesterday on freenode's #haskell channel Cane noted how my laziness
problem
> > reside in the foldl use in foldTradingSample.
> > I have to turn it into a foldr (but I'm still unsure how...)
> >
> >
> > Giacomo
> >
> >
> > On Wed, May 15, 2013 at 12:46 AM, Henk-Jan van Tuyl <hjgtuyl at chello.nl
>wrote:
> >
> > > On Tue, 14 May 2013 11:22:27 +0200, Giacomo Tesio <giacomo at tesio.it>
> > > wrote:
> > >
> > > Hi, I'm trying to improve a small haskell program of mine.
> > >>
> > > :
> > >
> > > Some remarks:
> > >
> > > 0) Use hlint (available on Hackage) for improvement suggestions
> > > 1) You don't have to write the module heading in Main.hs, it is not a
> > > library (why export main?)
> > > 2) Change "print" to "putStrLn" if you want to display messages
without
> > > quotes
> > > 2) switchArgs is only partially defined, add something like:
> > > switchArgs [x] = putStrLn $ "Unknown tool: " ++ x
> > > 3) Use shorter lines, for example change:
> > >
> > > importTrades outDir csvFile = transformFile csvFile
(foldTradingSample.*
> > > *getTickWriteTrades) (saveTradingSamples outDir)
> > >
> > > to:
> > >
> > > importTrades outDir csvFile =
> > > transformFile
> > > csvFile
> > > (foldTradingSample.**getTickWriteTrades)
> > > (saveTradingSamples outDir)
> > > 4) It is considered good practice, to write the function
> > > composition operator between spaces (change f.g to f . g)
> > >
> > > I have analyze your software further to see how sufficient laziness
can be
> > > reached.
> > >
> > > Regards,
> > > Henk-Jan van Tuyl
> > >
> > >
> > > --
> > > Folding at home
> > > What if you could share your unused computer power to help find a
cure? In
> > > just 5 minutes you can join the world's biggest networked computer
and get
> > > us closer sooner. Watch the video.
> > > http://folding.stanford.edu/
> > >
> > >
> > > http://Van.Tuyl.eu/
> > > http://members.chello.nl/**hjgtuyl/tourdemonad.html<
http://members.chello.nl/hjgtuyl/tourdemonad.html>
> > > Haskell programming
> > > --
> > >
> > > ______________________________**_________________
> > > Beginners mailing list
> > > Beginners at haskell.org
> > > http://www.haskell.org/**mailman/listinfo/beginners<
http://www.haskell.org/mailman/listinfo/beginners>
> > >
>
> > _______________________________________________
> > Beginners mailing list
> > Beginners at haskell.org
> > http://www.haskell.org/mailman/listinfo/beginners
>
>
>
>
> ------------------------------
>
> Message: 3
> Date: Wed, 15 May 2013 13:05:07 -0400
> From: Julian Arni <julian at edx.org>
> Subject: [Haskell-beginners] find by
> To: Beginners at haskell.org
> Message-ID:
> <CANct4CS4KoLra=
sepw_KD5jZePJjkmAdBCCG1SuuAAxVDeyuEw at mail.gmail.com>
> Content-Type: text/plain; charset="iso-8859-1"
>
> (For some reason my previous post seems to have been truncated.)
>
> I have a function that, simplifying a little, looks like this:
>
> fn :: [a] -> a
> fn = (head .) . takeWhile $ (\_ -> True)
>
> >From this, I want a function with the signature fn' :: [(x,a)] -> (x,a)
> such that:
>
> snd $ fn' (zip [x] [a]) = fn [a]
>
> I can see ways of doing this by altering fn, or by repeating some of fn in
> the definition of fn', or (because in this case I know that if fn xs = x,
> fn is returning the first x in xs and not any others), by doing something
> nasty like:
>
> fn' xs = xs !! fromMaybe 0 (findIndex (\(_,a) -> a == fn (snd $ unzip
> xs)) xs )
>
> But it seems to me like there should be prettier solutions to this (that
*do
> not* involve changing the definition of fn). After all, this doesn't seem
> like a rare pattern.
>
> Anyone know if in fact there's a better way to go about it?
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <
http://www.haskell.org/pipermail/beginners/attachments/20130515/7bb09f56/attachment.htm
>
>
> ------------------------------
>
> Message: 4
> Date: Wed, 15 May 2013 13:09:37 -0400
> From: Julian Arni <julian at edx.org>
> Subject: [Haskell-beginners] find by
> To: Beginners at haskell.org
> Message-ID:
> <CANct4CTOFLbkND1n1yDamfPu1k3=
PoeL4ZV0paCEhGF4kad0Zw at mail.gmail.com>
> Content-Type: text/plain; charset=ISO-8859-1
>
> (Truncated again - trying plain text. Sorry for the spam.)
>
> I have a function that, simplifying a little, looks like this:
>
> fn :: [a] -> a
> fn = (head .) . takeWhile $ (\_ -> True)
>
> >From this, I want a function with the signature fn' :: [(x,a)] ->
> (x,a) such that:
>
> snd $ fn' (zip [x] [a]) = fn [a]
>
> I can see ways of doing this by altering fn, or by repeating some of
> fn in the definition of fn', or (because in this case I know that if
> fn xs = x, fn is returning the first x in xs and not any others), by
> doing something nasty like:
>
> fn' xs = xs !! fromMaybe 0 (findIndex (\(_,a) -> a == fn (snd $
> unzip xs)) xs )
>
> But it seems to me like there should be prettier solutions to this
> (that do not involve changing the definition of fn). After all, this
> doesn't seem like a rare pattern.
>
> Anyone know if in fact there's a better way to go about it?
>
>
>
> ------------------------------
>
> Message: 5
> Date: Wed, 15 May 2013 14:03:56 -0400
> From: Brent Yorgey <byorgey at seas.upenn.edu>
> Subject: Re: [Haskell-beginners] find by
> To: beginners at haskell.org
> Message-ID: <20130515180356.GA18624 at seas.upenn.edu>
> Content-Type: text/plain; charset=us-ascii
>
> On Wed, May 15, 2013 at 01:09:37PM -0400, Julian Arni wrote:
> > (Truncated again - trying plain text. Sorry for the spam.)
> >
> > I have a function that, simplifying a little, looks like this:
> >
> > fn :: [a] -> a
> > fn = (head .) . takeWhile $ (\_ -> True)
> >
> > From this, I want a function with the signature fn' :: [(x,a)] ->
> > (x,a) such that:
> >
> > snd $ fn' (zip [x] [a]) = fn [a]
> >
> > I can see ways of doing this by altering fn, or by repeating some of
> > fn in the definition of fn', or (because in this case I know that if
> > fn xs = x, fn is returning the first x in xs and not any others), by
> > doing something nasty like:
> >
> > fn' xs = xs !! fromMaybe 0 (findIndex (\(_,a) -> a == fn (snd $
> > unzip xs)) xs )
> >
> > But it seems to me like there should be prettier solutions to this
> > (that do not involve changing the definition of fn). After all, this
> > doesn't seem like a rare pattern.
> >
> > Anyone know if in fact there's a better way to go about it?
>
> This is not possible. The problem is that given
>
> fn :: [A] -> A
>
> there is no way to tell where it found the particular value of type A
> in the list (unless, as you say, you happen to know something extra
> about the A's and how the function works). And since it takes
> specifically a list of type A, there is no way to give it a list with
> some "extra" information tagged onto the A's. Your only option is to
> generalize fn somehow.
>
> You say "this doesn't seem like a rare pattern"; as a counterpoint, I
> don't think I have ever wanted it. A function with the type of fn
> does not seem very useful -- what should it do on the empty list? And
> why not just use something like 'find' directly?
>
> -Brent
>
>
>
> ------------------------------
>
> Message: 6
> Date: Wed, 15 May 2013 23:34:09 +0530
> From: irfan hudda <huddairfan at gmail.com>
> Subject: [Haskell-beginners] HLint fails to give suggestions
> To: beginners at haskell.org
> Message-ID:
> <
CAC5dnm6VqeC-hHSGMKZjV0bz6LVo5hr7dE5BEUWLCafVNyBbqw at mail.gmail.com>
> Content-Type: text/plain; charset="iso-8859-1"
>
> I install HLint via cabal (output http://hpaste.org/88021)
> To check if it was working I used following code
>
> fun1 :: Int -> String
> fun1 1 = "hell"
> fun1 2 = 3
>
> and ran HLint on it
> $ ~/.cabal/bin/hlint hlint_test.hs
> No suggestions
>
> and it ouputs no suggestions
> any ideas?
>
> Additionally
> $ ~/.cabal/bin/hlint -v
> HLint v1.8.45, (C) Neil Mitchell 2006-2012
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <
http://www.haskell.org/pipermail/beginners/attachments/20130515/5b3396f0/attachment-0001.htm
>
>
> ------------------------------
>
> Message: 7
> Date: Wed, 15 May 2013 11:08:23 -0700
> From: Darren Grant <dedgrant at gmail.com>
> Subject: Re: [Haskell-beginners] HLint fails to give suggestions
> To: The Haskell-Beginners Mailing List - Discussion of primarily
> beginner-level topics related to Haskell <beginners at haskell.org>
> Message-ID:
> <CA+9vpFfAzxVF4v_fF-EKi=
Bq9SBVSajQucuiS_AfBebfb3sqsw at mail.gmail.com>
> Content-Type: text/plain; charset="iso-8859-1"
>
> Were you expecting a specific suggestion?
>
>
>
> On Wed, May 15, 2013 at 11:04 AM, irfan hudda <huddairfan at gmail.com>
wrote:
>
> > I install HLint via cabal (output http://hpaste.org/88021)
> > To check if it was working I used following code
> >
> > fun1 :: Int -> String
> > fun1 1 = "hell"
> > fun1 2 = 3
> >
> > and ran HLint on it
> > $ ~/.cabal/bin/hlint hlint_test.hs
> > No suggestions
> >
> > and it ouputs no suggestions
> > any ideas?
> >
> > Additionally
> > $ ~/.cabal/bin/hlint -v
> > HLint v1.8.45, (C) Neil Mitchell 2006-2012
> >
> >
> >
> > _______________________________________________
> > Beginners mailing list
> > Beginners at haskell.org
> > http://www.haskell.org/mailman/listinfo/beginners
> >
> >
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <
http://www.haskell.org/pipermail/beginners/attachments/20130515/f67bcf5a/attachment.htm
>
>
> ------------------------------
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
>
>
> End of Beginners Digest, Vol 59, Issue 17
> *****************************************
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/beginners/attachments/20130515/fdc86741/attachment-0001.htm>
More information about the Beginners
mailing list