Haskell语言学习笔记（31）ListT

Control.Monad.Trans.List

标准库中的 ListT 的实现由于有 bug，已经被废弃。

list-t 模块

这里使用 list-t 模块中的 ListT。

list-t 模块需要安装

ListT done right

$ cabal install list-t

list-t-1.0.0.1

Prelude> :m +ListT

Prelude ListT>

ListT Monad转换器

newtype ListT m a = ListT (m (Maybe (a, ListT m a)))

-- * Execution in the inner monad

-------------------------

-- Execute in the inner monad,

-- getting the head and the tail.

-- Returns nothing if it's empty.

uncons :: ListT m a -> m (Maybe (a, ListT m a))

-- Execute, getting the head. Returns nothing if it's empty.

head :: Monad m => ListT m a -> m (Maybe a)

-- Execute, getting the tail. Returns nothing if it's empty.

tail :: Monad m => ListT m a -> m (Maybe (ListT m a))

-- Execute, checking whether it's empty.

null :: Monad m => ListT m a -> m Bool

-- Execute, applying a left fold.

fold :: Monad m => (r -> a -> m r) -> r -> ListT m a -> m r

-- A version of 'fold', which allows early termination.

foldMaybe :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r

-- Execute, folding to a list.

toList :: Monad m => ListT m a -> m [a]

-- Execute, folding to a list in the reverse order.

-- Performs more efficiently than 'toList'.

toReverseList :: Monad m => ListT m a -> m [a]

-- Execute, traversing the stream with a side effect in the inner monad.

traverse_ :: Monad m => (a -> m ()) -> ListT m a -> m ()

-- Execute, consuming a list of the specified length and returning the remainder stream.

splitAt :: Monad m => Int -> ListT m a -> m ([a], ListT m a)

-- * Construction

-------------------------

-- Prepend an element.

cons :: Monad m => a -> ListT m a -> ListT m a

-- Construct from any foldable.

fromFoldable :: (Monad m, Foldable f) => f a -> ListT m a

-- Construct by unfolding a pure data structure.

unfold :: Monad m => (b -> Maybe (a, b)) -> b -> ListT m a

-- Construct by unfolding a monadic data structure

-- This is the most memory-efficient way to construct ListT where

-- the length depends on the inner monad.

unfoldM :: Monad m => (b -> m (Maybe (a, b))) -> b -> ListT m a

-- Produce an infinite stream.

repeat :: Monad m => a -> ListT m a

-- * Transformation

-------------------------

-- A transformation,

-- which traverses the stream with an action in the inner monad.

traverse :: Monad m => (a -> m b) -> ListT m a -> ListT m b

-- A transformation,

-- reproducing the behaviour of @Data.List.'Data.List.take'@.

take :: Monad m => Int -> ListT m a -> ListT m a

-- A transformation,

-- reproducing the behaviour of @Data.List.'Data.List.drop'@.

drop :: Monad m => Int -> ListT m a -> ListT m a

-- A transformation,

-- which slices a list into chunks of the specified length.

slice :: Monad m => Int -> ListT m a -> ListT m [a]

Prelude ListT> toList (return 1 :: ListT IO Int)

[1]

Prelude ListT> toList (return 1 :: ListT Maybe Int)

Just [1]

Prelude ListT> toList (fromFoldable [1,2,3] :: ListT Maybe Int)

Just [1,2,3]

Prelude ListT Control.Monad.Trans> toList $ (return 1 :: ListT IO Int) >>= lift . print >> return (1,2)

1

[(1,2)]

应用实例

import Control.Monad

import Control.Monad.Trans

import ListT

myTest :: Int -> ListT IO (Int, Int)

myTest n = do

    let squares = fromFoldable . takeWhile (<=n) $ map (^(2::Int)) [0..]

    x <- squares

    y <- squares

    lift $ print (x,y)

    guard $ x + y == n

    lift $ putStrLn "Sum of squares."

    return (x,y)

main = toList $ myTest 5

(0,0)

(0,1)

(0,4)

(1,0)

(1,1)

(1,4)

Sum of squares.

(4,0)

(4,1)

Sum of squares.

(4,4)

[(1,4),(4,1)]