Send Beginners mailing list submissions to
        beginners@haskell.org

To subscribe or unsubscribe via the World Wide Web, visit
        http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
        beginners-requ...@haskell.org

You can reach the person managing the list at
        beginners-ow...@haskell.org

When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."


Today's Topics:

   1. Re:  Runtime error “Could not deduce (Integral Float)
      arising from a use of..” (David McBride)


----------------------------------------------------------------------

Message: 1
Date: Thu, 23 Aug 2018 08:35:26 -0400
From: David McBride <toa...@gmail.com>
To: The Haskell-Beginners Mailing List - Discussion of primarily
        beginner-level topics related to Haskell <beginners@haskell.org>
Subject: Re: [Haskell-beginners] Runtime error “Could not deduce
        (Integral Float) arising from a use of..”
Message-ID:
        <can+tr42skqjezkd8wiwuz-f1yo3xaob+fagjy+xcmawos-b...@mail.gmail.com>
Content-Type: text/plain; charset="utf-8"

Floating is the type class of types that are floating point.  The two most
common instances are Float and Double.  Integral is the class of integer
types.  Most commonly Int and Integer.

stdDev
  :: (Floating a1, Floating a, Integral a1) =>

When you see a type like that it means type a1 is both a Floating and also
an Integral.  Intellectually that is impossible, but as far as ghc is
concerned there could be a type that is an instance of both classes, so it
allows it.  But when you try to call it, there's no type in scope that you
can affix to a1 to please it, so it will always error.

The reason it has both Floating and Integral on the same type is that you
are using several functions on various arguments of your function that
imply that the types of those arguments must be instances of various
classes.

fromIntegral :: (Integral a, Num b) => a -> b
sumOfMinusMeans :: (Eq t, Floating t) => Int -> t -> [[t]] -> t
sqrt :: Floating a => a -> a -- (this function may not be a factor)

I strongly recommend you write out a type for stdDev, but fix a1 to a
concrete type and then ghc can tell you why that type won't work.
stdDev :: Int -> Int -> [Double] -> [[Double]] -> [Double]

    • No instance for (Integral Double)
        arising from a use of ‘fromIntegral’

stdDev :: Int -> Int -> [Integer] -> [[Integer]] -> [Double]

    • No instance for (Floating Integer)
        arising from a use of ‘sumOfMinusMeans’

And then think really hard about what types you want stdDev to accept.
Rework its the definition until the compiler is happy.  I suspect it is an
extraneous fromIntegral.

On Thu, Aug 23, 2018 at 6:26 AM, Jack Vice <jack.v...@gmail.com> wrote:

> I am trying to calculate the standard deviation for each index in a list
> of lists of floats. Using Ubuntu 18.04, ghc 8.0.2. I am getting the
> following runtime error which I have googled and still don't understand
> what "Integral Float" is exactly or even which parameter is causing the
> trouble.
>
> *Main> let z = stdDev 0 2 y x
> <interactive>:250:9: error:
> • Could not deduce (Integral Float) arising from a use of ‘stdDev’
>   from the context: Floating a
>     bound by the inferred type of z :: Floating a => [a]
>     at <interactive>:250:5-38
> • In the expression: stdDev 0 (length (head (x))) y x
>   In an equation for ‘z’: z = stdDev 0 (length (head (x))) y x
>
> Code:
>
> -- i is start index, l is length of each list, ms is list of means,
> --    xs is Matrix
> stdDev i l ms xs
>      | i < l     = sqrt(fromIntegral(sumOfMinusMeans i (ms!!i) xs) /
>                              fromIntegral(l)):(stdDev (i+1) l ms xs)
>      | otherwise = []
>
> --i is index, m is mean for the index
> sumOfMinusMeans i m (x:xs)
>      | xs == []     = (x!!i - m)**2
>      | i < length x = (x!!i - m)**2 + (sumOfMinusMeans i m xs)
>      | otherwise    = 0
>
> Types:
>
> *Main> :t stdDev
> stdDev
>   :: (Floating a1, Floating a, Integral a1) =>
>      Int -> Int -> [a1] -> [[a1]] -> [a]
>
> *Main> :t sumOfMinusMeans
> sumOfMinusMeans :: (Eq t, Floating t) => Int -> t -> [[t]] -> t
>
> Variables:
>
> *Main> y
> [380.0,1.0]
> *Main> x
> [[600.0,1.0],[400.0,1.0],[170.0,1.0],[430.0,1.0],[300.0,1.0]]
>
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: 
<http://mail.haskell.org/pipermail/beginners/attachments/20180823/431893c4/attachment-0001.html>

------------------------------

Subject: Digest Footer

_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners


------------------------------

End of Beginners Digest, Vol 122, Issue 14
******************************************

Reply via email to