Как получить только определенный тип элементов из списка в Haskell?

простое понимание списка будет делать

filterDbDate xs = [ x | DbDate x <- xs ]

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

во-первых,напишите самое простое возможное решение, т. е. решение прямой рекурсии.

filterDbDate :: [DatabaseItem] -> [UTCTime]
filterDbDate ((DbDate time):items) = time:(filterDbDate items)
filterDbDate ( _           :items) =       filterDbDate items

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

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

1. определить тип аккумулятора. Это часто также тип возврата; в этом случае, список. Это дает вам новые первые строки

   filterDbDate :: [DatabaseItem] -> [UTCTime]
   filterDbDate = go []
     where ...
   

2. Теперь возьмите исходную функцию и превратите ее во внутреннюю go функция путем замены каждого рекурсивного вызова с аккумулятор, а затем положить результат в рекурсивный вызов go.

       go acc ((DbDate time):items) = go (time:acc) items
       go acc ( _           :items) = go       acc  items
   

3. добавить обработку конечного случая. Остерегайтесь, что порядок операций будет изменен.

       go acc  []                   = reverse acc
   

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

   filterDbDate = reverse . go []
     where 
       go acc  [] = acc
       ...
   

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

1. замените вызов go с вызовом в фолд.

   filterDbDate :: [DatabaseItem] -> [UTCTime]
   filterDbDate = reverse . foldl f []
   

2. поворот go на f удалив список-часть совпадений шаблона, конечный регистр и рекурсивные вызовы.

     where f acc (DbDate time) = time:acc
           f acc  _            =      acc
   

3. задумайтесь, если было бы лучше изменить направление рекурсия.

   filterDbDate :: [DatabaseItem] -> [UTCTime]
   filterDbDate = foldr f []
     where f (DbDate time) = (time:)
           f _             = id
   

теперь для окончательной очистки, дополнительные очки домового и чтобы разозлить учителей Haskell, сделайте это как можно более общим, не разбивая вещи.

{-# LANGUAGE NoImplicitPrelude, GADTs #-}
import ClassyPrelude

filterDbDate :: ( MonoFoldable items, Element items ~ DatabaseItem
                , Monoid times, SemiSequence times, Element times ~ UTCTime)
             => items -> times
filterDbDate = foldr f mempty
   where f (DbDate time) = cons time
         f _             = id

список-это монада. Таким образом, мы можем использовать функции Monad тип-класс.

utcTimes :: [UTCTime]
utcTimes =
  theDatabase >>=
  \ item ->
    case item of
      DbDate utcTime -> [utcTime]
      _ -> []

на (>>=) функция здесь ключ. По сути, это то же самое, что и "flatMap" на других языках, если это звонит в колокол.

следующее То же самое, что и выше, выраженное в Do-notation:

utcTimes :: [UTCTime]
utcTimes =
  do
    item <- theDatabase
    case item of
      DbDate utcTime -> [utcTime]
      _ -> []

фактически, мы можем даже обобщить это на функцию, которая будет работать для любой монады над UTCTime (ну, MonadPlus, на самом деле):

pickUTCTime :: MonadPlus m => DatabaseItem -> m UTCTime
pickUTCTime item =
  case item of
    DbDate utcTime -> return utcTime
    _ -> mzero

utcTimes :: [UTCTime]
utcTimes =
  theDatabase >>= pickUTCTime

простой способ сделать это следующим образом

filterDbDate :: [DatabaseItem] -> [UTCTime]
filterDbDate db = filterDbDate' [] db
  where filterDbDate' :: [UTCTime] -> [DatabaseItem] -> [UTCTime]
        filterDbDate' rest ((DbDate utcTime):xs) = filterDbDate' (rest ++ [utcTime]) xs
        filterDbDate' rest (_:xs) = filterDbDate' rest xs
        filterDbDate' rest _      = rest

то есть вы передаете другой аргумент, который содержит значения, которые вы хотите сохранить. Если вы посмотрите внимательно, вы увидите, что это именно то, что тип foldl указывает слишком foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b (вы также можете сделать это с помощью foldr, но я оставлю это вам), за исключением того, что он ожидает один элемент за раз. Так давайте перепишем filterDbDate' чтобы сделать это.

filterDbDate2 :: [DatabaseItem] -> [UTCTime]
filterDbDate2 db = foldl filterDbDate'' [] db
   where filterDbDate'' :: [UTCTime] -> DatabaseItem -> [UTCTime]
         filterDbDate'' rest (DbDate utcTime) = (rest ++ [utcTime])
         filterDbDate'' rest _                = rest

это не самая эффективная функция, но, надеюсь, вы будете см. как перевести функции в использование складок. Попробуйте с foldr!