@@ -27,160 +27,30 @@ open import Function.Equivalence
27
27
open import Relation.Binary.PropositionalEquality as P using (_≡_; _≢_; refl)
28
28
open import Relation.Nullary.Decidable using (isYes)
29
29
30
- private
31
- variable
32
- a b c : Level
33
- A : Set a
34
- B : Set b
35
- C : Set c
36
-
37
30
------------------------------------------------------------------------
38
31
-- Re-export basic type and operations
39
32
40
33
open import Data.List.NonEmpty.Base public
41
34
42
- ------------------------------------------------------------------------
43
- -- More operations
44
-
45
- -- Groups all contiguous elements for which the predicate returns the
46
- -- same result into lists.
47
-
48
- split : (p : A → Bool) → List A →
49
- List (List⁺ (∃ (T ∘ p)) ⊎ List⁺ (∃ (T ∘ not ∘ p)))
50
- split p [] = []
51
- split p (x ∷ xs) with p x | P.inspect p x | split p xs
52
- ... | true | P.[ px≡t ] | inj₁ xs′ ∷ xss = inj₁ ((x , Eq.from T-≡ ⟨$⟩ px≡t) ∷⁺ xs′) ∷ xss
53
- ... | true | P.[ px≡t ] | xss = inj₁ [ x , Eq.from T-≡ ⟨$⟩ px≡t ] ∷ xss
54
- ... | false | P.[ px≡f ] | inj₂ xs′ ∷ xss = inj₂ ((x , Eq.from T-not-≡ ⟨$⟩ px≡f) ∷⁺ xs′) ∷ xss
55
- ... | false | P.[ px≡f ] | xss = inj₂ [ x , Eq.from T-not-≡ ⟨$⟩ px≡f ] ∷ xss
56
-
57
- -- If we flatten the list returned by split, then we get the list we
58
- -- started with.
59
-
60
- flatten : ∀ {p q} {P : A → Set p} {Q : A → Set q} →
61
- List (List⁺ (∃ P) ⊎ List⁺ (∃ Q)) → List A
62
- flatten = List.concat ∘
63
- List.map Sum.[ toList ∘ map proj₁ , toList ∘ map proj₁ ]
64
-
65
- flatten-split : (p : A → Bool) (xs : List A) → flatten (split p xs) ≡ xs
66
- flatten-split p [] = refl
67
- flatten-split p (x ∷ xs)
68
- with p x | P.inspect p x | split p xs | flatten-split p xs
69
- ... | true | P.[ _ ] | [] | hyp = P.cong (_∷_ x) hyp
70
- ... | true | P.[ _ ] | inj₁ _ ∷ _ | hyp = P.cong (_∷_ x) hyp
71
- ... | true | P.[ _ ] | inj₂ _ ∷ _ | hyp = P.cong (_∷_ x) hyp
72
- ... | false | P.[ _ ] | [] | hyp = P.cong (_∷_ x) hyp
73
- ... | false | P.[ _ ] | inj₁ _ ∷ _ | hyp = P.cong (_∷_ x) hyp
74
- ... | false | P.[ _ ] | inj₂ _ ∷ _ | hyp = P.cong (_∷_ x) hyp
75
-
76
- -- Groups all contiguous elements /not/ satisfying the predicate into
77
- -- lists. Elements satisfying the predicate are dropped.
78
-
79
- wordsBy : (A → Bool) → List A → List (List⁺ A)
80
- wordsBy p =
81
- List.mapMaybe Sum.[ const nothing , just ∘′ map proj₁ ] ∘ split p
82
35
83
36
------------------------------------------------------------------------
84
- -- Examples
85
-
86
- -- Note that these examples are simple unit tests, because the type
87
- -- checker verifies them .
37
+ -- DEPRECATED
38
+ ------------------------------------------------------------------------
39
+ -- Please use the new names as continuing support for the old names is
40
+ -- not guaranteed .
88
41
89
42
private
90
- module Examples {A B : Set }
91
- (_⊕_ : A → B → B)
92
- (_⊗_ : B → A → B)
93
- (_⊙_ : A → A → A)
94
- (f : A → B)
95
- (a b c : A)
96
- where
97
-
98
- hd : head (a ∷⁺ b ∷⁺ [ c ]) ≡ a
99
- hd = refl
100
-
101
- tl : tail (a ∷⁺ b ∷⁺ [ c ]) ≡ b ∷ c ∷ []
102
- tl = refl
103
-
104
- mp : map f (a ∷⁺ b ∷⁺ [ c ]) ≡ f a ∷⁺ f b ∷⁺ [ f c ]
105
- mp = refl
106
-
107
- right : foldr _⊕_ f (a ∷⁺ b ∷⁺ [ c ]) ≡ (a ⊕ (b ⊕ f c))
108
- right = refl
109
-
110
- right₁ : foldr₁ _⊙_ (a ∷⁺ b ∷⁺ [ c ]) ≡ (a ⊙ (b ⊙ c))
111
- right₁ = refl
112
-
113
- left : foldl _⊗_ f (a ∷⁺ b ∷⁺ [ c ]) ≡ ((f a ⊗ b) ⊗ c)
114
- left = refl
115
-
116
- left₁ : foldl₁ _⊙_ (a ∷⁺ b ∷⁺ [ c ]) ≡ ((a ⊙ b) ⊙ c)
117
- left₁ = refl
118
-
119
- ⁺app⁺ : (a ∷⁺ b ∷⁺ [ c ]) ⁺++⁺ (b ∷⁺ [ c ]) ≡
120
- a ∷⁺ b ∷⁺ c ∷⁺ b ∷⁺ [ c ]
121
- ⁺app⁺ = refl
122
-
123
- ⁺app : (a ∷⁺ b ∷⁺ [ c ]) ⁺++ (b ∷ c ∷ []) ≡
124
- a ∷⁺ b ∷⁺ c ∷⁺ b ∷⁺ [ c ]
125
- ⁺app = refl
126
-
127
- app⁺ : (a ∷ b ∷ c ∷ []) ++⁺ (b ∷⁺ [ c ]) ≡
128
- a ∷⁺ b ∷⁺ c ∷⁺ b ∷⁺ [ c ]
129
- app⁺ = refl
130
-
131
- conc : concat ((a ∷⁺ b ∷⁺ [ c ]) ∷⁺ [ b ∷⁺ [ c ] ]) ≡
132
- a ∷⁺ b ∷⁺ c ∷⁺ b ∷⁺ [ c ]
133
- conc = refl
134
-
135
- rev : reverse (a ∷⁺ b ∷⁺ [ c ]) ≡ c ∷⁺ b ∷⁺ [ a ]
136
- rev = refl
137
-
138
- snoc : (a ∷ b ∷ c ∷ []) ∷ʳ a ≡ a ∷⁺ b ∷⁺ c ∷⁺ [ a ]
139
- snoc = refl
140
-
141
- snoc⁺ : (a ∷⁺ b ∷⁺ [ c ]) ⁺∷ʳ a ≡ a ∷⁺ b ∷⁺ c ∷⁺ [ a ]
142
- snoc⁺ = refl
143
-
144
- split-true : split (const true) (a ∷ b ∷ c ∷ []) ≡
145
- inj₁ ((a , tt) ∷⁺ (b , tt) ∷⁺ [ c , tt ]) ∷ []
146
- split-true = refl
147
-
148
- split-false : split (const false) (a ∷ b ∷ c ∷ []) ≡
149
- inj₂ ((a , tt) ∷⁺ (b , tt) ∷⁺ [ c , tt ]) ∷ []
150
- split-false = refl
151
-
152
- split-≡1 :
153
- split (ℕ._≡ᵇ 1 ) (1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ []) ≡
154
- inj₁ [ 1 , tt ] ∷ inj₂ ((2 , tt) ∷⁺ [ 3 , tt ]) ∷
155
- inj₁ ((1 , tt) ∷⁺ [ 1 , tt ]) ∷ inj₂ [ 2 , tt ] ∷ inj₁ [ 1 , tt ] ∷
156
- []
157
- split-≡1 = refl
158
-
159
- wordsBy-true : wordsBy (const true) (a ∷ b ∷ c ∷ []) ≡ []
160
- wordsBy-true = refl
161
-
162
- wordsBy-false : wordsBy (const false) (a ∷ b ∷ c ∷ []) ≡
163
- (a ∷⁺ b ∷⁺ [ c ]) ∷ []
164
- wordsBy-false = refl
165
-
166
- wordsBy-≡1 :
167
- wordsBy (ℕ._≡ᵇ 1 ) (1 ∷ 2 ∷ 3 ∷ 1 ∷ 1 ∷ 2 ∷ 1 ∷ []) ≡
168
- (2 ∷⁺ [ 3 ]) ∷ [ 2 ] ∷ []
169
- wordsBy-≡1 = refl
170
-
171
- ------------------------------------------------------------------------
172
- -- DEPRECATED
173
- ------------------------------------------------------------------------
174
- -- Please use the new names as continuing support for the old names is
175
- -- not guaranteed.
43
+ variable
44
+ a : Level
45
+ A : Set a
176
46
177
- -- Version 1.4
47
+ -- Version 1.4
178
48
179
- infixl 5 _∷ʳ'_
49
+ infixl 5 _∷ʳ'_
180
50
181
- _∷ʳ'_ : (xs : List A) (x : A) → SnocView (xs ∷ʳ x)
182
- _∷ʳ'_ = SnocView._∷ʳ′_
183
- {-# WARNING_ON_USAGE _∷ʳ'_
184
- "Warning: _∷ʳ'_ (ending in an apostrophe) was deprecated in v1.4.
185
- Please use _∷ʳ′_ (ending in a prime) instead."
186
- #-}
51
+ _∷ʳ'_ : (xs : List A) (x : A) → SnocView (xs ∷ʳ x)
52
+ _∷ʳ'_ = SnocView._∷ʳ′_
53
+ {-# WARNING_ON_USAGE _∷ʳ'_
54
+ "Warning: _∷ʳ'_ (ending in an apostrophe) was deprecated in v1.4.
55
+ Please use _∷ʳ′_ (ending in a prime) instead."
56
+ #-}
0 commit comments