To generate a random number by using time - haskell

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!!

Related

Ambiguous type variable ‘a0’ arising from a use of ‘print’

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 ()).

Why doesn't ghci provide the expected Ambiguous type variable error in this scenario?

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 ().

Ambiguous type variable `a0' arising from a use of `print'?

While learning Haskell I'm trying to write a function that given a number will give its successor in a Collatz sequence:
next :: (Fractional a, Integral a) => a -> a
next x
| odd x = x * 3 + 1
| otherwise = x / 2
When I run next 7 I get:
<interactive>:150: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 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 12 instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
* In a stmt of an interactive GHCi command: print it
Two questions:
Am I using the best class constraints in my signature?
Assuming I am, how can I show the result of next 7 ?
I believe Collatz sequence is an integer sequence, so it wouldn't be necessary making the result Fractional.
next :: (Integral a) => a -> a
To be able to get an integer from a division, you should use div function. Note that division will always be exact as you are going to divide only even numbers:
next x
| odd x = x * 3 + 1
| otherwise = x `div` 2

Print out a char in main method

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.

Is there a way to make GHC provide the type class constraints of typed holes?

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+.

Resources