小编And*_*ács的帖子

请使用以下代码:

{-# 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在类型规范中natToInt而不是a Nat,因此拒绝编译.这可以通过某种铸造来解决:

data NatToOpen :: Nat -> *

然后更换n与NatToOpen n在t时的natToInt-s.

问题1:有没有办法*在不使用类型级包装器的情况下指定除任何函数之外的其他类型？

问题2:在我看来,非类函数将很乐意使用任何类型的类型,例如:

foo :: (a :: *) -> …

Agda 2.3.2.1无法看到以下函数终止:

open import Data.Nat
open import Data.List
open import Relation.Nullary

merge : List ? ? List ? ? List ?
merge (x ? xs) (y ? ys) with x ?? y
... | yes p = x ? merge xs (y ? ys)
... | _     = y ? merge (x ? xs) ys 
merge xs ys = xs ++ ys

Agda wiki说,如果递归调用的参数按字典顺序减少,那么终止检查器就可以了.基于此,似乎这个功能也应该通过.那我在这里错过了什么？此外,在以前版本的Agda中它可能还可以吗？我在互联网上看过类似的代码,没有人提到那里的终止问题.

我刚刚发现自己写了这段代码:

import Control.Applicative ((<|>))

x = mA <|> mB <?> c

(<?>) :: Maybe a -> a -> a
Just x  <?> _ = x
Nothing <?> y = y

在哪里mA :: Maybe a,mB :: Maybe a和c :: a,和x :: a.基本上,代码说:选择第一个不是empty默认的替代方案c.你可以把它称为"逆向也许monad",其中的类比<?>将是pure.

同样,我本来可以写的

Just x = mA <|> mB <|> pure c,

但我对无可辩驳的模式感到不舒服.或者,当然,

x = fromMaybe c (mA <|> mB)

因为fromMaybe === flip <?> …

我有这个成员函数测试:

template <typename T> 
struct has_member {
    template <typename U>  static true_type  f(decltype(declval<U>().member()) *);
    template <typename>    static false_type f(...);
    static const bool value =  decltype(f<T>(0))::value;
};

当存在具有给定名称的成员函数时,如果函数具有不带参数的重载,则计算结果为true.对于这样的函数,在STL容器的情况下,除了元素访问函数(正面,背面等)之外,它的工作正常,它总是评估为false.

这是为什么？我有mingw g ++ 4.7.

我可以提取查询的第n个解决方案吗？我知道findall,但我认为(纠正我,如果我错了)它会创建一个完整的解决方案列表,而我更喜欢一种方法,它只需要消耗尽可能多的内存来计算值.

我对 Agda 很陌生，我正在尝试做一个简单的证明“地图的组合就是组合的地图”。

（本课程中的练习）

相关定义：

_=$=_ : {X Y : Set}{f f' : X -> Y}{x x' : X} ->
        f == f' -> x == x' -> f x == f' x'
refl f =$= refl x = refl (f x)

和

data Vec (X : Set) : Nat -> Set where
  []   :                              Vec X zero
  _,-_ : {n : Nat} -> X -> Vec X n -> Vec X (suc n)
infixr 4 _,-_

我想证明： …

如果量词出现在逆变位置，则函数类型具有更高的等级： f :: (forall a. [a] -> b) -> Bool

关于这种类型的统一，类型变量a比 更严格b，因为以下实例化规则适用：

• a可以使用灵活的类型变量实例化，前提是这不允许a超出其范围
• 或使用另一个刚性类型变量
• 但不是非抽象类型，因为不是调用者foo而是foo自己决定是什么a，而b已经由调用者决定

然而，一旦包容开始发挥作用，事情就会变得更加复杂：

{-# LANGUAGE RankNTypes #-}

f :: (forall a. [a] -> [a]) -> Int -- rank-2
f _ = undefined

arg1a :: a -> a
arg1a x = x

arg1b :: [Int] -> [Int]
arg1b x = x

f arg1a -- type checks
f arg1b -- rejected

g :: ((forall …

我有一个二进制数表示形式，以及往返于Nat的一些转换：

open import Data.Nat
open import Data.Nat.Properties
open import Function
open import Relation.Binary.PropositionalEquality hiding (trans; cong; subst; sym)
open import Relation.Binary.HeterogeneousEquality
open import Data.Unit
open import Algebra
module CS = CommutativeSemiring commutativeSemiring 

data Bin : ? ? Set where
  zero  : Bin zero
  2*n   : ? {n} ? Bin n ? Bin (n + n)
  2*n+1 : ? {n} ? Bin n ? Bin (suc (n + n))

suc-lem : ? n ? suc (suc (n + n)) ? suc …

我有以下定义

Inductive subseq : list nat -> list nat -> Prop :=
| empty_subseq : subseq [] []
| add_right : forall y xs ys, subseq xs ys -> subseq xs (y::ys)
| add_both : forall x y xs ys, subseq xs ys -> subseq (x::xs) (y::ys)
.

使用这个,我希望证明以下引理

Lemma del_l_preserves_subseq : forall x xs ys, subseq (x :: xs) ys -> subseq xs ys.

所以,我试着看看subseq (x :: xs) ys做的证明destruct H.

Proof.
  intros. induction H.

3 …

我想将字节的无限流解析为Haskell数据的无限流。每个字节都是从网络读取的，因此将它们包装到IO monad中。

更具体地说，我有一个无限的type流[IO(ByteString)]。另一方面，我有一个纯解析函数parse :: [ByteString] -> [Object]（ObjectHaskell数据类型在哪里）

有没有办法将我的无限monad流插入解析函数中？

例如，是否可以编写类型的函数[IO(ByteString)] -> IO [ByteString]以便我parse在monad中使用我的函数？