Re: [Haskell-beginners] Could not deduce (Matrix m (Maybe a)) from the context (Matrix m a)

29 Jan 2010

      Thanks Daniel.

It works, but I'm a bit confused as to why the extra type information is needed.

On Fri, Jan 29, 2010 at 5:17 PM, Daniel Fischer
 wrote:
...
Am Freitag 29 Januar 2010 09:52:37 schrieb Lyndon Maydwell:
...
Hi Beginners.
I'm writing a matrix class for a game of life implementation. When I
try to compile it I get the error "Could not deduce (Matrix m (Maybe
a)) from the context (Matrix m a)" for the method vicinityMatrix.
However, when I query the type of an identical implementation to
vicinityMatrix in ghci it is successful:
:t \m x y -> fromRows $ vicinityRows m x y
\m x y -> fromRows $ vicinityRows m x y
  :: forall (m :: * -> *) (m1 :: * -> *) a.
     (Matrix m (Maybe a), Matrix m1 a) =>
     m1 a -> Integer -> Integer -> m (Maybe a)
What might be preventing the class from compiling?
Well, the error says the compiler (the type checker) can't deduce the
context (Matrix m (Maybe a)) from the givens. If you supply that
information,
vicinityMatrix :: Matrix m (Maybe a) =>
              m a -> Integer -> Integer -> m (Maybe a)
it'll work.
...
Thanks guys.
---
My Matrix class definition follows below:
module Matrix (Matrix) where
import Data.Array
import Data.Maybe (catMaybes)
import Control.Monad (guard)
class Matrix m a
  where
    fromRows       :: [[a]] -> m a
    toList         :: m a   -> [a]
    rows           :: m a   -> Integer
    columns        :: m a   -> Integer
    row            :: m a   -> Integer -> [a]
    column         :: m a   -> Integer -> [a]
    at             :: m a   -> Integer -> Integer -> a
    (!!!)          :: m a   -> Integer -> Integer -> a
    vicinityRows   :: m a   -> Integer -> Integer -> [[Maybe a]]
    vicinityMatrix :: m a   -> Integer -> Integer -> m (Maybe a)
    neighbours     :: m a   -> Integer -> Integer -> [a]
    toList m = do
      x <- [0 .. columns m - 1]
      y <- [0 .. rows m - 1]
      return $ at m x y
    row    m n = [at m x n | x <- [0 .. columns m - 1]]
    column m n = [at m n y | y <- [0 .. rows    m - 1]]
    at    = (!!!)
    (!!!) = at
    vicinityRows m x y = do
      x' <- [x - 1 .. x + 1]
      return $ do
        y' <- [y - 1 .. y + 1]
        return cell where
          cell
            | x <  0         = Nothing
            | y <  0         = Nothing
            | x >= columns m = Nothing
            | y >= rows m    = Nothing
            | otherwise      = Just $ at m x y
    vicinityMatrix m x y = fromRows $ vicinityRows m x y
    -- neighbours = catMaybes . toListN . vicinityMatrix
toListN :: Matrix m a => m a -> [a]
toListN m = do
  x <- [0 .. columns m - 1]
  y <- [0 .. rows m - 1]
  guard $ x /= 1 && y /= 1
  return $ at m x y