haskell - 如何生成多态 "unit scalar"以便与 Data.VectorSpace 一起使用

Question

所以我正在使用 Data.VectorSpace我正在尝试扩展 force-layout 。

现在我想生成一个多态的“1”标量。也就是说，如果标量与向量相乘，则无论该向量的类型(参数)如何，都会产生相同的向量。是否可以？有有效的解决方法吗？

这是一个更具体的代码示例(它继续我使用过的代码 here ):

data Particle v = Particle { _pos   :: Point v
                           , _vel   :: v
                           , _force :: v
                           , _mass  :: Scalar v
                           }
-- .. standalone Show and Eq omitted 
initParticle :: AdditiveGroup v => Point v -> Particle v
initParticle p = Particle p zeroV zeroV unitScalar

unitScalar = undefined

-- Should always be true:
testInit :: Point (Double,Double) -> Bool
testInit p = ((_mass (initParticle p)) == 1::Double)

如何定义上面的“unitScalar”？

Answer 1

您定义的上下文是不可能的；既然您说 v 是一个 AdditiveGroup，那么它就只能是这样，因此不能将其他属性归因于 v。

您当然可以定义其他类来定义单位值:

{-# LANGUAGE FlexibleContexts #-}
module Main (main) where

import Data.VectorSpace

如果我们想要数学上严谨，我们可能会这样做；然而，这在 Haskell 中会产生不良后果，因为一种类型只能定义一个 Monoid，所以下面的解决方案可能更好。

-- BAD SOLUTION! (Arguably)
import Data.Monoid

instance Monoid Double where
  mempty = 1
  mappend = (*)

相反，我们定义了一个通用的MultiplicativeGroup，它也是乘法的幺半群。

class MultiplicativeGroup a where
  unit :: a
  multiply :: a -> a -> a
  reciprocal :: a -> a

instance MultiplicativeGroup Double where
  unit = 1
  multiply = (*)
  reciprocal = (1 /)

现在我们可以实现工作示例:

data Particle v =
  Particle -- Removed Point for this example since I don't have its definition
  { _vel :: v
  , _force :: v
  , _mass :: Scalar v
  }

-- We need VectorSpace because there needs to be a Scalar type associated with v
-- Also, this context requires you to use FlexibleContexts, which should be
-- harmless
initParticle :: (VectorSpace v, MultiplicativeGroup (Scalar v))
             => Particle v
initParticle = Particle zeroV zeroV unit

-- Works as expected:
main :: IO ()
main = print $ ((_mass (initParticle :: Particle Double)) == (1::Double))

顺便说一句，您当然可以将 MultiplicativeGroup 替换为 Num，并将 unit 替换为 1，但这将为您提供比您想要的更多的功能。

PS。您应该看看优秀的 algebra package ，它会更严格地为您执行此类操作。在其之上实现力求解器并不会太难。