September 2017 - Beginners

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 15 Sep '17

15 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

understanding type constructors and value constructors
by Anwar Ludin 14 Sep '17

14 Sep '17

Hello everyone, I have just started studying Haskell and I am having a hard time understanding type and value constructors. So to create a new type, you write something like: data FinancialInstrument = Financial String Double deriving (Eq, Show) and then you can write: ibm = Financial "ibm" 150 OK all good. This initializes a FinancialInstrument. What I don't quite grasp is what is the purpose of Financial (the data/value constructor)? And from what I have read, you could have also written: data FinancialInstrument = FinancialInstrument String Double deriving (Eq, Show) To me the second expression is a lot closer to the typical OOP way of doing things (where the type name and constructor(s) have the same name). Why would someone prefer the first notation? Once a value has been constructed, how can I access its fields? Is there a way to create values using named parameters? Thanks!

3 3

HSpec output option
by Baa 13 Sep '17

13 Sep '17

Hello, Dear List! I have tests: I'm using HSpec (and QuickCheck too). And I have tests like this: describe "Something" $ do it "something is correct" $ do ...blah-blah... it "any string is correct" $ property $ \s -> all (=='*') (Something s) -- it's for example only!!! so something like unit-test and property checks in one SomethingSpec.hs. I'm running them with this Makefile: .PHONY: test fast-test fast-test: stack exec runhaskell -- -isrc -itest test/Spec.hs test: stack test and in Spec.hs I have: {-# OPTIONS_GHC -F -pgmF hspec-discover #-} That's all. So, when I find failed test, I get a trace like this: ... Failures: test/SomethingSpec.hs:172: 1) BlahBlah.superFunc any string is correct: result Gave up after 48 tests ...etc... So, my question is: when QuichCheck runs my property test, it passes argument to property's lambda. And on 48th test attempt with some concreate argument value my check fails. How can I get detailed output from such test environment, to see what concreate arguments lead to failure? To see something (or similar/or more detailed even): Failed with arguments: s = "" Is it possible (I run them with stack and with runhaskell too) ? === Best regards, Paul

1 1