Композиция функций Do Notation

Как уже упоминалось leftaroundabout, вы можете использовать Arrows для написания своей функции. Но в компиляторе ghc Haskell есть функция, которая представляет собой proc-нотацию для стрелок. Она очень похожа на известную do-нотацию, но, к сожалению, мало кто о ней знает.

С помощью proc-нотации вы можете написать нужную функцию следующим более удобным и элегантным способом:

{-# LANGUAGE Arrows #-}

import Control.Arrow (returnA)
import Data.List     (maximum)

composed :: [String] -> [String]
composed = proc l -> do
    bangedL <- fmap (++"!!!")        -< l
    maxLen  <- maximum . fmap length -< bangedL
    returnA -< filter ((== maxLen) . length) bangedL

И это работает в ghci как и ожидалось:

ghci> composed ["alice", "bob", "david"]
["alice!!!","david!!!"]

Если вам интересно, вы можете прочитать несколько руководств с красивыми картинками, чтобы понять, что такое стрелка и как работает эта мощная функция, чтобы вы могли глубже погрузиться в нее:

https://www.haskell.org/arrows/index.html

https://en.wikibooks.org/wiki/Haskell/Understanding_arrows

Одним из возможных способов добиться чего-то подобного являются стрелки. По сути, при «сохранении промежуточных результатов» вы просто разделяете информационный поток по цепочке создания. Это то, что &&& (разветвление) делает комбинатор.

import Control.Arrow

composed = fmap (++ "!!!")
       >>> ((. length) . (==) . maximum . fmap length &&& id)
       >>> uncurry filter

Это определенно не является хорошим понятным для человека кодом.

Монада состояния, казалось бы, тоже допускает что-то связанное, но проблема в том, что тип состояния фиксируется через монадическую цепочку блока do. Это недостаточно гибко, чтобы подбирать значения разных типов по всей цепочке композиции. Хотя это, безусловно, можно обойти (среди них, действительно, RebindableSyntax), это тоже не очень хорошая идея, IMO.

Тип (<*>), специализированный для экземпляра функции Applicative:

(<*>) :: (r -> a -> b) -> (r -> a) -> (r -> b)

Результирующая функция r -> b передает свой аргумент обеим функциям r -> a -> b и r -> a, а затем использует значение a, полученное функцией r -> a, в качестве второго аргумента функции r -> a -> b.

Какое это имеет отношение к вашей функции? filter — это функция двух аргументов, предиката и списка. Теперь ключевым аспектом того, что вы пытаетесь сделать, является то, что предикат генерируется из списка. Это означает, что ядро ​​вашей функции может быть выражено в терминах (<*>):

-- Using the predicate-generating function from leftaroundabout's answer.
maxLengthOnly :: Foldable t => [t a] -> [t a]
maxLengthOnly = flip filter <*> ((. length) . (==) . maximum . fmap length)

composed :: [String] -> [String]
composed = maxLengthOnly . fmap (++ "!!!")

Это maxLengthOnly определение было бы довольно хорошим однострочником, если бы функция генерации бесточечных предикатов не была такой неуклюжей.

Поскольку экземпляр функций Applicative эквивалентен по мощности экземпляру Monad, maxLengthOnly можно также сформулировать так:

maxLengthOnly = (. length) . (==) . maximum . fmap length >>= filter

(Кстати, split, которое вы добавили к своему вопросу, — это (>>=) для функций.)

Другой способ записи с Applicative:

maxLengthOnly = filter <$> ((. length) . (==) . maximum . fmap length) <*> id

Не случайно это очень похоже на решение leftaroundabout: для функций (,) <$> f <*> g = liftA2 (,) f g = f &&& g.

Наконец, также стоит отметить, что хотя и заманчиво заменить id в последней версии maxLengthOnly на fmap (++ "!!!"), это не сработает, поскольку fmap (++ "!!!") изменяет длину строк и, следовательно, влияет на результат предиката. Однако с функцией, которая не делает недействительным предикат, это будет работать очень хорошо:

nicerComposed = filter
    <$> ((. length) . (==) . maximum . fmap length) <*> fmap reverse

GHCi> nicerComposed ["alice","bob","david"]
["ecila","divad"]

То, что у вас есть, по сути является фильтром, но функция фильтрации меняется по мере того, как вы перебираете список. Я бы смоделировал это не как "разветвленную" композицию, а как складку, используя следующую функцию f :: String -> (Int, [String]):

1. Возвращаемое значение поддерживает текущий максимум и все строки этой длины.
2. Если первый аргумент короче текущего максимума, отбросить его.
3. Если первый аргумент совпадает с текущим максимумом, добавьте его в список.
4. Если первый аргумент длиннее, сделайте его длину новой максимальной и замените текущий список вывода новым списком.

После завершения сворачивания вы просто извлекаете список из кортежа.

-- Not really a suitable name anymore, but...
composed :: [String] -> [String]
composed = snd . foldr f (0, [])
    where f curr (maxLen, result) = let currLen = length curr
                                    in case compare currLen maxLen of
                                       LT -> (maxLen, result)       -- drop
                                       EQ -> (maxLen, curr:result)  -- keep
                                       GT -> (length curr, [curr])  -- reset