Existe-t-il un équivalent Monoid de Bifunctor?

Question

Lorsque vous travaillez avec un Bifunctor, nous avons accès aux fonctions "carte" first et second. Donc, fondamentalement, c'est un Functor qui nous permet de fmap de deux façons différentes.

Y a-t-il quelque chose comme ceci pour Monoid? Un concept qui nous permet d'ajouter de deux manières différentes? Par exemple, imaginez un type Matrix opaque. Ce n'est pas une liste de listes ou un vecteur de vecteurs, nous n'avons aucune idée de la façon dont elle est structurée à l'intérieur, mais nous savons que nous pouvons y ajouter des lignes et des colonnes.

Y aurait-il une classe de type autorisée à le faire?

class X a where 
    firstAppend :: a -> a -> a 
    secondAppend :: a -> a -> a 

instance X Matrix where 
    firstAppend = appendRow 
    secondAppend = appendColumn 

Answer 1

Je suppose que vous pourriez faire quelque chose comme ça avec Monoïdes indexées:

{-# LANGUAGE PolyKinds  #-} 
{-# LANGUAGE KindSignatures #-} 
{-# LANGUAGE TypeFamilies #-} 

module IndexedMonoids where 

class MonoidIx (m :: k -> *) where 
    type Null m :: k 
    type Mult m (i :: k) (j :: k) :: k 

    nullIx :: m (Null m) 
    multIx :: m i -> m j -> m (Mult m i j) 

class MonoidIx2 (m :: k -> l -> *) where 
    type Null1 m :: k 
    type Null2 m :: l 
    type Mult1 m (i :: k) (j :: k) :: k 
    type Mult2 m (p :: l) (q :: l) :: l 

    null1Ix :: m (Null1 m) p 
    null2Ix :: m i (Null2 m) 
    mult1Ix :: m i p -> m j p -> m (Mult1 m i j) p 
    mult2Ix :: m i p -> m i q -> m i (Mult2 m p q) 

Vous vous attendez un tas de lois (identité, associativité, commutativité lorsque vous mettez 4 blocs ensemble). Un exemple trivial d'un Monoid indexé: celui où l'indice n'a pas d'importance:

newtype Dummy (m :: *) (i :: k) = Dummy { getDummy :: m } 

instance Monoid m => MonoidIx (Dummy m :: * -> *) where 
    type Null (Dummy m)  =() 
    type Mult (Dummy m) i j =() 

    nullIx = Dummy mempty 
    multIx (Dummy i) (Dummy j) = Dummy $ mappend i j 

Je vais vous laisser mettre en œuvre l'instance pour les matrices;)