Почему я получаю сообщение об ошибке «Перекрывающиеся экземпляры», если один из них не совпадает?

Я пытаюсь разрешить встраивание монады состояния в мою свободную монаду; вот моя простая попытка:

{-# language FlexibleInstances, MultiParamTypeClasses #-}
module Main where

import Control.Monad.Free
import Control.Monad.State
import Data.Bifunctor

data Toy state next =
      Output String next
    | LiftState (state -> (next, state))
    | Done

instance Functor (Toy s) where
  fmap f (Output str next) = Output str $ f next
  fmap f (LiftState stateF) = LiftState (first f . stateF)
  fmap f Done = Done

instance MonadState s (Free (Toy s)) where
  state = overState

overState :: (s -> (a, s)) -> Free (Toy s) a
overState = liftF . LiftState

output :: Show a => a -> Free (Toy s) ()
output x = liftF $ Output (show x) ()

done :: Free (Toy s) r
done = liftF Done

program :: Free (Toy Int) ()
program = do
  start <- get
  output start
  modify ((+10) :: (Int -> Int))
  end <- get
  output end
  done

interpret :: (Show r) => Free (Toy s) r -> s -> IO ()
interpret (Free (LiftState stateF)) s = let (next, newS) = stateF s
                                         in interpret next newS
interpret (Free (Output str next)) s = print str >> interpret next s
interpret (Free Done) s = return ()
interpret (Pure x) s = print x

main :: IO ()
main = interpret program (5 :: Int)

Я получаю сообщение об ошибке:

• Overlapping instances for MonadState Int (Free (Toy Int))
    arising from a use of ‘get’
  Matching instances:
    instance [safe] (Functor m, MonadState s m) =>
                    MonadState s (Free m)
      -- Defined in ‘Control.Monad.Free’
    instance MonadState s (Free (Toy s))
      -- Defined at app/Main.hs:18:10
• In a stmt of a 'do' block: start <- get
  In the expression:
    do { start <- get;
         output start;
         modify ((+ 10) :: Int -> Int);
         end <- get;
         .... }
  In an equation for ‘program’:
      program
        = do { start <- get;
               output start;
               modify ((+ 10) :: Int -> Int);
               .... }

Насколько я могу понять; он пытается применить этот экземпляр:

(Functor m, MonadState s m) => MonadState s (Free m)

из здесь; однако в этом случае он должен соответствовать Free (Toy s), а MonadState s (Toy s) не требуется, поэтому я не понимаю, почему он считает, что он применим.

Если я удалю определение своего экземпляра, я получу:

• No instance for (MonadState Int (Toy Int))
    arising from a use of ‘modify’

Что поддерживает мою мысль о том, что другой экземпляр на самом деле не применяется; Как я могу заставить это скомпилировать, используя мой указанный экземпляр? А можете объяснить, почему это происходит? Это связано с использованием FlexibleInstances?

Спасибо!