Derive instance {Fractional, RealFrac, Floating, RealFloat} Compose f g a

[jship]

In the same vein as #160, seems like Compose could use a few more instances:

deriving instance Fractional (f (g a)) => Fractional (Compose f g a)
deriving instance RealFrac (f (g a)) => RealFrac (Compose f g a)
deriving instance Floating (f (g a)) => Floating (Compose f g a)
deriving instance RealFloat (f (g a)) => RealFloat (Compose f g a)

I'm working with a DSL that is compatible with Compose, so with these instances (in particular, Fractional and Floating) I can make numerical functions that are unconcerned with whether or not Compose is used under the hood for the values.

[tomjaguarpaw]

Can you show some examples?

[jship]

I noticed the missing Fractional instance from experimenting with wrapping linear's vector types in a Compose, where the type parameter is some type isomorphic to Identity with domain-specific meaning (here I'll opt for Identity for simplicity):

type V3Wrapped :: (Type -> Type) -> Type
type V3Wrapped f = Compose f V3 Double -- a.k.a. f (V3 Double)

type PointWrapped :: (Type -> Type) -> Type
type PointWrapped f = Compose f (Point V3) Double -- a.k.a. f (Point V3 Double)

As of the the Num instance being added for Compose in #160, these wrapped vectors can be constructed with literal syntax just like the underlying vector type:

litNumV3 :: V3 Double
litNumV3 = 42

litNumV3Wrapped :: V3Wrapped Identity Double
litNumV3Wrapped = 42

Without a Fractional instance, the wrapped vector cannot be constructed with literal syntax while the underlying vector can be:

litFractionalV3 :: V3 Double
litFractionalV3 = 42.5

-- error: No instance for (Fractional (V3Wrapped Identity Double))
litFractionalV3Wrapped :: V3Wrapped Identity Double
litFractionalV3Wrapped = 42.5

Similarly, the Num instance allows for addition/multiplication of the wrapped vectors just as if we were using the underlying vector directly:

addV3 :: V3 Double -> V3 Double -> V3 Double
addV3 v1 v2 = v1 + v2

addV3Wrapped :: V3Wrapped Identity Double -> V3Wrapped Identity Double -> V3Wrapped Identity Double
addV3Wrapped v1 v2 = v1 + v2

Without a Fractional instance, the wrapped vector types cannot be divided, but the underlying vector types can be divided:

divV3 :: V3 Double -> V3 Double -> V3 Double
divV3 v1 v2 = v1 / v2

-- error: No instance for (Fractional (V3Wrapped Identity Double))
divV3Wrapped :: V3Wrapped Identity Double -> V3Wrapped Identity Double -> V3Wrapped Identity Double
divV3Wrapped v1 v2 = v1 / v2

[mixphix]

Yeah... we've already got Num instances, might as well add the rest of the RealFrac hierarchy. Writing integer literals for types that aren't plain numbers is fine I think, so why not decimals?

[Bodigrim]

@jship could you please raise an MR which CLC can vote on?

[jship]

Here's the MR: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/11890

[Bodigrim]

Dear CLC members, let's vote on the proposal to add more numeric instances for Compose f g a, continuing the work started in #160. The MR is available at https://gitlab.haskell.org/ghc/ghc/-/merge_requests/11890/diffs.

@tomjaguarpaw @mixphix @hasufell @velveteer @angerman @parsonsmatt

---

+1 from me. The instances are automatic derivations, correct by construction.

[tomjaguarpaw]

+1

---

It seems like part of the point of having Compose is carrying all the instances over.

[velveteer]

+1

[hasufell]

+1

[mixphix]

+1

[Bodigrim]

Thanks all, that's enough votes to approve.