在AGDA中使用依賴類型進行咖喱

Question

我以為您可以在Agda中使用任何功能。 這樣您就可以始終交換輸入的順序。

一個定理表示甚至可以編譯：

curry : {A : Set} -> {B : Set} -> {C : Set} -> ( A -> B -> C) -> (B -> A -> C)
curry f b a = f a b

但是，Agda具有依賴類型，例如

curry' : {A : Set} -> {B : ( A -> Set ) } -> { C : ( A -> Set ) } -> ( (a : A) -> B a -> C a) -> ( B a -> (a : A) -> C a) 

甚至不編譯。

因為(a : A) -> B a -> C a與A -> B -> C一樣有效，所以我開始認為您一般不能咖喱。 盡管在a : A之前傳遞函數B a似乎沒有什么特別可怕a : A 。

總的來說，是否有一些技巧可以進行欺騙？ 還是在阿格達不可能？

Answer 1

您所描述的不是輕率的。 這是一個簡單的參數交換。

這是多條彎彎的樣子：

open import Data.Product
  hiding (curry)

-- non-dependent version
curry′ : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} →
         (A × B → C) → (A → B → C)
curry′ f a b = f (a , b)

-- dependent version
curry : ∀ {a b c} {A : Set a} {B : A → Set b} {C : Set c} →
        (Σ A B → C) → ((a : A) → B a → C)
curry f a b = f (a , b)

C也可以取決於A和B ； 完全依賴的版本可以在Data.Product找到。

無論如何，這還不重要。 您想要的操作（即依賴於swap ）不能在Agda中實現，也不能在大多數其他依賴類型理論中實現。

Answer 2

您可以執行以下操作：

open import Level
open import Function hiding (id)
open import Data.Nat
open import Data.Vec

data Id {α : Level} {A : Set α} : A -> Set α where
  id : (x : A) -> Id x

flip-id : {α β γ : Level} {A : Set α} {B : A -> Set β} {C : (x : A) -> B x -> Set γ} {x : A}
       -> ((x : A) -> (y : B x) -> C x y) -> (y : B x) -> Id x -> C x y
flip-id f y (id x) = f x y

test-func : (n : ℕ) -> Vec ℕ n -> ℕ
test-func n _ = n

{-error : ℕ
error = flip test-func (0 ∷ 0 ∷ []) 2-}

ok : ℕ
ok = flip-id test-func (0 ∷ 0 ∷ []) (id 2)

還有對稱函數：

id-flip : {α β γ : Level} {A : Set α} {B : A -> Set β} {C : (x : A) -> B x -> Set γ}
      -> ({x : A} -> (y : B x) -> Id x -> C x y) -> (x : A) -> (y : B x) -> C x y
id-flip f x y = f y (id x)

Answer 3

如果在兩個函數中都使用相同的a : A則可以定義它，即

foo : {A : Set} {B C : A → Set}(a : A) →
      (A → B a → C a) →
      (B a → A → C a)
foo a f Ba _ = f a Ba