fork(3) download

copy

{-# LANGUAGE OverlappingInstances, MultiParamTypeClasses,
             FunctionalDependencies, FlexibleContexts,
             FlexibleInstances, UndecidableInstances,
             NoMonomorphismRestriction #-}
 
import qualified Prelude
import Prelude hiding ((+), (*))
import Prelude ()
 
class Times a b c | a b -> c where
    (*) :: a -> b -> c
 
instance Times Int Int Int where
    (*) = (Prelude.*)
 
instance Times Double Double Double where
    (*) = (Prelude.*)
 
instance (Times a b c) => Times a (Matrix b) (Matrix c) where
    l * (r', c', m) = (r', c', \i -> l * m i)
 
instance Times (b -> c) (a -> b) (a -> c) where
    f * g = f . g
 
instance (Times a b c) => Times a (r -> b) (r -> c) where
    x * g = \v -> x * g v
 
instance Times (a -> b) a b where
    f * y = f y
 
type Matrix a = (Int, Int, (Int, Int) -> a)
 
test = (2*(\x -> 2*x))*6
 
main = undefined 

[1 of 1] Compiling Main             ( prog.hs, prog.o )

prog.hs:33:1:
    Could not deduce (Times a1 b0 c1)
      arising from the ambiguity check for `test'
    from the context (Num a,
                      Num a2,
                      Num b,
                      Times (b1 -> c) b c2,
                      Times a (b1 -> c3) (b1 -> c),
                      Times a2 b1 c3)
      bound by the inferred type for `test':
                 (Num a, Num a2, Num b, Times (b1 -> c) b c2,
                  Times a (b1 -> c3) (b1 -> c), Times a2 b1 c3) =>
                 c2
      at prog.hs:33:1-24
    The type variables `a1', `b0', `c1' are ambiguous
    Possible fix: add a type signature that fixes these type variable(s)
    Note: there are several potential instances:
      instance [overlap ok] Times (a -> b) a b
        -- Defined at prog.hs:28:10
      instance [overlap ok] Times a b c => Times a (r -> b) (r -> c)
        -- Defined at prog.hs:25:10
      instance [overlap ok] Times (b -> c) (a -> b) (a -> c)
        -- Defined at prog.hs:22:10
      ...plus three others
    When checking that `test'
      has the inferred type `forall c b c1 a a1 b1 c2.
                             (Num a, Num a1, Num b, Times (b1 -> c) b c1,
                              Times a (b1 -> c2) (b1 -> c), Times a1 b1 c2) =>
                             c1'
    Probable cause: the inferred type is ambiguous

Standard output is empty