- Beginners - Haskell.org

Export of names only for testing
by Baa 02 Oct '17

02 Oct '17

Hello, All! What is the standard Haskell convenience about export of module names for testing? As I understand, I should export all of them which looks like abstraction leak, but without this I can't test them, right? === Best regards, Paul

2 4

Loading a ~200 column CSV file in Haskell into a Record structure
by Guru Devanla 01 Oct '17

01 Oct '17

Hello All, I am in the process of replicating some code in Python in Haskell. In Python, I load a couple of csv files, each file having more than 100 columns into a Pandas' data frame. Panda's data-frame, in short is a tabular structure which lets me performs on bunch of joins, and filter out data. I generated different shapes of reports using these operations. Of course, I would love some type checking to help me with these merge, join operations as I create different reports. I am not looking to replicate the Pandas data-frame functionality in Haskell. First thing I want to do is reach out to the 'record' data structure. Here are some ideas I have: 1. I need to declare all these 100+ columns into multiple record structures. 2. Some of the columns can have NULL/NaN values. Therefore, some of the attributes of the record structure would be 'MayBe' values. Now, I could drop some columns during load and cut down the number of attributes i created per record structure. 3. Create a dictionary of each record structure which will help me index into into them.' I would like some feedback on the first 2 points. Seems like there is a lot of boiler plate code I have to generate for creating 100s of record attributes. Is this the only sane way to do this? What other patterns should I consider while solving such a problem. Also, I do not want to add too many dependencies into the project, but open to suggestions. Any input/advice on this would be very helpful. Thank you for the time!

1 0

Ambiguous type error: multiparam class + type alias
by Baa 28 Sep '17

28 Sep '17

Hello, List! The further - the more interesting... For example, I want own `Show` analogue, which will be parameterized with type meaning "context"/"reason". So, to represent title of the value I will call: repr x::TitleRepr or simple `Show`: repr x::ShowRepr or repr x::Repr AsShow etc. I try: {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE MultiParamTypeClasses #-} data AsShow data AsTitle type Repr a = String class ReprC a b where repr :: a -> Repr b instance ReprC Int AsTitle where repr n = "a number " ++ show n main = do let n = 5 :: Int print $ (repr n :: Repr AsTitle) and sure I get error: • Ambiguous type variable ‘b0’ arising from a use of ‘repr’ prevents the constraint ‘(ReprC Int b0)’ from being solved. Probable fix: use a type annotation to specify what ‘b0’ should be. These potential instance exist: instance ReprC Int AsTitle -- Defined at .../.stack-work/intero/intero31144sPV.hs:12:10 • In the second argument of ‘($)’, namely ‘(repr n :: Repr AsTitle)’ In a stmt of a 'do' block: print $ (repr n :: Repr AsTitle) In the expression: do { let n = ...; print $ (repr n :: Repr AsTitle) } (intero) Sure, I can use as `Repr` not type-alias but `newtype`. But in this case I will need additional call (show/runRepr/coerce/etc.): coerce $ (repr x::AsTitle) So, what is the reason that GHCI is see that `repr n` is `::Repr AsTitle` (AsTitle!!) and says me that `b0` is ambigous?! It should know what concreate `repr` I mean! :) If I use `newtype` - no problem, so I suppose problem is in the type alias. It's not sterling type for such goal, right? Another question is: how to accomplish such goal, i.e. without to make additional call (coerce/show/runRepr/etc) when `repr` will return `String`, wrapped in newtype? PS. Execuse such silly and training example. Actually, I planned to made such class and to use it instead of `Show`. Sure, it can be splitted to several classed (my current state) but.. example is to learn Haskell and to understand my errors... === Best regards, Paul

3 6

Sequence function
by Jimbo 26 Sep '17

26 Sep '17

Hello everyone, Just trying to understand the sequence function as follows: sequence [Just 1] -- evaluates to Just [1] sequence = foldr mcons (return []) where mcons p q = p >>= \x -> q >>= \y -> return (x:y) -- I'm trying to walk through the code as follows, I understand what is below isn't -- haskell code p >>= \x -> [] q >>= \y -> Just 1 return (x:y) -- [] : Just 1 Am I thinking of sequence correctly here? Best regards, Jim

2 5

Ambogous error in returning value
by Baa 26 Sep '17

26 Sep '17

Hello, everyone. Considering, I have a class: class Flt a where allows :: FltOpts -> [a] denies :: FltOpts -> [a] crit :: a -> [a] -> Bool flt :: FltOpts -> a -> Bool flt opts a = allowed && not denied where allowed = if null $ allows opts then True else a `crit` (allows opts) denied = if null $ denies opts then False else a `crit` (denies opts) I get error here: • Could not deduce (Flt a1) arising from a use of ‘allows’ from the context: Flt a bound by the class declaration for ‘Flt’ at .../.stack-work/intero/intero5319V42.hs:(31,1)-(38,97) The type variable ‘a1’ is ambiguous These potential instance exist: instance Flt MyType -- Defined at ... • In the second argument of ‘($)’, namely ‘allows opts’ .................................................... As I understand, GHC can not deduce type if it's a return's value (contraposition?). OK, but it knows its type: it is `[a]`! What is the problem to keep `flt` method as a generic, i.e. without concreate type, but only `[a]` ? Second, I implemented instance: instance Flt MyType where allows = ... denies = ... flt opts a = allowed && not denied where allowed = if null $ (allows opts::[MyType]) then True else a `crit` (allows opts) denied = if null $ (denies opts::[MyType]) then False else a `crit` (denies opts) and without this explicite type annotation of `allows opts` I get again ambigous error. But why? GHC knows that `allows` returns `[a]` and `a` is `MyType`, so `[a]` is `[MyType]`. Why I need to write it explicitly? May be I need some extension here? === Best regards, Paul

2 2

take until duplicate
by mike h 24 Sep '17

24 Sep '17

I’m looking at how to take from a list until a duplicate is found. e.g. takeUntilDup [1,2,3,4,3] = [1,2,3,4] I found this implementation takeUntilDup = foldr (\x r -> x : takeWhile (/= x) r) [] It works but I can’t see how!!? The accumulated result is built up in r so with input [1,2,3,4,3] then, at the point when r = [1, 2, 3, 4], the fold is about to use the number 3. i.e. it does takeWhile (/=3) [1,2,3,4] which gives [1,2] Please, how does this work? Thanks Mike .

2 2

Writing a polymorphic function in Haskell
by Matt Williams 23 Sep '17

23 Sep '17

Dear All, I am having problems writing a polymorphic function. I have a type that has two constructors: data Arg = IndArg {evi::Evi, t1::Treatment, t2::Treatment, out::Outcome, dir::Direction} | MetaArg {target::EviType} deriving (Show) I have a function checks for conflict: checkConflict :: Arg -> Arg -> Bool checkConflict a b = if t1 a == t1 b && t2 a == t2 b && dir a /= dir b then True else False However, I can't make this work with both types of Argument - if I pass it MetaArg, it raises an error. In another language, I would write something like: checkConflict(ArgA,ArgB):

3 4

Syntax error using where with guards.
by Manuel Vázquez Acosta 16 Sep '17

16 Sep '17

I was trying to implement a functional version of numerator/denominator simplifications of symbols. I came up with: simplify :: (Eq o, Ord o) => [o] -> [o] -> ([o], [o]) simplify [] bs = ([], bs) simplify ts [] = (ts, []) simplify (x:xs) (y:ys) | x == y = simplify xs ys | x < y = ([x] ++ (fst $ simplify xs (y:ys)), snd $ simplify xs (y:ys)) | otherwise = (fst r, [y] ++ snd r) where r = simplify (x:xs) ys simplify2 :: (Eq o, Ord o) => [o] -> [o] -> ([o], [o]) simplify2 a b = simplify (sort a) (sort b) -- sort not shown here In the second guard of the simplify function the expression 'simplify xs (y:ys)' is repeated. I would like to write instead: simplify (x:xs) (y:ys) | x == y = simplify xs ys | x < y = ([x] ++ fst r, snd r) where r = simplify xs (y:ys) | otherwise = (fst r, [y] ++ snd r) where r = simplify (x:xs) ys But doing so is parse error: $ ghc xoutil/dim/meta.hs [1 of 1] Compiling Meta ( xoutil/dim/meta.hs, xoutil/dim/meta.o ) xoutil/dim/meta.hs:19:3: parse error on input ‘|’ I'm using: ghc 7.10.3. Any ideas of why this is a syntax error? Best regards, Manuel.

3 2

Square root algorithm
by mike h 15 Sep '17

15 Sep '17

Hi, To help me in learning Haskell I started blogging about some of the things I’ve looked at. One such topic was calculating square roots ‘by hand’ and then deriving a Haskell algorithm. I wrote about the well known technique here http://gitcommit.co.uk/2017/08/25/the-root-of-the-problem-part-1/ <http://gitcommit.co.uk/2017/08/25/the-root-of-the-problem-part-1/> and it it is really quite a simple method. The second part of the post will be an implementation in Haskell. I then tried implementing it and got something that works but really its not very pleasant to look at! And its something I don’t want to post! Some parts are fine but I think I locked myself into the notion that it had to be using State and really the end result is pretty poor. I know this i perhaps a ‘big ask’ but I’d really appreciate any suggestions, solutions, hints etc. I will of course give full attribution. I’ve created a gist of the code here https://gist.github.com/banditpig <https://gist.github.com/banditpig> Many Thanks Mike

5 9

"Phantom" function?
by Baa 15 Sep '17

15 Sep '17

Hello, List. I'm trying to write function like this: type VerifyJson a = IO Bool isRight :: FromJSON a => FilePath -> VerifyJson a isRight testbed = do js <- readFile testbed return $ isJust (decode js) <<<<< ERROR IS HERE ! So I get error: 60 23 error error: • Could not deduce (FromJSON a0) arising from a use of ‘decode’ from the context: FromJSON a bound by the type signature for: isRight :: FromJSON a => FilePath -> VerifyJson a at /home/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/.stack-work/intero/intero7476qP4.hs:57:1-46 The type variable ‘a0’ is ambiguous These potential instances exist: instance FromJSON DotNetTime -- Defined in ‘aeson-1.0.2.1:Data.Aeson.Types.FromJSON’ instance FromJSON Value -- Defined in ‘aeson-1.0.2.1:Data.Aeson.Types.FromJSON’ instance (FromJSON a, FromJSON b) => FromJSON (Either a b) -- Defined in ‘aeson-1.0.2.1:Data.Aeson.Types.FromJSON’ ...plus 25 others ...plus 52 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the first argument of ‘MB.isJust’, namely ‘(decode js)’ In the second argument of ‘($)’, namely ‘MB.isJust (decode js)’ In a stmt of a 'do' block: return $ MB.isJust (decode js) (intero) Is it possible to write such (phantom?;)) function? Sure, I can make workaround like: class FromJSON a => VerifyJson a where isRight :: FilePath -> IO Bool isRight testbed = do js <- readFile testbed return $ MB.isJust (decode js::Maybe a) but in this case I must declare instances for all verificating types (right?), like: instance VerifyJson MyType But idea was to minimize `isRight` users code... === Best regards, Paul

1 2