- Beginners - Haskell.org

Why is :t 42 ::Num a => a -> a ?
by Olumide 24 Sep '16

24 Sep '16

Is 42 a function? And if it is why does 42 + 24 work, if both are functions. I know there's something I'm getting wrong here. Also, is the expression abs -42 an error. I initially thought that abs to the operator (-) first but there is no space between - and 42. Or is there some associativity issue going on here. - Olumide

2 1

cabal optional build-depends
by PICCA Frederic-Emmanuel 24 Sep '16

24 Sep '16

Hello the hmatrix package was splitte hmatrix -> hmatrix, hmatrix-gsl, ... for version > 0.16 I use Debian stable and need to support hmatrix 0.15 (with no split) and hmatrix >= 0.17 (splitted) I would like to know how to suport this in the cabal file only hmatrix if >= 0.15 && < 0.16 and hmatrix + hmatrix-gsl if hmatrix > 0.17 thanks for your help Frederic

1 0

Re: [Haskell-beginners] Beginners Digest, Vol 99, Issue 15
by Lai Boon Hui 23 Sep '16

23 Sep '16

Hi, still does not compile sumList :: (Fractional a) => [a] -> a sumList [] = 0 sumList (x:xs) = x + (sumList xs) lengthList :: (Fractional a) => [t] -> a lengthList [] = 0 lengthList (_:xs) = 1 + (lengthList xs) meanList :: (Num a, Fractional b) => [a] -> b meanList xs = (sumList xs) / (lengthList xs) i know meanList :: (Fractional b) => [b] -> b meanList xs = (sumList xs) / (lengthList xs) compiles. But why do i have to restrict the inputs to be a list of Fractionals and not Nums?? On Fri, Sep 23, 2016 at 11:18 AM, <beginners-request(a)haskell.org> wrote: > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)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: Beginners Digest, Vol 99, Issue 13 (Tushar Tyagi) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Fri, 23 Sep 2016 09:01:18 +0530 > From: Tushar Tyagi <tushar4r(a)gmail.com> > To: The Haskell-Beginners Mailing List - Discussion of primarily > beginner-level topics related to Haskell <beginners(a)haskell.org> > Subject: Re: [Haskell-beginners] Beginners Digest, Vol 99, Issue 13 > Message-ID: > <CAEDPzikCmLEpiop-5BGbDaKZK1TifAu6ymF+jmJq_ > rEuMNN_Kg(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > You can read more about Numbers here: > https://www.haskell.org/tutorial/numbers.html > > In your implementation sumList and lengthList both return 'Num' which > doesn't define a division operator. So you have to convert them into > fractional by either changing the signatures of these 2 functions from Num > to Fractional, or use fromIntegral function, (or something else) . Two of > these approaches have been suggested by people here. :) > > Typed using my phone, so excuse my brevity. > > On 23 Sep 2016 6:14 a.m., "Lai Boon Hui" <laiboonh(a)gmail.com> wrote: > > > Hi All, > > > > i am overwhelmed by all the helpful responses. Thanks guys. > > > > I am more curious about why > > > > meanList :: (Num a, Fractional b) => [a] -> b > > meanList xs = (sumList xs) / (lengthList xs) > > > > does not compile. > > > > 'a' being a Num type seems perfectly fine, (/) returns a Fractional type > > hence 'b' being Fractional seems also fine. > > > > > > > > On Fri, Sep 23, 2016 at 7:13 AM, <beginners-request(a)haskell.org> wrote: > > > >> Send Beginners mailing list submissions to > >> beginners(a)haskell.org > >> > >> To subscribe or unsubscribe via the World Wide Web, visit > >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > >> or, via email, send a message with subject or body 'help' to > >> beginners-request(a)haskell.org > >> > >> You can reach the person managing the list at > >> beginners-owner(a)haskell.org > >> > >> When replying, please edit your Subject line so it is more specific > >> than "Re: Contents of Beginners digest..." > >> > >> > >> Today's Topics: > >> > >> 1. Newbie question about function type constraints (Lai Boon Hui) > >> 2. Re: Newbie question about function type constraints > >> (Tushar Tyagi) > >> 3. Re: Newbie question about function type constraints > >> (Imants Cekusins) > >> 4. Re: Newbie question about function type constraints > >> (Harald Bögeholz) > >> 5. Re: Newbie question about function type constraints > >> (Sylvain Henry) > >> 6. Re: Newbie question about function type constraints > >> (Sylvain Henry) > >> 7. The meaning of categories constructed from HASK > >> (Dimitri DeFigueiredo) > >> > >> > >> ---------------------------------------------------------------------- > >> > >> Message: 1 > >> Date: Thu, 22 Sep 2016 21:19:12 +0800 > >> From: Lai Boon Hui <laiboonh(a)gmail.com> > >> To: beginners(a)haskell.org > >> Subject: [Haskell-beginners] Newbie question about function type > >> constraints > >> Message-ID: > >> <CAJdQgg=jJYfdRsq+QfBr1aC-hS1ft9+4Sp4jopoktg=JnDMirg@mail. > >> gmail.com> > >> Content-Type: text/plain; charset="utf-8" > >> > >> Hi, can someone explain to me why i cannot define meanList as: > >> > >> meanList :: (Integral a, Fractional b) => [a] -> a > >> meanList xs = (sumList xs) / (lengthList xs) > >> > >> I want to restrict the function to only accept lists like [1,2,3] and > >> return answer 2.0 > >> > >> > >> sumList :: (Num a) => [a] -> a > >> sumList [] = 0 > >> sumList (x:xs) = x + (sumList xs) > >> > >> lengthList :: (Num a) => [t] -> a > >> lengthList [] = 0 > >> lengthList (_:xs) = 1 + (lengthList xs) > >>

2 1

Re: [Haskell-beginners] Beginners Digest, Vol 99, Issue 13
by Lai Boon Hui 22 Sep '16

22 Sep '16

Hi All, i am overwhelmed by all the helpful responses. Thanks guys. I am more curious about why meanList :: (Num a, Fractional b) => [a] -> b meanList xs = (sumList xs) / (lengthList xs) does not compile. 'a' being a Num type seems perfectly fine, (/) returns a Fractional type hence 'b' being Fractional seems also fine. On Fri, Sep 23, 2016 at 7:13 AM, <beginners-request(a)haskell.org> wrote: > Send Beginners mailing list submissions to > beginners(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > or, via email, send a message with subject or body 'help' to > beginners-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. Newbie question about function type constraints (Lai Boon Hui) > 2. Re: Newbie question about function type constraints > (Tushar Tyagi) > 3. Re: Newbie question about function type constraints > (Imants Cekusins) > 4. Re: Newbie question about function type constraints > (Harald Bögeholz) > 5. Re: Newbie question about function type constraints > (Sylvain Henry) > 6. Re: Newbie question about function type constraints > (Sylvain Henry) > 7. The meaning of categories constructed from HASK > (Dimitri DeFigueiredo) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Thu, 22 Sep 2016 21:19:12 +0800 > From: Lai Boon Hui <laiboonh(a)gmail.com> > To: beginners(a)haskell.org > Subject: [Haskell-beginners] Newbie question about function type > constraints > Message-ID: > <CAJdQgg=jJYfdRsq+QfBr1aC-hS1ft9+4Sp4jopoktg=JnDMirg@ > mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Hi, can someone explain to me why i cannot define meanList as: > > meanList :: (Integral a, Fractional b) => [a] -> a > meanList xs = (sumList xs) / (lengthList xs) > > I want to restrict the function to only accept lists like [1,2,3] and > return answer 2.0 > > > sumList :: (Num a) => [a] -> a > sumList [] = 0 > sumList (x:xs) = x + (sumList xs) > > lengthList :: (Num a) => [t] -> a > lengthList [] = 0 > lengthList (_:xs) = 1 + (lengthList xs) >

2 1

Newbie question about function type constraints
by Lai Boon Hui 22 Sep '16

22 Sep '16

Hi, can someone explain to me why i cannot define meanList as: meanList :: (Integral a, Fractional b) => [a] -> a meanList xs = (sumList xs) / (lengthList xs) I want to restrict the function to only accept lists like [1,2,3] and return answer 2.0 sumList :: (Num a) => [a] -> a sumList [] = 0 sumList (x:xs) = x + (sumList xs) lengthList :: (Num a) => [t] -> a lengthList [] = 0 lengthList (_:xs) = 1 + (lengthList xs)

4 4

Re: [Haskell-beginners] Newbie question about function type constraints
by Tushar Tyagi 22 Sep '16

22 Sep '16

What happens if you change the signature of meanList to meanList :: ( Fractional b) => [b] ->b The integrals in [1,2,3] would be converted to [1.0, 2.0, 3.0] before you act upon them. On 22 Sep 2016 6:49 p.m., "Lai Boon Hui" <laiboonh(a)gmail.com> wrote: Hi, can someone explain to me why i cannot define meanList as: meanList :: (Integral a, Fractional b) => [a] -> a meanList xs = (sumList xs) / (lengthList xs) I want to restrict the function to only accept lists like [1,2,3] and return answer 2.0 sumList :: (Num a) => [a] -> a sumList [] = 0 sumList (x:xs) = x + (sumList xs) lengthList :: (Num a) => [t] -> a lengthList [] = 0 lengthList (_:xs) = 1 + (lengthList xs) _______________________________________________ Beginners mailing list Beginners(a)haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners

1 0

is this right?
by Dennis Raddle 22 Sep '16

22 Sep '16

I want to evaluate a function on a series of inputs: f :: a -> Maybe b then collect the results [b] if they are all Just, or terminate the computation immediately upon hitting Nothing. This is exactly what mapM does in the Maybe monad, correct? In particular I want to make sure that it will not try to evaluate anything past the first 'Nothing' result as the efficiency of my design is based on that. D

2 1

why isnt this optimized?
by Gunnar Quehl 16 Sep '16

16 Sep '16

Hi, I wrote a recursive fibonacci function in ghci: :set +m let f 0 = 0 f 1 = 1 f n = f (n-1) + f (n-2) As expected calculation f 30 takes a while. About 5s on my machine. What I don't understand is that let x = f 30 in (x,x) takes twice as long. Why is ghci reevaluating the x twice? Isn't in always said, that it can optimize because we can replace same by same and so on. Actually if compiled the behaviour is as expected. main = print $ let x = f 34 in (x) and main = print $ let x = f 34 in (x,x) both take about 3s. Why is this not the case in the interactive enviroment? Thanks Gunnar

2 3

how to enter EOF in emacs haskell mode
by Chul-Woong Yang 14 Sep '16

14 Sep '16

Hi, all. I use emacs haskell mode for editing and testing simple programs. I have no success in finding out how to enter EOF to haskell program in emacs "Interactive-Haskell" buffer. So I am unable to test haskell program which reads from stdin. :-( Any help would be appreciated deeply. Regards, Chul-Woong Yang

1 0

help with optimizing memory usage of thunk size of Monte Carlo backtracking search algorithm
by Dennis Raddle 12 Sep '16

12 Sep '16

I'm a Haskell semi-beginner, and I've implemented a crude Monte Carlo search optimization algorithm, and I want to know how to use strict evaluation to prevent it from consuming too much memory. I am willing to learn new things to do this---if you want to point me in the right direction and maybe give some references, I'll take it from there. However, if there is something simple that can take care of the whole problem, please let me know. I have not run this with the profiler so I don't actually know precisely what it is doing now. I have not run out of memory using it in small cases, but I hope to use it on much larger cases. Here is the code so far: import qualified Data.List as L import Control.Monad import Data.Function -- Suppose that we do backtracking search for an optimal arrangement of -- elements in some kind of "structure". The "structure" is built one step at -- a time. -- -- An example would be searching for an optimal arrangement of furniture. The -- structure is a represenation of the room and all items that have been -- placed in it so far. We could list the options (or "steps") available to us -- at any point in building the structure, that is a list of furniture items -- and locations. -- -- We have the notion that the structure, at some point in adding steps, -- becomes complete. We have an evaluation function providing a "goodness -- score" on either a partially built or complete structure. -- -- The search will optimize the goodness score over all possible complete -- structures. (Or perhaps with Monte Carlo search, an approximate optimal -- value.) -- -- Class Opt (for "optimization") defines a structure type "struct" and a step -- type "step". class Opt struct step | struct -> step where -- number of steps chosen so far in current state of 'struct': oSize :: struct -> Int -- list all the available steps to choose next. If this list is null, then -- the structure is complete. oList :: struct -> [step] -- apply a step to the structure to create a new structure: oApply :: struct -> step -> struct -- evaluate the "goodness" of the current state of a structure. Higher is -- better. oEval :: struct -> Double -- Implement a kind of Monte Carlo search. (I have a vague idea of the -- literature on Monte Carlo; this algorithm is my guess at something that -- does the job). We work in a state monad of class -- "RandMonad" which holds the StdGen data and provides several methods for -- accessing it. The only method we need from RandMonad is -- -- rChooseItem :: RandMonad m => [a] -> m a -- -- which chooses a random item from a non-null list. -- -- The basic algorithm is this: at each point in building the structure, we -- have a structure S and a list of next steps step_list. We apply each step -- in step_list to S, in turn. After applying a step x to S, call the result -- S_x. We evaluate the "monte carlo fitness" of S_x by making random -- completions of it---that is, choosing a bunch of additional steps -- randomly---doing 'nExper' completions (nExper might be 1000 to 10000). The -- fitness as measured by oEval of the very best random completion becomes -- the "monte carlo fitness" of S_x. We then choose the step from step_list, -- x, that maximizes the "monte carlo fitness" of S_x. -- -- We then repeat this process until S is complete. -- Function monteCarlo will take a partially complete structure, and optimize -- it over an investigation of 'nExper' possible "completions". monteCarlo :: (RandMonad r, Opt a b) => Int -> a -> r a monteCarlo nExper struct = case oList struct of -- If structure is complete, then it is its own optimization. [] -> return struct -- Otherwise find optimal step according to "monte carlo fitness" and -- recursively call 'monteCarlo' steps -> do let doStep step = do let newStruct = oApply struct step score <- monteCarloEval nExper newStruct return (score,newStruct) (_,winner) <- L.maximumBy (compare `on` fst) `liftM` mapM doStep steps monteCarlo nExper winner -- monteCarloEval -- -- Evaluate the "monte carlo fitness" of a structure 'struct' by completing it -- in nExper random ways (that is, make all remaining choices in purely random -- way) and finding the maximum value of the evaluated final state among all -- nExper ways. -- monteCarloEval :: (RandMonad r, Opt a b) => Int -> a -> r Double monteCarloEval nExper struct = case oList struct of [] -> return $ oEval struct _ -> do scores <- replicateM nExper (randomComplete struct) return . maximum . map oEval $ scores -- Make random choices of steps until a structure 's' is complete. randomComplete :: (RandMonad r, Opt a b) => a -> r a randomComplete s = case oList s of [] -> return s steps -> rChooseItem steps >>= (randomComplete . oApply s)

3 3