[英]Map with Strings as Keys in Agda?
我在弄清楚如何正確地在Agda中使用String鍵制作Map時遇到了一些麻煩。 我有以下幾點:
import Data.AVL.IndexedMap
Var = String
data Type where -- ...
alwaysType : Var -> Set
alwaysType _ = Type
open Data.AVL.IndexedMap alwaysType (StrictTotalOrder.isStrictTotalOrder Data.String.strictTotalOrder)
這給出了錯誤:
String != Σ String _Key_90 of type Set
when checking that the expression
StrictTotalOrder.isStrictTotalOrder strictTotalOrder has type
Relation.Binary.IsStrictTotalOrder .Agda.Builtin.Equality._≡_
__<__91
打開“地圖”模塊的正確方法是什么?
請注意,標准庫的Data.AVL
已更新,可以接受不基於命題相等性的嚴格總訂單。
這些天,它很簡單:
open import Data.String.Properties
open import Data.AVL strictTotalOrder
Data.AVL.IndexedMap
模塊用於(有限)映射,其中鍵和值有一系列類型,並且與給定鍵關聯的值與該值共享索引。
這不是您想要的,因為您希望所有鍵都是String
。 因此,只需使用Data.AVL
(即具有未索引鍵的版本):
open import Data.String using (String)
open import Function using (const)
Key = String
postulate
Value : Set
open import Relation.Binary using (StrictTotalOrder)
open import Data.AVL (const Value) (StrictTotalOrder.isStrictTotalOrder Data.String.strictTotalOrder)
不幸的是,這仍然沒有類型檢查:
.Relation.Binary.List.Pointwise.Rel
(StrictTotalOrder._≈_ .Data.Char.strictTotalOrder)
(Data.String.toList x) (Data.String.toList x₁)
!= x .Agda.Builtin.Equality.≡ x₁ of type Set
when checking that the expression
StrictTotalOrder.isStrictTotalOrder Data.String.strictTotalOrder
has type IsStrictTotalOrder .Agda.Builtin.Equality._≡_ __<__10
這是因為Data.String.strictTotalOrder
使用逐點相等(在組成String
的Char
的ℕ
值列表中),並且Data.AVL
需要命題相等。 因此,完全相同的示例將與ℕ
鍵一起工作:
open import Data.Nat using (ℕ)
open import Function using (const)
Key = ℕ
postulate
Value : Set
import Data.Nat.Properties
open import Relation.Binary using (StrictTotalOrder)
open import Data.AVL (const Value) (StrictTotalOrder.isStrictTotalOrder Data.Nat.Properties.strictTotalOrder)
因此,下一步需要將StrictTotalOrder.isStrictTotalOrder Data.String.strictTotalOrder
轉換為IsStrictTotalOrder (_≡_ {A = String}) _
。 我現在將其留給其他人,但是如果有時間,如果您無法使它正常工作,並且也沒有其他人來找,我很樂意稍后進行調查。
編輯添加 :這是一種(可能非常復雜的)將StrictTotalOrder
for String
s從標准庫轉換為使用命題相等的方法:
open import Function using (const; _∘_; _on_)
open import Relation.Binary
open import Data.String
using (String; toList∘fromList; fromList∘toList)
renaming (toList to stringToList; fromList to stringFromList)
open import Relation.Binary.List.Pointwise as Pointwise
open import Relation.Binary.PropositionalEquality as P hiding (trans)
open import Data.Char.Base renaming (toNat to charToNat)
STO : StrictTotalOrder _ _ _
STO = record
{ Carrier = String
; _≈_ = _≡_
; _<_ = _<_
; isStrictTotalOrder = record
{ isEquivalence = P.isEquivalence
; trans = λ {x} {y} {z} → trans {x} {y} {z}
; compare = compare
}
}
where
open StrictTotalOrder Data.String.strictTotalOrder
renaming (isEquivalence to string-isEquivalence; compare to string-compare)
-- It feels like this should be defined somewhere in the
-- standard library, but I can't find it...
primCharToNat-inj : ∀ {x y} → primCharToNat x ≡ primCharToNat y → x ≡ y
primCharToNat-inj _ = trustMe
where
open import Relation.Binary.PropositionalEquality.TrustMe
open import Data.List
lem : ∀ {xs ys} → Pointwise.Rel (_≡_ on primCharToNat) xs ys → xs ≡ ys
lem [] = P.refl
lem {x ∷ xs} {y ∷ ys} (x∼y ∷ p) with primCharToNat-inj {x} {y} x∼y
lem {x ∷ xs} {_ ∷ ys} (x∼y ∷ p) | P.refl = cong _ (lem p)
≡-from-≈ : {s s′ : String} → s ≈ s′ → s ≡ s′
≡-from-≈ {s} {s′} p = begin
s ≡⟨ sym (fromList∘toList _) ⟩
stringFromList (stringToList s) ≡⟨ cong stringFromList (lem p) ⟩
stringFromList (stringToList s′) ≡⟨ fromList∘toList _ ⟩
s′ ∎
where
open P.≡-Reasoning
≈-from-≡ : {s s′ : String} → s ≡ s′ → s ≈ s′
≈-from-≡ {s} {_} refl = string-refl {s}
where
open IsEquivalence string-isEquivalence renaming (refl to string-refl) using ()
compare : (x y : String) → Tri (x < y) (x ≡ y) _
compare x y with string-compare x y
compare x y | tri< a ¬b ¬c = tri< a (¬b ∘ ≈-from-≡) ¬c
compare x y | tri≈ ¬a b ¬c = tri≈ ¬a (≡-from-≈ b) ¬c
compare x y | tri> ¬a ¬b c = tri> ¬a (¬b ∘ ≈-from-≡) c
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.