Czy ta prosta funkcja Haskella ma już znaną nazwę?

Question

Właśnie napisałem tę funkcję, która po prostu bierze parę, której druga wartość jest w jakiejś monadzie, i "wyciąga monadę", aby pokryć całą parę.

unSndM :: Monad m => (a, m c) -> m (a, c) 
unSndM (x, y) = do y' <- y 
        return (x, y') 

Czy jest lepszy i/lub krótszy, czy wolny od punktu, a nawet standardowy sposób wyrażenia tego?

mam tak daleko, jak poniżej, z -XTupleSections włączone ...

unSndM' :: Monad m => (a, m c) -> m (a, c) 
unSndM' (x, y) = y >>= return . (x,) 

Dzięki!

Answer 1

Jedna drobna uwaga: jest to możliwe, aby napisać to za pomocą tylko fmap (bez >>=), więc naprawdę trzeba tylko Functor instancję:

unSndM :: (Functor f) => (a, f c) -> f (a, c) 
unSndM (x, y) = fmap ((,) x) y 

ta wersja jest nieco bardziej ogólne. Aby odpowiedzieć na pytanie dotyczące wersji pointfree, możemy tylko prosić pointfree:

travis@sidmouth% pointfree "unSndM (x, y) = fmap ((,) x) y" 
unSndM = uncurry (fmap . (,)) 

Tak, tak, jeszcze krótsza wersja jest możliwe, ale ja osobiście uważam uncurry trochę trudne do odczytania i uniknąć w większości przypadków.

Gdybym pisząc tę ​​funkcję w mój własny kod, prawdopodobnie używać <$> z Control.Applicative, który nie ogolił jeden znak:

unSndM :: (Functor f) => (a, f c) -> f (a, c) 
unSndM (x, y) = ((,) x) <$> y 

<$> jest po prostu synonimem fmap, i to mi się podoba sprawia, że ​​jest to trochę bardziej przejrzyste.

Answer 2

Hoogle jest twoim przyjacielem. Jeśli jedna ze standardowych bibliotek miałaby to hoogle dla "Monad m => (a, m b) -> m (a,b)" by to znalazło. Zauważ, że funkcja nadal może być w pakiecie hackage, ale często nie jest warta dodatkowej instalacji dep tylko dla małych funkcji, takich jak ta.

Answer 3

Nie widziałem tego napisanego w żadnej bibliotece Haskella (choć prawdopodobnie jest to w kategoriach dodatków), ale jest ogólnie znane jako "siła tensora" monady. Zobacz:

http://en.wikipedia.org/wiki/Strong_monad

http://comonad.com/reader/2008/deriving-strength-from-laziness/

Answer 4

Jeśli Traversable i Foldable instancje dla (,) x) były w bibliotece (i przypuszczam, że muszę trochę winy za ich braku) ...

instance Traversable ((,) x) where 
    traverse f (x, y) = (,) x <$> f y 

instance Foldable ((,) x) where 
    foldMap = foldMapDefault 

... wtedy ta (czasami określana jako "siła") byłaby specjalizacją Data.Traversable.sequence.

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) 

tak

sequence :: (Monad m) => ((,) x) (m a) -> m (((,) x) a) 

tj

sequence :: (Monad m) => (x, m a) -> m (x, a) 

W rzeczywistości sekwencja naprawdę nie używać pełnej mocy Monad: Applicative zrobi. Co więcej, w tym przypadku parowanie-z-x jest liniowe, a więc traverse raczej niż inne przypadkowe kombinacje pure i <*> i (jak wskazano gdzie indziej) potrzebujesz tylko m, aby mieć strukturę funkturalną.