[Haskell-cafe] Re: Associated Type Synonyms question

Martin Sulzmann sulzmann at comp.nus.edu.sg
Thu Feb 16 03:46:43 EST 2006

Stefan Wehr writes:
 > Niklas Broberg <niklas.broberg at gmail.com> wrote::
 > > On 2/10/06, Ross Paterson <ross at soi.city.ac.uk> wrote:
 > >> On Fri, Feb 10, 2006 at 05:20:47PM +0100, Niklas Broberg wrote:
 > >> > - when looking at the definition of MonadWriter the Monoid constraint
 > >> > is not strictly necessary, and none of the other mtl monads have
 > >> > anything similar. Is it the assumption that this kind of constraint is
 > >> > never really necessary, and thus no support for it is needed for ATS?
 > >>
 > >> I think that's right -- it's only needed for the Monad instance for
 > >> WriterT.  But it is a convenience.  In any instance of MonadWriter, the
 > >> w will be a monoid, as there'll be a WriterT in the stack somewhere,
 > >> so the Monoid constraint just saves people writing general functions
 > >> with MonadWriter from having to add it.
 > >
 > > Sure it's a convenience, and thinking about it some more it would seem
 > > like that is always the case - it is never crucial to constrain a
 > > parameter. But then again, the same applies to the Monad m constraint,
 > > we could give the same argument there (all actual instances will be
 > > monads, hence...). So my other question still stands, why not allow
 > > constraints on associated types as well, as a convenience?
 > Manuel (Chakravarty) and I agree that it should be possible to
 > constrain associated type synonyms in the context of class
 > definitions. Your example shows that this feature is actually
 > needed. I will integrate it into phrac within the next few days.

By possible you mean this extension won't break any
of the existing ATS inference results?
You have to be very careful otherwise you'll loose decidability.

Something more controversial.
Why ATS at all? Why not encode them via FDs?


-- ATS
class C a where
  type T a
  m :: a->T a
instance C Int where
  type T Int = Int
  m _ = 1

-- FD encoding
class T a b | a->b 
instance T Int Int

class C a where
  m :: T a b => a->b

instance C Int where
  m _ = 1

-- general recipe:
-- encode type functions T a via type relations T a b
-- replace T a via fresh b under the constraint C a b

The FD program won't type check under ghc but this
doesn't mean that it's not a legal FD program.
It's wrong to derive certain conclusions
about a language feature by observing the behavior
of a particular implementation!



More information about the Haskell-Cafe mailing list