- Beginners - Haskell.org

hanoi 4 problem
by Roelof Wobben 19 Feb '15

19 Feb '15

Hello, I try now to make the optional exercise hanoi with 4 pegs, So I did on paper this : start temp1 temp2 end 3 2 1 first move : start -> temp2 start temp1 temp2 end 2 3 1 second move : start -> temp1 start temp1 temp2 end 1 2 3 now I tried to make this piece in code So I did : hanoi4 1 start _ _ end = "move 1 disk from " ++ [start] ++ " to " ++ [end] ++ ".\n" hanoi4 n start temp1 temp2 end = hanoi4 (n-1) start end temp1 temp2 ++ hanoi4 1 start end temp1 temp2 ++ hanoi4 (n-1) start temp1 end temp2 because on the first step start must be start and end must be temp1 and on the second step start must be start and end must be temp2 but when I run in I see this output : move 1 disk from a to b. move 1 disk from a to b. move 1 disk from a to b. move 1 disk from a to c. move 1 disk from a to d. move 1 disk from a to d. move 1 disk from a to d. Can anyone explain or let me see where my thinking took the wrong turn ? Roelof

2 2

tower hanoi problem
by Roelof Wobben 19 Feb '15

19 Feb '15

8 55

enumaratioin question
by Roelof Wobben 19 Feb '15

19 Feb '15

3 6

Package access problem
by Gregory Guthrie 19 Feb '15

19 Feb '15

I installed diagrams, and it seems to be there, but GHCi doesn't find it. I tried adding the local sandbox to the command line (-package-db), but still no luck Any suggestions? C:\Users\guthrie> C:\Users\guthrie>cabal install diagrams Resolving dependencies... All the requested packages are already installed: diagrams-1.2 Use --reinstall if you want to reinstall anyway. I find it in: C:\Users\guthrie\.cabal-sandbox\i386-windows-ghc-7.6.3-packages.conf.d (diagrams-1.2, diagrams-contrib, -core, -lib, -svg) But running: "cabal repl" or using the GHC(i) flag "-package-db=..." fail to find it: C:\Users\guthrie>cabal repl GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> :m + Diagrams <no location info>: Could not find module `Diagrams' It is not a module in the current program, or in any known package. Prelude> :m + Diagrams.Prelude <no location info>: Could not find module `Diagrams.Prelude' It is not a module in the current program, or in any known package. Prelude> ----------------------------------------------------------

4 3

Haskell implementation of longest path algorithm
by Jeremy 19 Feb '15

19 Feb '15

Compared to the Nim code [https://github.com/logicchains/LPATHBench/blob/master/nim.nim] for a longest path algorithm, Haskell [https://github.com/logicchains/LPATHBench/blob/master/hs.hs] looks horrendously verbose and ugly, even if you ignore the pragmas and imports. Is this idiomatic Haskell style? Could it be clearer, but has to be written that way for performance - although it still takes 3.7x as long as the Nim version [https://github.com/logicchains/LPATHBench/blob/master/writeup.md]?

1 0

Re: [Haskell-beginners] tower hanoi problem
by Roelof Wobben 18 Feb '15

18 Feb '15

Oke, Im thinking of this way hanoi 3 source between end hanoi 1 source _ end = [ (source, end)] hanoi n source between end = hanoi (n-1) xxxx print move somehow. Roelof Dudley Brooks schreef op 18-2-2015 om 17:19: > There are three *locations*. But there is only one *thing* -- only > *one at a time*, that is, namely whichever one you are moving on any > given move, be it a disc or an entire stack. > > On 2/17/15 11:10 PM, Roelof Wobben wrote: >> That part I understand already. >> >> The only thing I do not see is what the base case in this exercise is >> because you are working with 3 things instead of 1 for example a list. >> >> As a example reversing a list recursive >> >> the base case is the not reversed list is empty. >> >> >> Roelof >> >> >> >> Dudley Brooks schreef op 18-2-2015 om 8:04: >>> On 2/17/15 10:56 PM, Dudley Brooks wrote: >>>> On 2/16/15 7:06 PM, Doug McIlroy wrote: >>>>>> My way of working is one problem at the time. >>>>>> So first solve the itterate one and after that I gonna try to >>>>>> solve the >>>>>> recursion one. >>>>>> Otherwise I get confused. >>>>> This is the crux of the matter. You must strive to think those >>>>> thoughts >>>>> in the opposite order. Then you won't get confused. >>>>> >>>>> Recursion takes a grand simplifying view: "Are there smaller >>>>> problems of >>>>> the same kind, from the solution(s) of which we could build a >>>>> solution of >>>>> the problem at hand?" If so, let's just believe we have a solver >>>>> for the >>>>> smaller problems and build on them. This is the recursive step. >>>>> >>>>> Of course this can't be done when you are faced with the smallest >>>>> possible problem. Then you have to tell directly how to solve >>>>> it. This is the base case. >>>>> >>>>> [In Hanoi, the base case might be taken as how to move a pile >>>>> of one disc to another post. Even more simply, it might be how >>>>> to move a pile of zero discs--perhaps a curious idea, but no more >>>>> curious than the idea of 0 as a counting number.] >>>>> >>>>> A trivial example: how to copy a list (x:xs) of arbitrary length. >>>>> We could do that if we knew how to copy the smaller list tail, xs. >>>>> All we have to do is tack x onto the head of the copy. Lo, the recipe >>>>> copy (x:xs) = x : copy xs >>>>> Final detail: when the list has no elements, there is no smaller >>>>> list to copy. We need another rule for this base case. A copy >>>>> of an empty list is empty: >>>>> copy [] = [] >>>>> >>>>> With those two rules, we're done. No iterative reasoning about >>>>> copying all the elements of the list. We can see that afterward, >>>>> but that is not how we got to the solution. >>>>> >>>>> [It has been suggested that you can understand recursion thus >>>>> > Do the first step. Then (to put it very dramatically) >>>>> > do *everything else* in *a single step*! >>>>> This point of view works for copy, and more generally for >>>>> "tail recursion", which is trivially transformable to iteration. >>>>> It doesn't work for Hanoi, which involves a fancier recursion >>>>> pattern. The "smaller problem(s)" formulation does work.] >>>> >>>> I simplified it (or over-dramatized it) to the point of >>>> not-quite-correctness. I was trying to dramatize the point of how >>>> surprising the idea of recursion is, when you first encounter it >>>> (because I suspected that the OP had not yet "grokked" the elegance >>>> of recursion) -- and remembering my own Aha! moment at recursive >>>> definitions and proofs by induction in high school algebra, back >>>> when the only "high-level" programming language was assembly. I >>>> see that I gave the mistaken impression that that's the *only* kind >>>> of recursive structure. What I should have said, less dramatically, is >>>> >>>> Do the base case(s) >>>> Then do the recursion -- whatever steps that might involve, >>>> including possibly several recursive steps and possibly even >>>> several single steps, interweaved in various possible orders. >>>> >>>> You can't *start* with the recursion, or you'll get either an >>>> infinite loop or an error. >>>> >>>> I wouldn't quite call the conversion of tail-recursion to iteration >>>> trivial, exactly ... you still have to *do* it, after all! And >>>> when I did CS in school (a long time ago), the equivalence had only >>>> fairly recently been recognized. (By computer language designers, >>>> anyway. Maybe lambda-calculus mathematicians knew it long before >>>> that.) Certainly the idea that compilers could do it automatically >>>> was pretty new. If it were *completely* trivial, it would have >>>> been recognized long before! ;^) >>>> >>>> If you're younger you probably grew up when this idea was already >>>> commonplace. Yesterday's brilliant insight is today's trivia! >>> >>> BTW, since, as you and several others point out, the recursive >>> solution of Towers of Hanoi does *not* involve tail recursion, >>> that's why it's all the more surprising that there actually is a >>> very simple iterative solution, almost as simple to state as the >>> recursive solution, and certainly easier to understand and follow by >>> a novice or non-programmer, who doesn't think recursively. >>>> >>>>> In many harder problems a surefire way to get confused is to >>>>> try to think about the sequence of elementary steps in the final >>>>> solution. Hanoi is a good case in point. >>>>> >>>>> Eventually you will come to see recursion as a way to confidently >>>>> obtain a solution, even though the progress of the computation is >>>>> too complicated to visualize. It is not just a succinct way to >>>>> express iteration! >>>>> >>>>> Doug McIlroy >>>>> _______________________________________________ >>>>> Beginners mailing list >>>>> Beginners(a)haskell.org >>>>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners >>>> >>> >>> _______________________________________________ >>> Beginners mailing list >>> Beginners(a)haskell.org >>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners >>> >> > >

3 9

Re: [Haskell-beginners] Beginners Digest, Vol 80, Issue 39
by Gregory Guthrie 18 Feb '15

18 Feb '15

Thank you for the clarification; I should not have included that example - but the issue is with the other names that should work as in the same example below; "import Diagrams.Prelude", import Diagrams.Backend.SVG.CmdLine, etc. ------------------------------------------- > I installed diagrams, and it seems to be there, but GHCi doesn't find it. I tried adding the > local sandbox to the command line (-package-db), but still no luck Any suggestions? > > C:\Users\guthrie> > C:\Users\guthrie>cabal install diagrams > Resolving dependencies... > All the requested packages are already installed: > diagrams-1.2 > Use --reinstall if you want to reinstall anyway. > > I find it in: > C:\Users\guthrie\.cabal-sandbox\i386-windows-ghc-7.6.3-packages.conf.d (and C:\Users\guthrie\.cabal-sandbox\i386-windows-ghc-7.6.3 ) > (diagrams-1.2, diagrams-contrib, -core, -lib, -svg) > > But running: "cabal repl" or using the GHC(i) flag "-package-db=...(as above)..." > fail to find it: > > C:\Users\guthrie>cabal repl > GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help > Loading package ghc-prim ... linking ... done. > Loading package integer-gmp ... linking ... done. > Loading package base ... linking ... done. > Prelude> :m + Diagrams.Prelude > > <no location info>: > Could not find module `Diagrams.Prelude' > It is not a module in the current program, or in any known package. > Prelude> > ----------------------------------------------------------

2 1

Re: [Haskell-beginners] tower hanoi problem
by Doug McIlroy 18 Feb '15

18 Feb '15

> My way of working is one problem at the time. > So first solve the itterate one and after that I gonna try to solve the > recursion one. > Otherwise I get confused. This is the crux of the matter. You must strive to think those thoughts in the opposite order. Then you won't get confused. Recursion takes a grand simplifying view: "Are there smaller problems of the same kind, from the solution(s) of which we could build a solution of the problem at hand?" If so, let's just believe we have a solver for the smaller problems and build on them. This is the recursive step. Of course this can't be done when you are faced with the smallest possible problem. Then you have to tell directly how to solve it. This is the base case. [In Hanoi, the base case might be taken as how to move a pile of one disc to another post. Even more simply, it might be how to move a pile of zero discs--perhaps a curious idea, but no more curious than the idea of 0 as a counting number.] A trivial example: how to copy a list (x:xs) of arbitrary length. We could do that if we knew how to copy the smaller list tail, xs. All we have to do is tack x onto the head of the copy. Lo, the recipe copy (x:xs) = x : copy xs Final detail: when the list has no elements, there is no smaller list to copy. We need another rule for this base case. A copy of an empty list is empty: copy [] = [] With those two rules, we're done. No iterative reasoning about copying all the elements of the list. We can see that afterward, but that is not how we got to the solution. [It has been suggested that you can understand recursion thus > Do the first step. Then (to put it very dramatically) > do *everything else* in *a single step*! This point of view works for copy, and more generally for "tail recursion", which is trivially transformable to iteration. It doesn't work for Hanoi, which involves a fancier recursion pattern. The "smaller problem(s)" formulation does work.] In many harder problems a surefire way to get confused is to try to think about the sequence of elementary steps in the final solution. Hanoi is a good case in point. Eventually you will come to see recursion as a way to confidently obtain a solution, even though the progress of the computation is too complicated to visualize. It is not just a succinct way to express iteration! Doug McIlroy

3 3

Re: [Haskell-beginners] Getting "Discrete Mathematics Using a Computer" code to run
by Henk-Jan van Tuyl 15 Feb '15

15 Feb '15

There are several types of exceptions that could be caught here, but the compiler does not know which one to choose. You could specify a type, but it is easier to use 'onException' (also in Control.Exception) instead of 'catch', if you want to treat all exceptions the same way, without any info about the kind of exception. On Sun, 15 Feb 2015 17:49:21 +0100, Lawrence Bottorff <borgauf(a)gmail.com> wrote: > Thanks for the tip. Yes, I had tried that, but never got it right. Here's > my change: : > Stdm02142015.lhs:1037:40-46: > No instance for (Exception e1) arising from a use of `catch' > The type variable `e1' is ambiguous > Possible fix: add a type signature that fixes these type variable(s) > Note: there are several potential instances: > instance Exception NestedAtomically > -- Defined in `Control.Exception.Base' > instance Exception NoMethodError > -- Defined in `Control.Exception.Base' > instance Exception NonTermination > -- Defined in `Control.Exception.Base' > ...plus 7 others > In a stmt of a 'do' block: > filedata <- (readFile filename) `catch` (\ _ -> return "") : > et cetera, et cetera. Any idea where this import Control.Exception should > go. Or is there something else amiss? > > On Sun, Feb 15, 2015 at 5:06 AM, Henk-Jan van Tuyl <hjgtuyl(a)chello.nl> > wrote: > >> On Sat, 14 Feb 2015 23:30:13 +0100, Lawrence Bottorff >> <borgauf(a)gmail.com> >> wrote: >> >> .../Discrete/Stdm02142015.lhs:1036:40-46: >>> Not in scope: `catch' >>> >>> .../Discrete/Stdm02142015.lhs:1048:40-46: >>> Not in scope: `catch' >>> Failed, modules loaded: none. >>> >>> This is on ghci 7.6.3 >>> >> >> The function "catch" is removed from Prelude, you need to add the line: >> import Control.Exception >> >> 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/

1 0

Re: [Haskell-beginners] Spec with QuickCheck generationg list of list of the same length
by Ondrej Nekola 15 Feb '15

15 Feb '15

Thanks, it sent me to the (higly probably) right direction: newtype RectList = RectList [LVector] deriving Show instance Arbitrary RectList where arbitrary = do m <- getPositive <$> arbitrary n <- getPositive <$> arbitrary RectList <$> replicateM n (vector m) and the test can look like this: it "average times number is sum" $ property (\(RectList x) -> null $ nozeroMembers $ zipWith (-) ( map (* (fromIntegral $ length x)) (average x)) (sumVect x) ) Thanks again Ondrej > On 2015-02-15 at 10:52, Ondrej Nekola <ondra(a)nekola.cz> wrote: >> How can I generate list of lists, where all the included lists are of >> the same length? > The general approach is to make a newtype, the Arbitrary instance of > which does what you want. For example, QucickCheck includes newtypes > Positive[1] and NonNegative[2], that generate restricted numbers. > > For your case, I'd write something like (untested): > > ``` > newtype RectList a = RectList [[a]] > > instance Arbitrary a => Arbitrary RectList a where > arbitrary = do > -- length of inner lists > m <- getPositive <$> arbitrary > -- length of outer list, can be zero > n <- getNonNegative <$> arbitrary > RectList <$> replicateM n (vector m) > ``` > > vector here is another function provided by QuickCheck: [3]. > > Hope this helps. > > bergey > >> Link for some tutorial *) can be, I believe, enough but I would be glad >> for any help. >> >> Thanks >> Ondra @satai Nekola >> ondra(a)nekola.cz >> >> *) Maybe I have not trained my google good enough yet, but lack of >> tutorials describing more than the most basic usecase is probably the >> most problematic point in re-learning Haskell so far. >> _______________________________________________ >> Beginners mailing list >> Beginners(a)haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners > Footnotes: > [1] http://hackage.haskell.org/package/QuickCheck-2.7.6/docs/Test-QuickCheck.ht… > > [2] http://hackage.haskell.org/package/QuickCheck-2.7.6/docs/Test-QuickCheck.ht… > > [3] http://hackage.haskell.org/package/QuickCheck-2.7.6/docs/Test-QuickCheck-Ar… > >

1 0