Есть ли бесплатный способ конвертировать условную проверку в тип Maybe типа ввода?

Question

Я просто проработал несколько простых упражнений в haskell и задавался вопросом, существует ли простой способ преобразования инструкции if-then-else в тип Maybe: Nothing возвращается, если условие ложно, и Just вход если условие истинно.

Короче говоря, учитывая некоторые из них:

maybeIf :: (a -> Bool) -> a -> Maybe a 
maybeIf cond a = if cond a then Just a else Nothing 

Есть ли реализация, которая является точкой, свободной по отношению к a? Я также смотрел более конкретную версию, a -> Maybe a, и чувствую, что может быть ответ где-то в Control.Arrow. Однако, поскольку Maybe является типом данных, а операторы if-else управляют потоком данных, я не уверен, есть ли чистый способ сделать это.

Answer 1

Вы можете импортировать find из Data.Foldable, а затем это довольно просто:

import Data.Foldable(find) 

maybeIf cond = find cond . Just 

Функция find не сложно, так что вы могли бы довольно легко определить он сам менее общий, с точки зрения Maybe, но это не " t на самом деле так отличается от вашей собственной реализации maybeIf, поэтому вы можете не получить много, в зависимости от того, почему вы хотели это сделать.

Answer 2

Главное, что делается для того, чтобы сделать эту точку свободной: if/then/else. Вы можете определить if' комбинатора, или вы можете использовать эту обобщенную версию, что я определяю и часто используете:

ensure p x = x <$ guard (p x) 

Стандартных инструменты дают последовательные версии точечной бесплатно в

ensure p = ap (<$) (guard . p) 
ensure = ap (<$) . (guard .) 

хотя я действительно не думаю, что они лучше, чем точечные версии.

Answer 3

Если мы выбираем церковную-кодирование для Booleans ...

truth :: Bool -> a -> a -> a 
truth True t f = t 
truth False t f = f 

Тогда мы можем написать точечно бесплатно maybeIf в Applicative стиле.

maybeIf :: (a -> Bool) -> a -> Maybe a 
maybeIf = liftA3 truth <*> pure Just <*> pure (pure Nothing) 

Некоторых интуитивные ...

f <$> m₁ <*> … <*> mₙ = \x -> f (m₁ x) … (mₙ x) 
liftAₙ f <$> m₁ <*> … <*> mₙ = \x -> f <$> m₁ x <*> … <*> mₙ x 

Вот рендеринг в формате PNG из выше «интуиции», в случае, если ваши установленные шрифты не поддерживают необходимые символы Юникода.

И поэтому:

liftA3 truth <*> pure Just <*> pure (pure Nothing) 
= liftA3 truth <$> id <*> pure Just <*> pure (pure Nothing) 
= \p -> truth <$> id p <*> (pure Just) p <*> (pure (pure Nothing)) p 
= \p -> truth <$> p <*> Just <*> pure Nothing 
= \p -> \a -> truth (p a) (Just a) ((pure Nothing) a) 
= \p -> \a -> truth (p a) (Just a) Nothing 

Answer 4

После dfeuer's lead (и используя новое имя Даниэля Вагнера для этой функции),

import Data.Bool (bool) 
--   F T  
-- bool :: a -> a -> Bool -> a 

ensure :: (a -> Bool) -> a -> Maybe a 
ensure p x = bool (const Nothing) Just (p x) x 

ensure p = join (bool (const Nothing) Just . p) 
      = bool (const Nothing) Just =<< p 

ensure  = (bool (const Nothing) Just =<<) 

join является монадической функцией, join :: Monad m => m (m a) -> m a, но для функций это просто

join k x = k x x 
(k =<< f) x = k (f x) x 

join принимаются как замену на W combinator в бесплатном коде.

Вы только хотели его точечными бесплатно по аргументу значение, но это легко преобразовать уравнение join дальнейшего (читаемость результата еще одна проблема в целом), а

  = join ((bool (const Nothing) Just .) p) 
      = (join . (bool (const Nothing) Just .)) p 

Действительно,

#> (join . (bool (const Nothing) Just .)) even 3 
Nothing 

#> (bool (const Nothing) Just =<<) even 4 
Just 4