20

有这些进口：

> import Control.Lens
Control.Lens> import qualified Data.Map as Map

以及定义如下的映射值：

Control.Lens Map> let m = Map.fromList [('a', 1), ('c', 3), ('b', 2)]

我可以像这样一个一个地得到它的元素：

Control.Lens Map> view (at 'b') m
Just 2

我想知道的是，有一组这样的键：

Control.Lens Map> import qualified Data.Set as Set
Control.Lens Map Set> let keys = Set.fromList ['d', 'c', 'b']

如何构造这样的吸气剂（我猜），使用它我将能够获得一组（或列表）匹配元素：

Control.Lens Map Set> view (**???**) m
[3, 2]

请注意，结果仅包含 2 个元素，因为 key 没有匹配项'd'。

4

2 回答 2

22

如果您只想在多个字段上使用 getter，则以下方法将起作用。

首先，您需要将镜头中的 Accessor 设为 Monoid 的实例（该实例位于在 HEAD 中，但尚未发布 已在 中定义lens >= 4，因此您只需要在使用旧版本的库时定义实例）。

import Data.Monoid
import Control.Lens

instance Monoid r => Monoid (Accessor r a) where
  mempty = Accessor mempty
  mappend (Accessor a) (Accessor b) = Accessor $ a <> b

然后，您可以使用该实例将多个镜头/遍历组合成一个遍历：

>>> import qualified Data.Set as S
>>> import qualified Data.Map as M
>>> import Data.Foldable (foldMap)
>>> import Control.Lens
>>> let m = M.fromList [('a',1), ('b',2), ('c',3)]
>>> let k = S.fromList ['b','c','e']
>>> m ^.. foldMap at k
[Just 2,Just 3,Nothing]
>>> m ^.. foldMap ix k
[2,3]

foldMap 为 Accessor 使用 Monoid 实例，为函数使用 Monoid 实例。

于 2013-06-17T20:29:24.687 回答
5

我认为这是解决方案：

import Control.Applicative
import Control.Lens
import qualified Data.Map as M
import Data.Monoid hiding ((<>))

empty :: (Applicative f, Monoid a) => (b -> f b) -> (a -> f a)
empty _ _ = pure mempty

(<>)
    :: (Applicative f, Monoid a)
    => ((b -> f b) -> (a -> f a))
    -> ((b -> f b) -> (a -> f a))
    -> ((b -> f b) -> (a -> f a))
(l1 <> l2) f a = mappend <$> (l1 f a) <*> (l2 f a)

例子：

>>> toListOf (at "A" <> at "B" <> at "C") (M.fromList [("A", 1), ("B", 2)])
[Just 1, Just 2, Nothing]

这个想法是 aTraversal是一个幺半群。正确的解决方案需要对Traversal.

Monoid编辑：这是所有新类型恶作剧的正确实例：

import Control.Applicative
import Control.Lens
import qualified Data.Map as M
import Data.Monoid
import Data.Foldable

newtype Combinable f a b = Combinable { useAll :: (b -> f b) -> (a -> f a) }

instance (Applicative f, Monoid a) => Monoid (Combinable f a b) where
    mempty = Combinable (\_ _ -> pure mempty)
    mappend (Combinable l1) (Combinable l2)
        = Combinable (\f a -> mappend <$> (l1 f a) <*> (l2 f a))

myMap :: M.Map String Int
myMap = M.fromList [("A", 1), ("B", 2)]

myLens :: Traversal' (M.Map String Int) (Maybe Int)
myLens = useAll $ foldMap (Combinable . at) ["A", "B", "C"]

例子：

>>> toListOf myLens myMap
[Just 1,Just 2, Nothing]
于 2013-06-17T19:36:25.030 回答