Re: [Haskell-beginners] Concrete instance of abstract class

6 Jun 2013

      I'm starting to tidy it up:

class Turtlish t where
  type Context t  :: *
  type Content t  :: *
  construct       :: Content t -> Context t -> t
  destruct        :: t -> (Content t, Context t)
  combine         :: Content t -> Content t -> Content t
  contemp         :: Context t -> Context t -> Context t
  conform         :: Context t -> t -> t
  present         :: t -> Dia
  content         :: t -> Content t
  content         = fst.destruct
  context         :: t -> Context t
  context         = snd.destruct
  (>>>),(+++)     :: t -> t -> t
  x +++ y         = construct (content x `combine` content y) (context x
`contemp` context y)
  x >>> y         = x +++ conform (context x) y

but I hit this:

turtle.hs:23:32:
    Could not deduce (Content t ~ Content t0)
    from the context (Turtlish t)
      bound by the class declaration for `Turtlish'
      at turtle.hs:(9,1)-(24,47)
    NB: `Content' is a type function, and may not be injective
    In the return type of a call of `content'
    In the first argument of `combine', namely `content x'
    In the first argument of `construct', namely
      `(content x `combine` content y)'

turtle.hs:23:64:
    Could not deduce (Context t ~ Context t1)
    from the context (Turtlish t)
      bound by the class declaration for `Turtlish'
      at turtle.hs:(9,1)-(24,47)
    NB: `Context' is a type function, and may not be injective
    In the return type of a call of `context'
    In the first argument of `contemp', namely `context x'
    In the second argument of `construct', namely
      `(context x `contemp` context y)'

What does this mean, and how do I fix it?

TIA,
Adrian.

On 6 June 2013 11:28, Adrian May <adrian.alexander.may@gmail.com> wrote:
...
Hi Brent,
...
I would do this using an associated
type, like so:
class Turtlish t where
  type TState t :: *
  pic           :: t -> Dia
  state         :: t -> TState t
  move          :: TState t -> t -> t
  (>>>),(+++)   :: t -> t -> t
  x >>> y = x +++ move (state x) y
Bingo. Just what I needed. But is this a Haskellish thing to do or am I
showing my C++ background by even wanting something like this? Anyway,
for the sake of any future googlers, I needed  {-# LANGUAGE TypeFamilies
#-} and completed the instance with:
instance Turtlish TurtWorld where
  type TState TurtWorld = TurtState
  ...
Thanks,
Adrian.
...