我有一个编程语言的AST的数据类型,我想解释一下,但AST大约有10个不同的构造函数。
data Term : Set where
UnitTerm : Term
VarTerm : Var -> Term
...
SeqTerm : Term -> Term -> Term
我正在尝试编写一个函数,它对这种语言的语法树具有可判定的等价性。从理论上讲,这很简单:没有什么太复杂的,它只是存储在AST中的简单数据。
问题是,编写这样一个函数似乎需要大约100个用例:对于每个构造函数,有10个用例。
eqDecide : (x : Term) -> (y
对于自然数nat这样的简单归纳型,很容易证明两个构造函数(0和后继)给出了所有可能的自然数,
Lemma nat_destruct (n : nat) : n = O \/ exists m : nat, n = S m.
Proof.
destruct n. left. reflexivity. right. exists n. reflexivity.
Qed.
然而,我听说平等证明并不是那么简单。只有一个等式构造函数eq_refl,但是Coq不能证明
eq_destruct : forall (A : Type) (x : A) (prEq : x = x), prEq = eq_r
当查看可判定相等类型的结果时(特别是在中),有一些结果(对于A类型)是需要的
forall x y : A, x = y \/ x <> y
而有些人则要求
forall x y : A, {x = y} + {x <> y}
我的印象是,这是最后一个被称为可决定的平等,但我非常不确定的差别是什么。我知道x = y \/ x <> y在Prop和{x = y} + {x <> y}中是在Set中,我可以证明第一个是从第二个,而不是反过来。据我所知,这是因为不允许我从Prop类型的值构造Set类型的值。
有人能分辨出两者的区别吗?是否有某种
我正在努力学习,并希望定义一个替换函数,它使用x和y两个元素,并将给定列表中的x替换为y。
我试着这样定义它:
def replace {α : Type}: α -> α -> list α -> list α
| a b [] := []
| a b (x::xs) := (if a = x then b else x) :: replace a b xs
这给了我以下错误:
error: failed to synthesize type class instance for
α : Type,
replace : α → α → list α → list α,
a
今天在F#中遇到了这样的情况:
let test<'a> (f: 'a -> unit) =
let x = f 123
let y = f "wow"
()
,这会产生编译器错误,因为泛型参数在测试<‘a>的每个调用中必须相同,如下所述:
虽然这是有意义的,但这让我好奇是否还有其他语言实现了这样的东西--也许是一种“参数级泛型”?
作为后续行动,实施这样的方案面临哪些挑战?
,行多态不能用于创建异构容器。
特别是,不能使用行多态性将不同类型的对象放置在同一个容器中。例如,不能使用行多态性创建异构元素列表。
举的例子如下:
type square = < area : float; width : int >;;
type shape = < variant : repr; area : float>
and circle = < variant : repr; area : float; radius : int >
and line = < variant : repr; area : float; length
是否有可能定义一个简单的相等语法概念(类似于GHC可能自动派生为Haskell 98类型的Eq实例),而不显式地证明每个数据构造函数是内射的,或者执行类似的操作,例如定义每个构造函数的回缩和使用cong?
换句话说,是否有可能更直接地利用数据构造函数的内射性,而不是每个构造函数引入一个辅助函数?
下面以自然数为例。
module Eq where
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import R
我刚刚开始学习Haskell。由于Haskell是静态类型的,并且具有多态类型推断,因此标识函数的类型为
id :: a -> a
建议id可以接受任何类型作为其参数并返回自身。当我尝试时,它工作得很好:
a = (id 1, id True)
我只是假设在编译时,第一个id是Num a ::a -> a,第二个id是Bool -> Bool。当我尝试以下代码时,它给出一个错误:
foo f a b = (f a, f b)
result = foo id 1 True
它显示a的类型必须与b的类型相同,因为它与
result = foo id 1 2
但是,id参数的类型可
下面是显示此问题的最小演示代码:
interface A
fun <T1, T2> test() where T2 : T1, T2 : A {}
当我试图编译它时,编译器会抱怨:
错误:(81,25) Kotlin: Type参数如果被另一个类型参数限制,它就不能有任何其他边界
我读过,但只找到以下绑定限制:
类型参数不能将自身指定为自己的绑定,而多个类型参数不能以循环方式相互指定为绑定。
这并不能解释我遇到的限制。
我研究了Kotlin的问题跟踪器,我发现了一个关于这个限制的问题:。然而,这一问题被拒绝的原因如下(2017年5月6日更新: Stanislav
我有以下递归函数:
fun tester (f:'a -> 'b, tl:(string * 'a * 'b) list) =
case tl of
[] => []
| (t, c, e)::rest =>
let val tr = f (c)
in
if tr <> (e)
then ((t), (e), tr)::(tester (f, rest))
else tester (f, rest)
为什么这种类型的单一用法会编译,但将其放入列表会失败呢?
ft1 :: (Foldable t, Num a) => t a -> a
ft1 = (F.foldl (+) 0)
fTest :: [(Foldable t, Num a) => t a -> a ]
fTest = [ F.foldl (+) 0 ]
后者给出了错误:
folding.hs:80:10:
Illegal polymorphic or qualified type:
(Foldable t, Num a) => t a -> a
Pe
我试图在幻影类型中将单元数组(来自dimensional)相乘,并且在函数依赖方面遇到了困难。该问题的简化版本如下:
我有以下类型
data F (a:: [*]) = F String
其中,字符串以外语表示表达式,而幻影类型表示类型的列表。
我可以这样做
x = F "x" :: F '[Double]
y = F "(1,3)" :: F '[Int, Int]
我通过创建一个Nums类来实现像这样的算术运算符,这个类是一个Num列表。
class Nums (a::[*])
instance Nums '[]
instance (
我的模特班:
public class Person
{
[DataType(DataType.Currency)]
public decimal Salary { get; set; }
}
我的控制器
public class PersonController : Controller
{
public ActionResult Create()
{
var person = new Person();
person.Salary = 100; // setting default value
return