Parameterizing properties with DerivingVia - Haskell

-- |Int-ranked min leftist heap yo
data LeftHeap' prio a =
    E
  | T Int a (LeftHeap' prio a) (LeftHeap' prio a)
  deriving (Show, Eq, Functor, Foldable)
type LeftHeap a = LeftHeap' MinPolicy a

data MinPolicy
data MaxPolicy

class MergeOrd p where
    compareByPriority :: Ord a => a -> a -> Bool

instance MergeOrd MinPolicy where ...
instance MergeOrd MaxPolicy where ...

instance (MergeOrd prio) => Heap (LeftHeap' prio) where
    merge :: (Ord a) => LeftHeap' prio a -> LeftHeap' prio a -> LeftHeap' prio a
    merge h1 h2
    | comparePriority @prio h1 h2 = ...
      | otherwise                    = ...
    ...

-- |Leftist Heap w/ minimum values at head
newtype MinHeap a = MinHeap
  { unMinHeap :: LeftHeap' MinPolicy a }
  deriving stock (Show, Eq)
  deriving Heap via (LeftHeap' MinPolicy)

-- |Leftist Heap w/ maximum values at head
newtype MaxHeap a = MaxHeap
  { unMaxHeap :: LeftHeap' MaxPolicy a }
  deriving stock (Show, Eq)
  deriving Heap via (LeftHeap' MaxPolicy)

data F_lte_R     -- ^ Rebalance when size of front list is equal to size of rear
data TwoF_lte_R  -- ^ Rebalance when twice the size of front list is equal to size of rear

class BalanceCondition c where
  needsRebalance :: Int -> Int -> Bool

instance BalanceCondition F_lte_R where ...
instance BalanceCondition TwoF_lte_R where ...

instance (BalanceCondition invariant) => Queue (BankersQueue' invariant) where
    ... -- some code branching on `needsRebalance @invariant`

type BankersQueue a = BankersQueue' F_lte_R a

newtype LessMovementBQ a = LessMovementBQ
  { unLessMovementBQ :: (BankersQueue' TwoF_lte_R a) }
  deriving stock (Show, Eq, Functor, Foldable)
  deriving Queue via (BankersQueue' TwoF_lte_R)