March 2016 - Beginners

Using Cassava with medium sized files (~50MB)
by Antoine Genton 21 Mar '16

21 Mar '16

Hello, I tried to load a ~50MB csv file in memory with cassava but found that my program was incredibly slow. After doing some profiling, I realized that it used an enormous amount of memory in the heap: 24,626,540,552 bytes allocated in the heap 6,946,460,688 bytes copied during GC 2,000,644,712 bytes copied maximum residency (14 sample(s)) 319,728,944 bytes maximum slop 3718 MB total memory in use (0MB lost due to fragmentation) ... %GC time 84.0% (94.3% elapsed) Seeing that, I have the feeling that my program lacks strictness and accumulates thunks in memory. I tried two versions, on using Data.Csv, and one using Data.Csv.Streaming. Both are giving the same result. What am I doing wrong? Here are the two sources: 1/ import Data.Csv import Data.ByteString.Lazy as BL import qualified Data.Vector as V main :: IO () main = do csv <- BL.readFile "tt.csv" let !res = case decode NoHeader csv of Right q -> q :: V.Vector(V.Vector(ByteString)) print $ res V.! 0 -------------------------------- 2/ import Data.Csv.Streaming import Data.ByteString.Lazy as BL import qualified Data.Vector as V import Data.Foldable main :: IO () main = do csv <- BL.readFile "tt.csv" let !a = decode NoHeader csv :: Records(V.Vector(ByteString)) let !xx = V.fromList $ [V.fromList([])] :: V.Vector(V.Vector(ByteString)) let !res = Data.Foldable.foldr' V.cons xx a print $ res V.! 0 The goal of the program is ultimately to have the csv loaded in memory as a Vector of Vector of ByteString for further processing later on. Thank you for your help, Antoine

1 0

better way: contains one of a string from list in a string
by Miro Karpis 20 Mar '16

20 Mar '16

Hi, I needed a function that returns True/False if a list of strings are in a given string. I made one function below (works fine),..but I was wondering whether there is a shorter way? -- |Returns True if one of given strings are contained in given string contains :: [String] -> String -> Bool contains elements seach_elem | trueListCount == 0 = False | otherwise = True where isInStringList = [isInfixOf elem seach_elem | elem <- elements] onlyTrueList = [elem | elem <- isInStringList, elem == True] trueListCount = length onlyTrueList Cheers, -m

2 1

Parsing
by Mike Houghton 19 Mar '16

19 Mar '16

Hi, I’m using Parsec to parse structured text and have some problems with mandatory and optional text entries and the order in which they occur. For example module{ name = some string source = … dest = ….. bundle = … bundle_dest = … zip_name = …. } In the above text the name and source are mandatory and all others are optional. I’m not quite sure how to handle the optional parts once I’ve parsed name and source. Should I enforce the rule that if dest does appear then it must be first in the list? In this situation how should I make use of the various Parsec functions such as choice, option, optionMaybe, lookAhead etc. Thanks Mike

2 5

Multiplicaton of singletons
by Dmitriy Matrosov 16 Mar '16

16 Mar '16

> {-# LANGUAGE DataKinds, KindSignatures, TypeFamilies, UndecidableInstances #-} Hi. I've reading "Part I: Dependent Types in Haskell" by Hiromi ISHII at schoolofhaskell [1] and i can't understand why my multiplication for singletons (that was exercise) does not not work: > data Nat = Z | S Nat > > type family Plus (a :: Nat) (b :: Nat) :: Nat where > Plus 'Z b = b > Plus ('S a1) b = 'S (Plus a1 b) > > type family Mult (a :: Nat) (b :: Nat) :: Nat where > Mult 'Z b = 'Z > Mult ('S 'Z) b = b > Mult ('S a1) b = Plus (Mult a1 b) b > > data SNat :: Nat -> * where > SZ :: SNat 'Z > SN :: SNat n -> SNat ('S n) > > plusN :: SNat n -> SNat m -> SNat (Plus n m) > plusN SZ y = y > plusN (SN x) y = SN (plusN x y) > > multN :: SNat n -> SNat m -> SNat (Mult n m) > multN SZ y = SZ > multN (SN SZ) y = y > multN (SN x) y = plusN (multN x y) y The last line (multN) does not type-check with error: 1.lhs:31:25: Could not deduce (Mult ('S n1) m ~ Plus (Mult n1 m) m) from the context (n ~ 'S n1) bound by a pattern with constructor SN :: forall (n :: Nat). SNat n -> SNat ('S n), in an equation for ‘multN’ at 1.lhs:31:10-13 Expected type: SNat (Mult n m) Actual type: SNat (Plus (Mult n1 m) m) Relevant bindings include y :: SNat m (bound at 1.lhs:31:17) x :: SNat n1 (bound at 1.lhs:31:13) multN :: SNat n -> SNat m -> SNat (Mult n m) (bound at 1.lhs:29:3) In the expression: plusN (multN x y) y In an equation for ‘multN’: multN (SN x) y = plusN (multN x y) y Though, when (n ~ 'S n1) i get `SNat (Mult ('S n1) m)` and by definition of Mult this is `SNat (Plus (Mult n1 m) m)` . On the other hand, when i check the type of expression, i get `SNat (Plus (Mult n1 m) m)` by definition of plusN. I.e. exactly the same type. [1]: https://www.schoolofhaskell.com/user/konn/prove-your-haskell-for-great-safe…

1 1

lookAhead
by Dennis Raddle 16 Mar '16

16 Mar '16

I'm working with "lookAhead" in Parsec. My goal is to simplify error messages and make them more relevant. I'm parsing strings that represent musical score text markings that convey nuances of playback expression. I worked long and hard to devise a concise syntax that has sufficient expressive power --- must be concise because there is little room in these score for text markings, especially if there are a lot of them. The result is that it looks a little cryptic. 1;%2|> <%4| <<5:4 <<5:4a etc. My first parser worked, but would give error messages like "Unexpected ';', expected digit, ';', '%', '<<', '|', .... etc., basically giving me no clue what the parser was thinking. The first challenge is that it's hard to identify the particular type of mark from the first few characters. For instance, a mark like this "1;%2|>" --- what gives it away is the ">" at the very end. That means it's a "right-facing warp" and that defines what to expect in the other characters. So it would be great if my parser first identified this as a "right-facing warp" and then when parsing the internals it can give messages that make sense in context. So I tried this, with lookAhead rightWarp = do try (lookAhead (do many1 (noneOf "<>") char '>' eof)) ... parse internals ... char '>' eof The problem is that I want to put a <?> message in here somewhere so that if this whole 'rightWarp' parser fails, it will say "expected right warp". But I have found with experiment that the parser considers the point of failure to be in different places inside the lookAhead. For instance if I give an input string that has too many characters at the end, the failure point will be the 'eof' inside the lookAhead. If I put a <?> message anywhere else, the parser will just say "expected end of input". On the other hand, if there is no '>' character, then the failure point will be "char '>'" and the message will be "expected >". What I was hoping was that there was some single place I could put a <?> message that would say "expected right warp" no matter where inside rightWarp the failure point occurs. Any ideas? Mike

1 0

Getting a specified number of lines from stdin
by Nicolaas du Preez 12 Mar '16

12 Mar '16

Good day All, Why does liftM (take 5) $ sequence $ repeat getLine not stop at reading only 5 lines from stdin but keeps on reading more? What I’m really trying to achieve is to get input from the user until an empty line is read with the code below. But this doesn’t work as I expected, similar to the above. liftM (takeWhile (/= "")) $ sequence $ repeat getLine Regards, Nicolaas du Preez

6 6

Showing Types
by Dániel Arató 09 Mar '16

09 Mar '16

How does GHCi show types? Is there a magic function (showType :: a -> String) that does that? Or is this feature buried somewhere deep in the compiler? Can I show, compare and reason about types in a Haskell program? This would be cool: ```haskell test = do let len = sum . map (const 1) when (isInfixOf "Integer" (showType len)) $ putStrLn "restrictive type inferred; maybe try turning off monomorphism restriction" ```

3 3

Re: [Haskell-beginners] Question on terminology
by Ben Rogalski 06 Mar '16

06 Mar '16

I'm having trouble understanding this: > IIUC, one would describe fmap as "lifting" a function g into a functor f, > in the sense of > > Functor f => (g a b) -> g a -> g b > > > Is there an inverse concept (? co-lift ?) that describes > > Functor f => (g a -> g b) -> a -> b > It seems like these are type declarations for functions, with class constraints that say f must be a Functor, but then f doesn't appear anywhere else in the declaration. Why is this? Thanks, -Ben

3 2

failing to install GHC 7.10.3 appears to have broken cabal and stack
by Jeffrey Brown 04 Mar '16

04 Mar '16

I use Ubuntu 14.04. Outside of a stack context, I have been using GHC 7.8.4. I tried to install 7.10.3. ./configure worked, but make install failed with this error: make[1]: *** No rule to make target `utils/haddock/dist/build/tmp/haddock', needed by `install_libexecs'. Stop. make: *** [install] Error 2 I tried to manually undo the install, by deleting it from /usr/local/lib, and by changing all the symlinks in /usr/local/bin back to 7.8.4. If I run ghci without stack, it works, and is still at version 7.8.4. But now cabal and stack are producing errors. "cabal update" runs, but "cabal install" gets confused: jeff@jeffLenovUbu:~/dwt_git_hask$ cabal install regex-compat Warning: cannot determine version of /usr/local/bin/hpc : "" Warning: cannot determine version of /usr/local/bin/hsc2hs : "" Resolving dependencies... Configuring regex-posix-0.95.2... Building regex-posix-0.95.2... Preprocessing library regex-posix-0.95.2... /usr/local/bin/hsc2hs: line 29: /usr/local/lib/ghc-7.10.3/bin/hsc2hs: No such file or directory Failed to install regex-posix-0.95.2 cabal: Error: some packages failed to install: regex-compat-0.95.1 depends on regex-posix-0.95.2 which failed to install. regex-posix-0.95.2 failed during the building phase. The exception was: ExitFailure 127 jeff@jeffLenovUbu:~/dwt_git_hask$ As an example of a stack problem, I downloaded Oleg Prophet's implementation of MicroKanren [1]. "stack build" ran without complaint (or visible output), but "stack ghci" fails thus: jeff@jeffLenovUbu:~/work/computer/Haskell/microKanren/featherweight$ stack ghciConfiguring GHCi with the following packages: microKanren GHCi, version 7.10.2: http://www.haskell.org/ghc/ :? for help <command line>: cannot satisfy -package QuickCheck (use -v for more information) jeff@jeffLenovUbu:~/dwt_git_hask$ stack ghci even fails (with a different error) on my own project [2]: jeff@jeffLenovUbu:~/dwt_git_hask$ stack ghci Configuring GHCi with the following packages: Dwt GHCi, version 7.10.2: http://www.haskell.org/ghc/ :? for help <command line>: can't load .so/.DLL for: /home/jeff/dwt_git_hask/.stack-work/install/x86_64-linux/nightly-2015-08-03/7.10.2/lib/x86_64-linux-ghc-7.10.2/Dwt-0.1.0.0-7VW1kKp7le6K6OdeGoRsDt/ libHSDwt-0.1.0.0-7VW1kKp7le6K6OdeGoRsDt-ghc7.10.2.so (/home/jeff/dwt_git_hask/.stack-work/install/x86_64-linux/nightly-2015-08-03/7.10.2/lib/x86_64-linux-ghc-7.10.2/Dwt-0.1.0.0-7VW1kKp7le6K6OdeGoRsDt/ libHSDwt-0.1.0.0-7VW1kKp7le6K6OdeGoRsDt-ghc7.10.2.so: undefined symbol: Dwtzu7VW1kKp7le6K6OdeGoRsDt_DwtziSearch_QNode_con_info) jeff@jeffLenovUbu:~/dwt_git_hask$ Thanks in advance for your help. [1] https://github.com/Oregu/featherweight [2] https://github.com/JeffreyBenjaminBrown/digraphs-with-text -- Jeffrey Benjamin Brown

1 0

general observation about programming
by Dennis Raddle 03 Mar '16

03 Mar '16

This is more about programming in general than Haskell, although Haskellers probably know it well. I don't claim to have expert knowledge on this, but I'm gradually getting better at it. When I set out to write a program, or refactor a program, or modify a program, it helps to set out my thinking in a clear way. And how I make it clear is to document my thoughts. An outline is one good way to organize thoughts and is probably my main tool. But good English prose is also helpful. The key factor is "editing." In what sense do I mean that? Good writers do it, and the Haskell documentation does it. I mean (1) brevity and (2) good flow. To achieve brevity, you must think about the essence of each statement and trim away the unnecessary stuff. Good flow refers to how the document builds up and modifies your concepts as you read it. A document can actually mirror an effective learning process, or influence and change your process. I work with my documentation, making several editing passes. By the time I'm done, I am in a great position to write a concise and flexible program. It's interesting that not only is Haskell a concise language, but the Haskell library documentation is concise. Contrast that with the Python documentation which often wanders about into areas that are irrelevant--it could easily be cut into one third its present size. Mike

12 19