小编Sam*_*ire的帖子

我正在尝试运行以下程序,该程序计算度数达到d的多项式的根,系数仅为+1或-1,然后将其存储到文件中.

d = 20; n = 18000; 
f[z_, i_] := Sum[(2 Mod[Floor[(i - 1)/2^k], 2] - 1) z^(d - k), {k, 0, d}];

这里f [z,i]给出z中的多项式,其中加号或减号以二进制计数.说d = 2,我们会的

f [z,1] = -z ² - z - 1
f [z,2] = -z ² - z + 1
f [z,3] = -z ² + z - 1
f [z,4] = - z ² + z + 1

DistributeDefinitions[d, n, f]

ParallelDo[ 
            Do[ 
                     root = N[Root[f[z, i], j]];
                     {a, b} = Round[n ({Re[root], Im[root]}/1.5 …

我想让 GHC 推断出超过 GADT 模式匹配的约束。例如，假设我有两个表达式，每个表达式都有一个推断约束：

f :: _ => a
g :: _ => a

（在我的用例中，这些推断的约束可能很大，因此手动写出它们是不可行的。）

假设我想使用f或g取决于布尔条件。天真地，我可以按如下方式进行：

h1 :: _ => Bool -> a
h1 c = if c then f else g

假设我将推断约束称为 forf ct_f和 for g ct_g，那么 GHC 将推断出约束( ct_f, ct_g )为h1。

问题是这是一个过于严格的类型：如果布尔值是TrueI don't need ct_g，反之如果是FalseI don't need ct_f。所以我尝试使用标准机制来启用这种依赖约束：

data SBool (c :: Bool) where
  SFalse :: SBool False
  STrue  :: …

我可以定义一个玩具状态机(具有简单的输入),如下所示:

--------------------------------------------
-- module State where

data State = A | B Int

--------------------------------------------
-- module A where
-- import State

transitionA :: State
transitionA = B 10

--------------------------------------------
-- module B where
-- import State

transitionB :: Int -> State
transitionB i
  | i < 0     = A
  | otherwise = B (i-1)

--------------------------------------------
-- module StateMachine where
-- import State
-- import A
-- import B

transition :: State -> State
transition A     = transitionA
transition (B i) …

基本思想是我有一系列函数可以处理来自特定类的任何类型,但在运行时,程序应该读取配置文件并提取类中其中一种类型的元素.

例如,我有一个'Coefficient'类,它的各种实例,以及与该类类型多态的各种类型的函数; 在运行时,将确定并传递该类的一种特定类型.

我不确定如何妥善解决这个问题; 我尝试制作'复合'类型,做类似的事情:

data CompoundCoeff = CompoundInt Int | CompoundDouble Double | ...

其中Int,Double,...是"Coefficient"类的实例.
然而,它开始成为一项重大努力,以适应代码中涉及的所有函数来使用这些复合类型(并且它也不是一个很好的解决方案,真的).如果所有函数都具有相同的简单类型,那就没关系了

Coefficient a => a -> (stuff not involving a anymore)

但遗憾的是并非如此.

我遇到的另一个问题是,我正在使用类型系列,并且有类似的东西

class (Monoid (ColourData c), Coordinate (InputData c)) => ColourScheme c where
    type ColourData c :: *
    type InputData c  :: *
    colouriseData     :: c -> (ColourData c) -> AlphaColour Double
    processInput      :: c -> InputData c -> ColourData c

如果我必须使用某种复合ColourData数据类型(如前一个),那么这不会干净利落; 特别是我不能再保证数据流给出一致的类型(而不仅仅是复合类型的不同'子类型),并且如果我组成了一个,那么(除其他外)必须构成一个虚假的Monoid实例复合ColourData类型.

我也研究过Data.Dynamic,但我再也看不出它如何正确解决问题; 似乎出现了完全相同的问题(好吧,甚至稍差,因为我理解只有一个'通用'动态类型).

问题:如何实现从属于特定类的动态数据类型,而不必重写涉及这些数据类型的所有函数？如果我不必牺牲任何类型的安全性,那将是最好的,但我不是太乐观.
程序应该在运行时读取配置文件,并且应用相关类的所有必需函数(多态).

以下类型系列

type family ListVariadic (as :: [Type]) (b :: Type) = (f :: Type) where  
  ListVariadic (a ': as) b = a -> ListVariadic as b
  ListVariadic '[]       b = b

显然不是单射的,例如ListVariadic '[] (a -> a) ~ ListVariadic '[a] a.
然而,使用injectivity帮助类型推断是非常方便的,我不打算使用ListVariadic其第二个参数作为函数类型.
我提出了两个解决方法,两者都非常令人不满意:

选项1:传递与ListVariadic(通过类型类)相反的左侧类型族.

type family Arguments (f :: Type) :: [Type] where
  Arguments (a -> b) = a ': Arguments b
  Arguments b        = '[]
type family Return (f :: Type) :: Type where
  Return …

我有一个 AST，它描述了纯计算和不纯计算，不纯计算在类型级别跟踪状态。我正在使用 HOAS 表示；AST GADT的相关构造函数如下：

data AST a where
  Lam :: (AST a -> AST b) -> AST (a -> b)
  (:$) :: AST (a -> b) -> AST a -> AST b

  Return :: AST (a -> (a := i) i)
  Bind :: AST ( (a := j) i -> ( a -> q j ) -> q i )

  -- then some stateful operations
  -- for instance if the indexed state keeps track of a CD player tray: …