haskell - 镜头库 : Is there an optic for this?

Question

我有一系列固定长度向量:

data family Vector (n :: Nat) a
data instance Vector 2 a = Vector2 a a
data instance Vector 3 a = Vector3 a a a
-- and so on

以及两个函数来获取向量切片并将其设置为列表:

getSlice :: Proxy i -> Proxy l -> Vector n a -> [a]
setSlice :: Proxy i -> Proxy l -> Vector n a -> [a] -> Maybe (Vector n a)
-- ^ setSlice is partial because list parameter may not have enough elements.

我想我可以将这些 getter 和 setter 组合成这样的镜头:

slice :: Proxy i -> Proxy l -> Lens (Vector n a) (Maybe (Vector n a)) [a] [a]
slice i l = lens (getSlice i l) (setSlice i l)

但这违反了镜头定律( http://hackage.haskell.org/package/lens-4.15.2/docs/Control-Lens-Lens.html#t:Lens

所以我想知道是否有这样的结构？

Answer 1

我不认为你能得到你正在寻找的东西，但你可以得到一些相关的东西。这个答案将采取一个相当迂回的路径来达到我认为你最可能想要的；这是我的思想接近结论的路径，我认为这证明了我最终的结论。总的主题是，您可以将几种不同的合法光学应用于您的情况，并且可以以不同的方式发挥作用。

首先，让我们看看您可以获得哪种镜头。。 i 和 l Nat 在 Vector n 中标记出一个“窗口”。您还没有表明如果窗口不完全位于向量内您想要发生什么。一种选择是简单地要求它适合。另一种选择是将窗口裁剪为向量的大小:

-- Minimum
type Min m n = Min' (m <=? n) m n
type family Min' m_le_n (m :: Nat) (n :: Nat) where
  Min' 'True m _ = m
  Min' 'False _ n = n

-- Saturated subtraction
type SatMinus m n = SatMinus' (n <=? m) m n
type family SatMinus' n_le_m m n where
  SatMinus' 'True m n = m - n
  SatMinus' 'False _ _ = 0

-- Window clipping
type ClippedLength i l n = Min l (SatMinus n i)

现在你当然可以定义(对于每个n，使用一个类；我将在帖子的其余部分忽略这个细节)一个合法的

vlCut :: (KnownNat i, KnownNat l)
   => Proxy i -> Proxy l
   -> Lens' (Vector n a) (Vector (ClippedLength i l n) a)

或者，如果您只想允许适合的窗口，

vl :: (KnownNat i, KnownNat j, i + l <= n)
   => Proxy i -> Proxy l
   -> Lens' (Vector n a) (Vector l a)

我们现在可以通过这些镜头之一进行工作，而不会失去任何通用性(尽管我们会失去效率；稍后会详细讨论如何解决这个问题)。这样做意味着我们可以完全忽略窗口之外的所有内容，因此我们无需再提及代理。如果我们有从 Vector w a 到 t 的任何光学器件，那么我们可以生成从 Vector n a 到 t 的光学器件.

将切片操作函数减少到窗口，您将得到

getSliceW :: Vector w a -> [a]
setSliceWpartial :: Vector w a -> [a] -> Maybe (Vector w a)

正如您所发现的，这些并不能构成镜头。但如果您进一步减少一点，请将 setSliceWpartial 替换为

fromList :: [a] -> Maybe (Vector w a)

你可以制作一个合法的棱镜:

slicep :: Prism' [a] (Vector w a)

给定一个Vector w a，您总是可以生成一个[a]，但有时另一种方式是可能的。您当然可以将其与 vl 或 vlCut 一起使用(如果这是您需要解决的问题，那么这是一个很好的解决方案)，但您不能compose 与它们一起使用，因为类型不匹配。您可以使用 re 反转棱镜，但这最终只会给您一个 Getter。

<小时/>

由于您的类型似乎不太适合，让我们尝试更改它们:

getSliceW :: Vector w a -> [a]
setSliceW :: Vector w a -> [a] -> Vector w a

现在我们用鲈鱼做饭了!它具有Lens' (Vector w a) [a]的类型，尽管它实际上不是一个合法的镜头。然而，这是一个非常好的线索。 Control.Lens.Traversal 优惠

partsOf' :: ATraversal s t a a -> Lens s t [a] [a]

在这种情况下，您可以将其读作

partsOf' :: Traversal' (Vector w a) a -> Lens' (Vector w a) [a]

所以(透过 window )，我们真正想要的是

traverseVMono :: Traversal' (Vector w a) a

当然，这可以立即概括；只需为 Vector n 编写一个 Traversable 实例并使用其traverse即可。

<小时/>

我之前提到过，通过窗口 Lens 工作效率很低。那么你该如何处理呢？好吧，不用费心去 build window 了!你想要“从头到尾”的只是遍历窗口。所以这样做:

traverseWindow :: (KnownNat i, KnownNat l, Applicative f)
               -- optionally require i + l <= n
               => proxy1 i
               -> proxy2 l
               -> (a -> f a)
               -> Vector n a
               -> f (Vector n a)

如果您愿意，您可以恢复原始的部分setSlice；您只需将 traverseWindow 与 MaybeT (State [a]) 结合使用:

foldMapWindow :: (KnownNat i, KnownNat l, Monoid m)
  => proxy1 i
  -> proxy2 l
  -> (a -> m)
  -> Vector n a
  -> m
foldMapWindow p1 p2 f = getConst . traverseWindow p1 p2 (Const . f)

windowToList :: (KnownNat i, KnownNat l)
  => proxy1 i
  -> proxy2 l
  -> Vector n a
  -> [a]
windowToList p1 p2 = foldMapWindow p1 p2 (:[])

setSlice :: (KnownNat i, KnownNat l)
         => proxy1 i -> proxy2 l
         -> Vector n a -> [a] -> Maybe (Vector n a)
setSlice p1 p2 v xs = flip evalState (windowToList p1 p2 v) . runMaybeT $ flip (traverseWindow p1 p2) v $ \_ -> do
  y : ys <- get
  put ys
  pure y