我试图在一个也从show库导入的模块中使用Tagged s b类型的东西()。不幸的是,加速库定义了显示实例。
instance Kit acc => Show (acc aenv a) where
在Data.Array.Accelerate.Pretty.hs中。阅读一下,我无法避免导入这个实例,它显然与Data.Tagged Show实例重叠。事实上,泛型加速实例阻止我打印任何类型的*->*->*。
下面是一个简单的示例,演示了这个问题:
{-# LANGUAGE FlexibleContexts, OverlappingInstances, IncoherentIns
请使用以下代码:
{-# LANGUAGE KindSignatures, DataKinds #-}
data Nat = O | S Nat
class NatToInt (n :: Nat) where
natToInt :: n -> Int
instance NatToInt O where
natToInt _ = 0
instance (NatToInt n) => NatToInt (S n) where
natToInt _ = 1 + natToInt (undefined :: n)
GHC通知我们,它希望在OpenKind的类
继续我的一系列关于类型级算术的问题,我偶然发现了另一个问题:多态递归函数的返回类型。
代码如下:
module Nat : sig
type z = Z
type 'n s = S of 'n
type ('n) nat =
Zero : (z) nat
| Succ : ('n) nat -> ('n s) nat
val of_int : int -> 'n nat
end = struct
type z = Z
type 'n s = S of 'n
我试图在向量上定义rev函数,它的大小被嵌入其中,我不知道如何在它上定义rev函数。
以下是我的类型定义:
Inductive vect {X : Type} : nat -> Type -> Type
:= Nil : vect 0 X
| Cons : forall n, X -> vect n X -> vect (S n) X
.
我在它上定义了一些有用的功能:
Fixpoint app {X : Type} {n m : nat} (v1 : vect n X) (v2 : vect m X)
: vect (n + m) X :=
matc
我试图在Ocaml的类型级别上实现Peano算法,但遇到了一个问题: module Nat = struct
type zero = Z
type 'a succ = S
type 'a nat = Zero : zero nat | Succ : 'a nat -> 'a succ nat
end 现在,如果我想实现add,关于这个操作的两个公理是: ? ? 我试过了 let rec add : type n1 n2. n1 nat -> n2 nat -> 'a nat =
fun a b -&
我希望一些Haskell专家能帮助澄清一些事情。
可以用通常的方式定义Nat (通过@dorchard )吗?
data S n = Succ n
data Z = Zero
class Nat n
instance Nat Z
instance Nat n => Nat (S n)
(或其某些变体),然后定义LessThan关系,使得对于所有n和m
LessThan Z (S Z)
LessThan n m => LessThan n (S m)
LessThan n m => LessThan (S n) (S m)
然后编写如下类型的函数:
foo :
作为一种传递时间,我试图实现我在大学里学的一门课程(涉及Lambda和各种编程概念)中提出的各种问题。因此,我试图在OCaml中实现丘奇数字和相关运算符(也是在OCaml中的一个练习)。
这是目前为止的代码:
let church_to_int n =
n (fun x -> x + 1) 0;;
let succ n s z =
s (n s z)
let zero = fun s z -> z
let int_to_church i =
let rec compounder i cont =
match i with
我们已经尝试了一些AGDA,基本上是通过播放Lean in AGDA中的自然数的一部分。然而,对于不平等,我们遇到了一个错误,这个错误不存在于这个问题的精益解决方案中。
代码如下:
module minimalExample where
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
open import Agda.Builtin.Sigma
-- x ≤ x + 1
data _leq_ {x : Nat} {y : Nat} : Nat -> Nat -> Set where
leqpr
据我所知,模板值需要在编译时知道。所以我写了一个小例子,看看我得到了它,但很明显我没有。所以我得到了这个:
`defValue' cannot appear in a constant-
expression
谁能告诉我这个问题是什么,以及如何解决它?
#include <iostream>
template <class T,T defaultVal, int dim=255>
class Vec
{
T _vec[dim];
int _dim;
public:
Vec () : _dim(dim)
{
在下面的简单定理中,证明是直接以证明函数的形式给出的。我想了解这两个术语(括号以反映我的概念)是如何组合成一个返回预期类型的最终证明函数的。
Lemma simple : forall i, i <= S i.
Proof
fun i => (le_S i i) (le_n i).
似乎(le_S i i)构造函数项返回了一个函数,该函数将接受(le_n i)作为参数。有人能在这里解释一下证明函数组合是如何工作的吗?
定义如下:
Inductive eq (A : Type) (x : A) : A → Prop := eq refl : (eq x) x
Parameter a b : A.
当我考虑它的一个实例eq a b时,我阅读了类型为A -> Prop的(eq a)。
那么,我的问题是,(eq a) b如何能够确定a和b对应于同一个对象这一事实?
对我来说,奇怪的是,我们没有关于(eq a)实际做什么的信息。
这是对的跟进。多亏了Kwartz,我现在有了一个命题的状态,如果b除以a,那么对于任何整数c,b除a*c,即:
alsoDividesMultiples : (a, b, c : Integer) ->
DivisibleBy a b ->
DivisibleBy (a * c) b
现在,我们的目标是证明这一说法。我意识到,我不知道如何操作依赖对。我尝试了一个更简单的问题,它表明每个数字都可以被1整除。在对它进行了可耻的思考之后,我认为我已经想出了一个解决方案:
-- All number
证明通用量词从窄到大范围。有两个定理。`
lemma "(∀l k. l< i ∧ k<j⟶ (f l k))
⟹ (∀l. l< i⟶ (f l j))
⟹ (∀l k. l<i ∧ k≤j⟶ (f l k))"
oops
lemma "(∀l k. l< i ∧ k<j⟶ (f l k)) ⟹
(∀l. l< i⟶ (f l j)) ⟹ (∀k. k<j⟶ (f i k)) ⟹ f i j
⟹ (∀l k. l≤ i ∧ k≤j⟶ (f l k
我有以下源码:
{-# LANGUAGE
FlexibleContexts,
MultiParamTypeClasses,
FunctionalDependencies
#-}
class Digit d
data Zero
data One
data Two
data Three
data Four
data Five
data Six
instance Digit Zero
instance Digit One
instance Digit Two
instance Digit Three
instance Digit Four
instanc
我最近在vinyl上读到,它使用奇怪的“种类列表”类型。在阅读了一些关于种类和乙烯基的文章之后,我对它们有了一些直观的理解,并且我已经能够将它们组合在一起
{-# LANGUAGE DataKinds,
TypeOperators,
FlexibleInstances,
FlexibleContexts,
KindSignatures,
GADTs #-}
module Main where
-- from the data kinds page, with HC
我有一个矩阵表示
data ListN (dim :: Nat) a where
Nil :: ListN Zero a
Cons :: a -> ListN n a -> ListN (Succ n) a
infixr 5 `Cons`
data Tensor (dims :: [Nat]) a where
Dense :: (Product dims ~ n) => ListN n a -> Tensor dims a
Sparse :: Tensor n a
当您使用所有元素的乘积时,Product确保dims与n相等。现在我想
我试图将特定西格玛类型的强制写入二进制关系。强制在使用强制项作为函数参数时有效,但当使用相同的术语作为函数时则不起作用。
以下是代码:
Definition relation A := A -> A -> Prop.
Definition is_serial {A} (R: relation A) := forall x, exists y, R x y.
Definition serial state := {R: relation state | is_serial R}.
Definition serial_to_relation A (s: serial A) : r
( 1)我认为在不进行模式匹配的情况下,可以使用归纳类型。(仅使用_rec、_rect、_ind )。它是不透明的,复杂的,但可能的。( 2)是否有可能使用具有模式匹配的共进类型?
从共归纳型到同归纳型构造子域的结合都存在着一个函数。Coq是否显式地生成它?如果是,如何重写“hd”?
Section stream.
Variable A : Type.
CoInductive stream : Type :=
| Cons : A -> stream -> stream.
End stream.
Definition hd A (s : stream A) : A
作为一个玩具项目,我想了解如何建模的数学小组在哈斯克尔在总体上。
首先,我们从观察待定义的Group只是一个带有反转的Monoid开始。
class (Monoid m) => Group m where
minvert :: m -> m
接下来,我们首先将自己限制在循环群上,然后从定义12阶循环群开始。
data Cyclic12 = Cyclic12 Int deriving (Show, Eq)
最后,我们实例化了Cyclic12的两个类。
instance Monoid Cyclic12 where
mempty = Cyclic12 0
mapp
我有一个包含两个datetime列的大型数据集,当我试图清理它时,我创建了一个应用于这两列的每个单元格的函数:
#dropoff_datetime
def date_time_dropoff(cell):
if pd.isnull(cell) == True:
return('Missing Date Time dropoff')
elif type(cell) == datetime.datetime:
return ('Clean Date Time dropoff')
elif type(cell)
假设我有一个数据类型
data Interval :: Nat -> Nat -> * where
Go :: Interval m n -> Interval m (S n)
Empty :: SNat n -> Interval n n
这些是半(右)开区间。Nat是标准的归纳自然数,SNat是相应的单例。
现在我想获得一个给定间隔长度的单例Nat:
intervalLength :: Interval n (Plus len n) -> SNat len
intervalLength Empty = Z
intervalLength (Go i) =