Add iso-deriving for Unboxed instances

[Shimuuar]

Another take on use of DerivingVia for defining Unbox instances. This should largely subsume TH-based deriving from th-vector-unbox. Verbosity is about same and there's no TH which is frequently breaks with each GHC release

P.S. It's still too verbose. I think use of data family was a mistake. They couldn't be derived and have to be defined for each type. On top of it we only have handful of possible representations. Type family + newtype wrapper for injectivity would've worked out much better.

[lehins]

I love it!

It is similar to what I was suggesting here: #315 (comment) but better

[lehins]

What do you think about adding a default implementation that uses Coercible?

Suggested change

	class Isomorphic a b where
	-- | Convert value into it representation in unboxed vector.
	toURepr :: a -> b
	-- | Convert value representation in unboxed vector back to value.
	fromURepr :: b -> a
	class Isomorphic a b where
	-- | Convert value into it representation in unboxed vector.
	toURepr :: a -> b
	default toURepr :: Coercible a b => a -> b
	toURepr = coerce
	-- | Convert value representation in unboxed vector back to value.
	fromURepr :: b -> a
	default fromURepr :: Coercible b a => b -> a
	fromURepr = coerce

We do already have an ability to use GND for newtypes, but I don't think coercible would hurt here.

[Shimuuar]

I wonder are there cases when one could coerce but not GND? I need to think about this. Obvious downside it prevents other possible implementations

Also most important use case should be converting between product types and tuples. I'll try to cook up something using generics to see whether its possible

[Shimuuar]

I started writing pessimistic reply about how we can't have good default instance... And then come up with interesting idea. We should coerce between generic representations and not between values themselves. As and illustration:

λ> data Foo = Foo Int Char deriving (Show,Generic)
λ> to . coerce . from $ Foo 1 'c' :: (Int,Char)
(1,'c')
λ> to . coerce . from $ Foo 1 'c' :: (Sum Int,Char)
(Sum {getSum = 1},'c')
λ> to . coerce . from $ (Sum (1::Int), 'c') :: Foo
Foo 1 'c'

It's even able to coerce between fields! This is definition I propose (sans INLINE):

class IsoUnbox a b where
  -- | Convert value into it representation in unboxed vector.
  toURepr   :: a -> b
  default toURepr :: (Generic a, Generic b, Coercible (Rep a ()) (Rep b ())) => a -> b
  toURepr = to . idU . coerce . idU . from
  -- | Convert value representation in unboxed vector back to value.
  fromURepr :: b -> a
  default fromURepr :: (Generic a, Generic b, Coercible (Rep b ()) (Rep a ())) => b -> a
  fromURepr = to . idU . coerce . idU . from

idU :: f () -> f ()
idU = id

Only question is whether GHC guarantees that data types with same shape will have same shape. Think (a :*: b) :*: c vs a :*: (b :*: c). I think they do but documentation is silent about this.

[Shimuuar]

I added generic-based instance for IsoUnbox. It looks very nice. Only question is performance. I think it should be fine since we don't do anything except calling to and from

[Shimuuar]

I've added inspection tests for iso-deriving. GHC is able to opmitise waya both generics and even data type constructors. Syntax is bearable although a bit too verbose:

data Foo a = Foo Int a
  deriving (Show,Generic)

instance VU.IsoUnbox (Foo a) (Int,a) where

newtype instance VU.MVector s (Foo a) = MV_Int (VU.MVector s (Int, a))
newtype instance VU.Vector    (Foo a) = V_Int  (VU.Vector    (Int, a))

instance VU.Unbox a => VU.Unbox (Foo a)
deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VGM.MVector VU.MVector (Foo a)
deriving via (Foo a `VU.As` (Int, a)) instance VU.Unbox a => VG.Vector   VU.Vector  (Foo a)

Core is quite nice too.