Добавить действие без изменения результата в рефакторинг do-notation

Question

Я хочу последовательно составлять два действия монады в Haskell, отбрасывая любое значение, созданное вторым, и передавая аргумент обоим действиям. В настоящее время я использую Do-блок, как это:

ask = do 
    result <- getLine 
    putStrLn result 
    return result 

Я надеялся написать эту немного больше безточечный и аккуратно, поэтому я попытался это:

ask' = getLine <* putStrLn 

Однако это Безразлично» t даже проверить тип, и проблема в том, что <* не передает результат первого действия ко второму. Я хочу связать действия, например, >>=, но не изменить результат. Тип должен быть (a -> m b) -> (a -> m c) -> (a -> m b), но Hoogle не дает подходящих результатов. Что было бы оператором для достижения этой функции?

Answer 1

В тенденции, если вы используете одно значение в двух разных местах, это, вероятно, это хорошая идея, чтобы дать ему имя в ясном do блоке, а не нажимать на бессмысленный стиль.

Абстрактная концепция разделения потока информации на различные действия зафиксирована в cartesian monoidal categories, известном Haskellers как arrows. В вашем случае, вы в основном работаете в категории IO Клейли:

import Prelude hiding (id) 
import Control.Arrow 

ask' :: Kleisli IO() String 
ask' = Kleisli (\()->getLine) >>> (putStrLn &&& id) >>> arr snd 

Я не думаю, что это хорошая идея, чтобы написать такой код.

Answer 2

Я хочу последовательно составлять два действия монады в Haskell, отбрасывая любое значение, полученное вторым, и передавая аргумент обоим действиям.

Это звучит для меня как Reader -функции типа r -> m a изоморфен ReaderT r m a, и монада работает неявно затыкать в том же r значения во все «дырку». Так, например:

import Control.Applicative 
import Control.Monad.Reader 

example :: IO String 
example = getLine >>= discarding putStrLn 

discarding :: Monad m => (a -> m b) -> a -> m a 
discarding action = runReaderT (ReaderT action *> ask) 

Оператор вы хотите, то что-то вроде:

action `thingy` extra = action >>= discarding extra 

Но конечно discarding имеет более простую реализацию:

discarding :: Applicative f => (a -> f b) -> a -> f a 
discarding action a = action a *> return a 

... так в конце концов, Я думаю, что это действительно кодовый гольф. Но в более сложной программе, где это общая картина в более широком масштабе, это может стоить того.В принципе, если у вас есть:

a0 :: r -> m a0 
a1 :: r -> m a1 
    . 
    . 
    . 
an :: r -> m an 

Отсюда следует, что:

ReaderT a0 :: ReaderT r m a0 
ReaderT a1 :: ReaderT r m a1 
    . 
    . 
    . 
ReaderT an :: ReaderT r m an 

И потом:

runReaderT (ReaderT a0 <* ReaderT a1 <* ... <* ReaderT an) :: r -> m a0 

Answer 3

Для полноты, в данном конкретном случае (IO) монады, вы могли бы также злоупотребление bracket для этой цели:

bracket getLine putStrLn return 

Но я сильно отговариваю его, так как это будет гораздо менее читаемым, чем исходный блок-блок, это просто уродливо.

Как уже упоминалось, в этом конкретном случае наименование результата представляется наилучшим способом.

Смотрите также Should do-notation be avoided in Haskell?