#3005: Normalize fully-applied type functions prior to display
---------------------------------+------------------------------------------
Reporter: dmcclean | Owner: chak
Type: feature request | Status: new
Priority: normal | Milestone:
Component: GHCi | Version: 6.10.1
Severity: normal | Resolution:
Keywords: | Difficulty: Unknown
Testcase: | Os: Unknown/Multiple
Architecture: Unknown/Multiple |
---------------------------------+------------------------------------------
Changes (by igloo):
* difficulty: => Unknown
Old description:
> I have a module with a matrix type constructor:
>
> > data (Natural r, Natural c) => Matrix r c t = Matrix [[t]] deriving
> (Eq)
>
> which uses type-level naturals to provide dimension checking.
>
> A type class for multiplication:
>
> > class Multiply a b where
> > type Product a b
> > times :: a -> b -> Product a b
>
> and an instance for matrix multiplication:
>
> > instance (Natural a, Natural b, Natural c, Num t) => Multiply (Matrix a
> b t) (Matrix b c t) where
> > type Product (Matrix a b t) (Matrix b c t) = Matrix a c t
> > times m1 m2 = ...
>
> All of this works really well, I get dimension checking (and inference),
> and lot of other goodies.
>
> My request has to do with the following GHCi session:
>
> *Main> let a = matrix two two [[1,1],[2,6]]
> *Main> :t a
> a :: Matrix Two Two Integer
> *Main> :t a `times` a
> a `times` a :: Product
> (Matrix Two Two Integer) (Matrix Two Two Integer)
>
> When a type function is fully-applied, as Product is in this case, it
> would be nice if GHC could simplify it prior to display.
>
> This would result in the following output for this example:
>
> :t a `times` a
> a `times` a :: Matrix Two Two Integer
>
> I have attached the files necessary to run this test case, although a
> simpler one could be constructed.
New description:
I have a module with a matrix type constructor:
{{{
> data (Natural r, Natural c) => Matrix r c t = Matrix [[t]] deriving (Eq)
}}}
which uses type-level naturals to provide dimension checking.
A type class for multiplication:
{{{
> class Multiply a b where
> type Product a b
> times :: a -> b -> Product a b
}}}
and an instance for matrix multiplication:
{{{
> instance (Natural a, Natural b, Natural c, Num t) => Multiply (Matrix a
b t) (Matrix b c t) where
> type Product (Matrix a b t) (Matrix b c t) = Matrix a c t
> times m1 m2 = ...
}}}
All of this works really well, I get dimension checking (and inference),
and lot of other goodies.
My request has to do with the following GHCi session:
{{{
*Main> let a = matrix two two [[1,1],[2,6]]
*Main> :t a
a :: Matrix Two Two Integer
*Main> :t a `times` a
a `times` a :: Product
(Matrix Two Two Integer) (Matrix Two Two Integer)
}}}
When a type function is fully-applied, as Product is in this case, it
would be nice if GHC could simplify it prior to display.
This would result in the following output for this example:
{{{
:t a `times` a
a `times` a :: Matrix Two Two Integer
}}}
I have attached the files necessary to run this test case, although a
simpler one could be constructed.
--
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/3005#comment:3>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler_______________________________________________
Glasgow-haskell-bugs mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs
