Send Beginners mailing list submissions to
[email protected]
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
[email protected]
You can reach the person managing the list at
[email protected]
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: HLint fails to give suggestions (Erik de Castro Lopo)
2. Re: HLint fails to give suggestions (David McBride)
3. Re: find by (Julian Arni)
4. Re: HLint fails to give suggestions (Darren Grant)
5. Re: HLint fails to give suggestions (Darren Grant)
----------------------------------------------------------------------
Message: 1
Date: Wed, 15 May 2013 11:25:35 -0700
From: Erik de Castro Lopo <[email protected]>
Subject: Re: [Haskell-beginners] HLint fails to give suggestions
To: [email protected]
Message-ID: <[email protected]>
Content-Type: text/plain; charset=US-ASCII
irfan hudda wrote:
> Because the code
> fun1 :: Int -> String
> fun1 1 = "hell"
> fun1 2 = 3
> has obvious errors I was expecting HLint to display those errors.
The compiler show errors, hlint provides coding style suggestions.
Two different tools for two different jobs. I usually only run
hlint on code after I am sure it compiles.
Erik
--
----------------------------------------------------------------------
Erik de Castro Lopo
http://www.mega-nerd.com/
------------------------------
Message: 2
Date: Wed, 15 May 2013 14:27:26 -0400
From: David McBride <[email protected]>
Subject: Re: [Haskell-beginners] HLint fails to give suggestions
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CAN+Tr43jYt=BKomaQSZKtSQbupO=rii_aswnwmcwdmtzcgp...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Hlint doesn't compile your code. It only looks for common patterns in
code that are usually bad. It is going on the assumption that your
code already compiled and you are just looking for some advice on
refactoring.
234234 = do
return 1
gives
Blah5.hs:2:10: Error: Redundant do
Found:
do return 1
Why not:
return 1
On Wed, May 15, 2013 at 2:04 PM, irfan hudda <[email protected]> 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
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
------------------------------
Message: 3
Date: Wed, 15 May 2013 14:37:23 -0400
From: Julian Arni <[email protected]>
Subject: Re: [Haskell-beginners] find by
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CANct4CQyi_+d+TMwCmGGXWfs5q3Y5QF=sveomn2fwkcg+ed...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
Thanks a lot for the response.
Yeah, I noticed that a function f :: [a] -> a needn't return an
element of the list (sum, for instance, rarely does), and so from that
perspective I shouldn't be too hopeful. But it doesn't seem all that
pleasant, and probably will be quite repetitive, otherwise. The actual
fn I have is:
fFirst = (head .) . intersect -- Some empty-list checks around it
too, but they're irrelevant for exposition
One of the lists fFirst takes as argument - call it xs - shows up, in
basically a 'zipped' format in other lists (i.e., map fst, map snd,
etc. over those lists is xs). The other list - call is ys - only
exists as a simple list (not of tuples). So yeah,
fNew = head $ filter (\(_,x) -> x `elem` ys)
Would work, I suppose. But the ugly thing is that for each n, given a
list of n-tuples s.t. mapping (\(_,)^n x -> x) over the list returns
my original xs [where here (_,)^n is meta-speak for _, repeated n
times], not only do I have to rewrite this (which I half-expect, given
that I'm working with tuples), but calculations which are intuitively
'the same' are going to have to be done multiple times (I think). It
looks ugly and inefficient.
(P.S.: Might there be some html/mime issues in the list archive?
Possibly some characters aren't properly escaped - I don't really know
- but in the archive my previous emails were all truncated).
On Wed, May 15, 2013 at 2:03 PM, Brent Yorgey <[email protected]> wrote:
> 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
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
------------------------------
Message: 4
Date: Wed, 15 May 2013 11:43:03 -0700
From: Darren Grant <[email protected]>
Subject: Re: [Haskell-beginners] HLint fails to give suggestions
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CA+9vpFco3qYLYdArxM0BKOt8pnDm-kbCqP1=s+gz-xl6qaj...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
David answered my question.
On Wed, May 15, 2013 at 11:27 AM, David McBride <[email protected]> wrote:
> Hlint doesn't compile your code. It only looks for common patterns in
> code that are usually bad. It is going on the assumption that your
> code already compiled and you are just looking for some advice on
> refactoring.
>
> 234234 = do
> return 1
>
> gives
>
> Blah5.hs:2:10: Error: Redundant do
> Found:
> do return 1
> Why not:
> return 1
>
>
> On Wed, May 15, 2013 at 2:04 PM, irfan hudda <[email protected]> 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
> > [email protected]
> > http://www.haskell.org/mailman/listinfo/beginners
> >
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130515/e10eb018/attachment-0001.htm>
------------------------------
Message: 5
Date: Wed, 15 May 2013 11:42:39 -0700
From: Darren Grant <[email protected]>
Subject: Re: [Haskell-beginners] HLint fails to give suggestions
To: The Haskell-Beginners Mailing List - Discussion of primarily
beginner-level topics related to Haskell <[email protected]>
Message-ID:
<CA+9vpFe2_daLZKoAcZYX17UijSD4MjEuS=wnexjimspysdm...@mail.gmail.com>
Content-Type: text/plain; charset="iso-8859-1"
Ah you're right. :) A full or type-checking build catches that, but HLint
does not.
I'm curious about this too; does HLint not need code that checks out in the
type system?
Cheers,
Darren
On Wed, May 15, 2013 at 11:21 AM, irfan hudda <[email protected]> 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, <[email protected]> wrote:
> >
> > Send Beginners mailing list submissions to
> > [email protected]
> >
> > 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
> > [email protected]
> >
> > You can reach the person managing the list at
> > [email protected]
> >
> > 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 <[email protected]>
> > Subject: Re: [Haskell-beginners] Diagrams brain twister
> > To: [email protected]
> > Cc: [email protected]
> > Message-ID: <[email protected]>
> > 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 <[email protected]>
> > Subject: Re: [Haskell-beginners] How to improve lazyness of a foldl
> > (and memory footprint)
> > To: [email protected]
> > Message-ID: <[email protected]>
> > 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 <[email protected]
> >wrote:
> > >
> > > > On Tue, 14 May 2013 11:22:27 +0200, Giacomo Tesio <[email protected]>
> > > > 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@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
> > > > [email protected]
> > > > http://www.haskell.org/**mailman/listinfo/beginners<
> http://www.haskell.org/mailman/listinfo/beginners>
>
> > > >
> >
> > > _______________________________________________
> > > Beginners mailing list
> > > [email protected]
> > > http://www.haskell.org/mailman/listinfo/beginners
> >
> >
> >
> >
> > ------------------------------
> >
> > Message: 3
> > Date: Wed, 15 May 2013 13:05:07 -0400
> > From: Julian Arni <[email protected]>
> > Subject: [Haskell-beginners] find by
> > To: [email protected]
> > Message-ID:
> > <CANct4CS4KoLra=
> [email protected]>
> > 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 <[email protected]>
> > Subject: [Haskell-beginners] find by
> > To: [email protected]
> > Message-ID:
> > <CANct4CTOFLbkND1n1yDamfPu1k3=
> [email protected]>
> > 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 <[email protected]>
> > Subject: Re: [Haskell-beginners] find by
> > To: [email protected]
> > Message-ID: <[email protected]>
> > 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 <[email protected]>
> > Subject: [Haskell-beginners] HLint fails to give suggestions
> > To: [email protected]
> > Message-ID:
> > <
> cac5dnm6vqec-hhsgmkzjv0bz6lvo5hr7de5beuwlcafvnyb...@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 <[email protected]>
> > Subject: Re: [Haskell-beginners] HLint fails to give suggestions
> > To: The Haskell-Beginners Mailing List - Discussion of primarily
> > beginner-level topics related to Haskell <[email protected]>
> > Message-ID:
> > <CA+9vpFfAzxVF4v_fF-EKi=
> [email protected]>
> > 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 <[email protected]>
> 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
> > > [email protected]
> > > 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
> > [email protected]
> > http://www.haskell.org/mailman/listinfo/beginners
> >
> >
> > End of Beginners Digest, Vol 59, Issue 17
> > *****************************************
>
>
> _______________________________________________
> Beginners mailing list
> [email protected]
> http://www.haskell.org/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://www.haskell.org/pipermail/beginners/attachments/20130515/615928c4/attachment.htm>
------------------------------
_______________________________________________
Beginners mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 59, Issue 19
*****************************************
