# [Haskell-beginners] HLint fails to give suggestions

Darren Grant dedgrant at gmail.com
Wed May 15 20:42:39 CEST 2013

```Ah you're right. :)  A full or type-checking build catches that, but HLint
does not.

type system?

Cheers,
Darren

On Wed, May 15, 2013 at 11:21 AM, irfan hudda <huddairfan at gmail.com> wrote:

>
> 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
> >
> > To subscribe or unsubscribe via the World Wide Web, visit
> > or, via email, send a message with subject or body 'help' to
> >
> > You can reach the person managing the list at
> >
> > 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.
> >
> >
> > 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:
> >
> >
> > The code of this example is also available here:
> >
> > 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
> > > >
> > > > to:
> > > >
> > > >   importTrades outDir csvFile =
> > > >     transformFile
> > > >       csvFile
> > > >       (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/
> > > > Haskell programming
> > > > --
> > > >
> > > > ______________________________**_________________
> > > > Beginners mailing list
> > > > Beginners at haskell.org
>
> > > >
> >
> > > _______________________________________________
> > > Beginners mailing list
> > > Beginners at haskell.org
> >
> >
> >
> >
> > ------------------------------
> >
> > 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=
> > 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: <
> >
> >
> > ------------------------------
> >
> > 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=
> > 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?
> >
> > \$ ~/.cabal/bin/hlint -v
> > HLint v1.8.45, (C) Neil Mitchell 2006-2012
> > -------------- next part --------------
> > An HTML attachment was scrubbed...
> > URL: <
> >
> >
> > ------------------------------
> >
> > 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
> > 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?
> > >
> > > \$ ~/.cabal/bin/hlint -v
> > > HLint v1.8.45, (C) Neil Mitchell 2006-2012
> > >
> > >
> > >
> > > _______________________________________________
> > > Beginners mailing list
> > > Beginners at haskell.org
> > >
> > >
> > -------------- next part --------------
> > An HTML attachment was scrubbed...
> > URL: <
> >
> >
> > ------------------------------
>
> >
> > _______________________________________________
> > Beginners mailing list
> >
> >
> > End of Beginners Digest, Vol 59, Issue 17
> > *****************************************
>
>
> _______________________________________________
> Beginners mailing list