I am trying to do MannWhitney-U test as described here. Following is my code:
import Data.Vector as V
import Data.Vector.Unboxed as VU
import Statistics.Test.MannWhitneyU
sampleA = [1.0, 2.0, 3.0, 4.0, 1.0, 2.0, 3.0, 4]
sampleB = [2.0, 4.0, 5.0, 5.0, 3.0, 4.0, 5.0, 6]
main = do
putStrLn "\nResult of mannWhitneyUtest: "
print (mannWhitneyUtest SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB) )
However, the error is much longer than above code:
[1 of 1] Compiling Main ( rnmann.hs, rnmann.o )
rnmann.hs:6:12: error:
• Ambiguous type variable ‘t0’ arising from the literal ‘1.0’
prevents the constraint ‘(Fractional t0)’ from being solved.
Relevant bindings include sampleA :: [t0] (bound at rnmann.hs:6:1)
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Fractional Double -- Defined in ‘GHC.Float’
instance Fractional Float -- Defined in ‘GHC.Float’
...plus four instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: 1.0
In the expression: [1.0, 2.0, 3.0, 4.0, ....]
In an equation for ‘sampleA’: sampleA = [1.0, 2.0, 3.0, ....]
rnmann.hs:6:47: error:
• Ambiguous type variable ‘t0’ arising from the literal ‘4’
prevents the constraint ‘(Num t0)’ from being solved.
Relevant bindings include sampleA :: [t0] (bound at rnmann.hs:6:1)
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Double -- Defined in ‘GHC.Float’
instance Num Float -- Defined in ‘GHC.Float’
...plus two others
...plus 13 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: 4
In the expression: [1.0, 2.0, 3.0, 4.0, ....]
In an equation for ‘sampleA’: sampleA = [1.0, 2.0, 3.0, ....]
rnmann.hs:7:12: error:
• Ambiguous type variable ‘t0’ arising from the literal ‘2.0’
prevents the constraint ‘(Fractional t0)’ from being solved.
Relevant bindings include sampleB :: [t0] (bound at rnmann.hs:7:1)
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Fractional Double -- Defined in ‘GHC.Float’
instance Fractional Float -- Defined in ‘GHC.Float’
...plus four instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: 2.0
In the expression: [2.0, 4.0, 5.0, 5.0, ....]
In an equation for ‘sampleB’: sampleB = [2.0, 4.0, 5.0, ....]
rnmann.hs:7:47: error:
• Ambiguous type variable ‘t0’ arising from the literal ‘6’
prevents the constraint ‘(Num t0)’ from being solved.
Relevant bindings include sampleB :: [t0] (bound at rnmann.hs:7:1)
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Double -- Defined in ‘GHC.Float’
instance Num Float -- Defined in ‘GHC.Float’
...plus two others
...plus 13 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: 6
In the expression: [2.0, 4.0, 5.0, 5.0, ....]
In an equation for ‘sampleB’: sampleB = [2.0, 4.0, 5.0, ....]
rnmann.hs:11:16: error:
• Ambiguous type variable ‘t0’ arising from a use of ‘mannWhitneyUtest’
prevents the constraint ‘(Ord t0)’ from being solved.
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Integer
-- Defined in ‘integer-gmp-1.0.0.1:GHC.Integer.Type’
instance Ord PositionTest -- Defined in ‘Statistics.Test.Types’
...plus 26 others
...plus 25 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the first argument of ‘print’, namely
‘(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))’
In a stmt of a 'do' block:
print
(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))
In the expression:
do { putStrLn
"\n\
\Result of mannWhitneyUtest: ";
print
(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB)) }
rnmann.hs:11:47: error:
• No instance for (Fractional (Statistics.Types.PValue Double))
arising from the literal ‘0.05’
• In the second argument of ‘mannWhitneyUtest’, namely ‘0.05’
In the first argument of ‘print’, namely
‘(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))’
In a stmt of a 'do' block:
print
(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))
rnmann.hs:11:75: error:
• Ambiguous type variable ‘t0’ arising from a use of ‘VU.fromList’
prevents the constraint ‘(Unbox t0)’ from being solved.
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Unbox () -- Defined in ‘Data.Vector.Unboxed.Base’
instance (Unbox a, Unbox b) => Unbox (a, b)
-- Defined in ‘Data.Vector.Unboxed.Base’
instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
-- Defined in ‘Data.Vector.Unboxed.Base’
...plus 9 others
...plus 16 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the fourth argument of ‘mannWhitneyUtest’, namely
‘(VU.fromList sampleB)’
In the first argument of ‘print’, namely
‘(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))’
In a stmt of a 'do' block:
print
(mannWhitneyUtest
SamplesDiffer 0.05 (VU.fromList sampleA) (VU.fromList sampleB))
I think the key problem is how to mention 0.05 as the Pvalue.
Thanks for your help.
Here's the super relevant bits of the error report.
Ambiguous type variable ‘t0’ arising from the literal ‘4’
Probable fix: use a type annotation to specify what ‘t0’ should be.
Is it an Int, Double, Float? The compiler can't tell since 2 it is ambiguous.
Adding a type signature ought to fix things.
sampleA :: [Double]
You can not use 0.05 as PValue, you can use the mkPValue :: (Ord a, Num a) => a -> PValue a to construct a PValue:
import Statistics.Types(mkPValue)
main = do
putStrLn "\nResult of mannWhitneyUtest: "
print $
mannWhitneyUtest SamplesDiffer (mkPValue 0.05) (VU.fromList sampleA) (VU.fromList sampleB)
This prints as result:
Result of mannWhitneyUtest:
Just Significant
Related
I would like to generate a number by using Data.Time.Clock.POSIT
test' = do
y <- getPOSIXTime
let w = (tail (take 3 (reverse(show y))))
return w
test2 = do
getseed <- test'
let x = read (getseed)
putStrLn (show(x))
So I use getPOSIXTime to get time with the nanosecond, so I convert it into a string and take the first 3 digits and then convert them back to Int. However, it gives me error like this:
test.hs:156:14: error:
• Ambiguous type variable ‘a0’ arising from a use of ‘read’
prevents the constraint ‘(Read a0)’ from being solved.
Relevant bindings include x :: a0 (bound at test.hs:156:10)
Probable fix: use a type annotation to specify what ‘a0’ should be.
These potential instances exist:
instance Read GeneralCategory -- Defined in ‘GHC.Read’
instance Read Ordering -- Defined in ‘GHC.Read’
instance Read Integer -- Defined in ‘GHC.Read’
...plus 23 others
...plus 12 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: read (getseed)
In an equation for ‘x’: x = read (getseed)
In the expression:
do getseed <- test'
let x = read (getseed)
putStrLn (show (x))
|
156 | let x = read (getseed)
| ^^^^^^^^^^^^^^
test.hs:157:16: error:
• Ambiguous type variable ‘a0’ arising from a use of ‘show’
prevents the constraint ‘(Show a0)’ from being solved.
Relevant bindings include x :: a0 (bound at test.hs:156:10)
Probable fix: use a type annotation to specify what ‘a0’ should be.
These potential instances exist:
instance Show GeneralCategory -- Defined in ‘GHC.Unicode’
instance Show Ordering -- Defined in ‘GHC.Show’
instance Show Integer -- Defined in ‘GHC.Show’
...plus 23 others
...plus 27 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the first argument of ‘putStrLn’, namely ‘(show (x))’
In a stmt of a 'do' block: putStrLn (show (x))
In the expression:
do getseed <- test'
let x = read (getseed)
putStrLn (show (x))
|
157 | putStrLn (show(x))
| ^^^^^^^
any help would be appreciated!!
I have the following data structure, and I am trying to write a printer for it:
data CTypeF a
= CVarF Int
| CArrF a a
| CIntF
| CBoolF
deriving (Eq, Data, Show, Functor, Foldable, Traversable)
The following gives me an error:
my_test = do
let c0 = CIntF
(print CIntF)
This is the error message:
• Ambiguous type variable ‘a0’ arising from a use of ‘print’
prevents the constraint ‘(Show a0)’ from being solved.
Probable fix: use a type annotation to specify what ‘a0’ should be.
These potential instances exist:
instance Show Constr -- Defined in ‘Data.Data’
instance Show ConstrRep -- Defined in ‘Data.Data’
instance Show DataRep -- Defined in ‘Data.Data’
...plus 40 others
...plus 166 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In a stmt of a 'do' block: (print CIntF)
In the expression:
do let c0 = CIntF
(print CIntF)
I saw the following question Ambiguous type variable ‘b1’ arising from a use of ‘print’
and modified my code to do (print CIntF :: CTypeF) but I get:
• Expecting one more argument to ‘CTypeF’
Expected a type, but ‘CTypeF’ has kind ‘* -> *’
I am a bit lost on what the issue is. Could someone point out what I'm doing wrong here?
As the error message says, CTypeF takes an argument. CTypeF is not a type, but e.g. CTypeF () or CTypeF Int or CTypeF [(String, Double)] are.
The situation is analogous to print Nothing and attempting to fix it by adding (Nothing :: Maybe). You need to specify Maybe () or Maybe Int or ...
Try
my_test = do
let c0 = CIntF :: CTypeF ()
print c0
The issue is that, as Haskell sees it, you havent told it what the a in CTypeF a is, at least not enough to print it. You might try print (CIntF :: CTypeF ()).
I'm working through a Haskell book. It has the following example:
ghci> Right 3 >>= \x -> return (x + 100)
It expects that this blows up with this error:
<interactive>:1:0:
Ambiguous type variable `a' in the constraints:
`Error a' arising from a use of `it' at <interactive>:1:0-33
`Show a' arising from a use of `print' at <interactive>:1:0-33
Probable fix: add a type signature that fixes these type variable(s)
When I run it:
$ ghci
Prelude> Right 3 >>= \x -> return (x + 100)
I get:
Right 103
ie I don't get the error expected.
Now maybe the compiler or the library has changed - but I'm not sure how to verify that.
My question is: Why doesn't ghci provide the expected Ambiguous type variable error in this scenario?
This is due to -XExtendedDefaultRules being now enabled by default in GHCi. To turn it off (and get your expected error message):
ghci> :set -XNoExtendedDefaultRules
ghci> Right 3 >>= \x -> return (x + 100)
<interactive>:2:1: error:
• Ambiguous type variable ‘a0’ arising from a use of ‘print’
prevents the constraint ‘(Show a0)’ from being solved.
Probable fix: use a type annotation to specify what ‘a0’ should be.
These potential instances exist:
instance (Show b, Show a) => Show (Either a b)
-- Defined in ‘Data.Either’
instance Show Ordering -- Defined in ‘GHC.Show’
instance Show Integer -- Defined in ‘GHC.Show’
...plus 23 others
...plus 11 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In a stmt of an interactive GHCi command: print it
This extension adds a bunch of extra ways to default otherwise ambiguous code. In your case, you have an expression of type Num b => Either a b. Regular Haskell defaulting rules tell us the b should default to Integer. The extended rules (see the link above) additionally default a to ().
I have two modules defined as follows:
Foo.hs
module Foo
where
class F t where
c :: t -> Char
instance F Double where
c s = 'x'
Main.hs
import Foo
main :: IO ()
main = do
print $ (c 2.0)
When I compile these two modules I get this error:
ghc Foo.hs Main.hs
[1 of 2] Compiling Foo ( Foo.hs, Foo.o )
[2 of 2] Compiling Main ( Main.hs, Main.o )
Main.hs:6:12: error:
• Ambiguous type variable ‘t0’ arising from a use of ‘c’
prevents the constraint ‘(F t0)’ from being solved.
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instance exist:
instance [safe] F Double -- Defined in ‘Foo’
• In the second argument of ‘($)’, namely ‘(c 2.0)’
In a stmt of a 'do' block: print $ (c 2.0)
In the expression: do { print $ (c 2.0) }
Main.hs:6:14: error:
• Ambiguous type variable ‘t0’ arising from the literal ‘2.0’
prevents the constraint ‘(Fractional t0)’ from being solved.
Probable fix: use a type annotation to specify what ‘t0’ should be.
These potential instances exist:
instance Fractional Double -- Defined in ‘GHC.Float’
instance Fractional Float -- Defined in ‘GHC.Float’
...plus one instance involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the first argument of ‘c’, namely ‘2.0’
In the second argument of ‘($)’, namely ‘(c 2.0)’
In a stmt of a 'do' block: print $ (c 2.0)
How do I fix this so it prints out 'x'?
You should just rename call to c.
EDIT: Try annotating 2.0 as Double:
print $ c (2.0 :: Double)
GHC doesn't know which type to use for 2.0, it could be any Fractional type. To fix this we force 2.0 to be of type Double by explicitly marking its type.
Current behavior
Prelude> show _
<interactive>:7:6:
Found hole ‘_’ with type: a0
Where: ‘a0’ is an ambiguous type variable
Relevant bindings include it :: String (bound at <interactive>:7:1)
In the first argument of ‘show’, namely ‘_’
In the expression: show _
In an equation for ‘it’: it = show _
Desired behavior
It would be nice if GHC would also tell me that the typed hole has the Show type class constraint.
Misc
GHC Version 7.8.1
This is now fixed in GHC 8.0 thanks to #DominiqueDevriese's GHC ticket.
Due to extended type defaulting, this isn't immediately obvious in GHCi. With your example,
> show _
<interactive>:7:6: error:
• Found hole: _h :: ()
Or perhaps ‘_h’ is mis-spelled, or not in scope
• In the first argument of ‘show’, namely ‘_h’
In the expression: show _h
In an equation for ‘it’: it = show _h
• Relevant bindings include
it :: String (bound at <interactive>:7:1)
the type of the hole is defaulted to (). This is apparently the desired behavior, though there's an argument to be made that extended defaulting shouldn't apply to holes (as a common use for them is to get the compiler to tell you the inferred type).
Nevertheless, if you compile with GHC or disable extended default rules in GHCi (via :set -XNoExtendedDefaultRules), we see the result of the improvements:
<interactive>:3:1: error:
• Ambiguous type variable ‘a0’ arising from a use of ‘show’
prevents the constraint ‘(Show a0)’ from being solved.
Probable fix: use a type annotation to specify what ‘a0’ should be.
These potential instances exist:
instance Show Ordering -- Defined in ‘GHC.Show’
instance Show Integer -- Defined in ‘GHC.Show’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
...plus 22 others
...plus 11 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: show _
In an equation for ‘it’: it = show _
<interactive>:3:6: error:
• Found hole: _ :: a0
Where: ‘a0’ is an ambiguous type variable
• In the first argument of ‘show’, namely ‘_’
In the expression: show _
In an equation for ‘it’: it = show _
• Relevant bindings include
it :: String (bound at <interactive>:3:1)
No currently its not possible.But it may be added to GHC as per the speculations.
Try it :: _ => _ in GHC 8.8+.