fact stringlengths 5 670 | type stringclasses 3
values | library stringclasses 18
values | imports listlengths 0 48 | filename stringclasses 782
values | symbolic_name stringlengths 1 35 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
UIP : (A : Set a) → Set a | function | Axiom | [
"Level",
"Relation.Nullary.Decidable.Core",
"Relation.Binary.Core",
"Relation.Binary.Definitions",
"Relation.Binary.PropositionalEquality.Core",
"Relation.Binary.PropositionalEquality.Properties"
] | Axiom/UniquenessOfIdentityProofs.agda | UIP | |
μ : Container s p → Set (s ⊔ p) | function | Data | [
"Level",
"Data.W",
"Data.Container.Core public",
"Data.Container.Relation.Unary.Any",
"Data.Container.Relation.Unary.All",
"Data.Container.Membership",
"Data.Container.Relation.Binary.Pointwise",
"Data.Container.Relation.Binary.Pointwise.Properties",
"Data.Container.Relation.Binary.Equality.Setoid",... | Data/Container.agda | μ | |
WithDefault {a} {A: Set a} (x : A) : Set a
where
constructor _!
field value : A | record | Data | [] | Data/Default.agda | WithDefault | |
DiffList : Set a → Set a | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | DiffList | |
lift : (List A → List A) → (DiffList A → DiffList A) | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | lift | |
_∷_ : A → DiffList A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | _∷_ | |
_++_ : DiffList A → DiffList A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | _++_ | |
_∷ʳ_ : DiffList A → A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | _∷ʳ_ | |
toList : DiffList A → List A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | toList | |
fromList : List A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | fromList | |
map : (A → B) → DiffList A → DiffList B | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | map | |
concat : DiffList (DiffList A) → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | concat | |
take : ℕ → DiffList A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | take | |
drop : ℕ → DiffList A → DiffList A | function | Data | [
"Level",
"Data.List.Base as List",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceList.agda | drop | |
Diffℕ : Set | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | Diffℕ | |
0# : Diffℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | 0# | |
suc : Diffℕ → Diffℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | suc | |
1# : Diffℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | 1# | |
_+_ : Diffℕ → Diffℕ → Diffℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | _+_ | |
toℕ : Diffℕ → ℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | toℕ | |
fromℕ : ℕ → Diffℕ | function | Data | [
"Data.Nat.Base as ℕ",
"Function.Base"
] | Data/DifferenceNat.agda | fromℕ | |
DiffVec : ∀ {ℓ} → Set ℓ → Diffℕ → Set ℓ | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | DiffVec | |
_∷_ : ∀ {a} {A : Set a} {n} → A → DiffVec A n → DiffVec A (suc n) | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | _∷_ | |
_++_ : ∀ {a} {A : Set a} {m n} → | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | _++_ | |
toVec : ∀ {a} {A : Set a} {n} → DiffVec A n → Vec A (toℕ n) | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | toVec | |
fromVec : ∀ {a} {A : Set a} {n} → Vec A n → DiffVec A (fromℕ n) | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | fromVec | |
head : ∀ {a} {A : Set a} {n} → DiffVec A (suc n) → A | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | head | |
tail : ∀ {a} {A : Set a} {n} → DiffVec A (suc n) → DiffVec A n | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | tail | |
take : ∀ {a} {A : Set a} m {n} → | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | take | |
drop : ∀ {a} {A : Set a} m {n} → | function | Data | [
"Data.DifferenceNat",
"Data.Vec.Base as Vec",
"Function.Base",
"Data.Nat.Base"
] | Data/DifferenceVec.agda | drop | |
Digit : ℕ → Set | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | Digit | |
0b : Bit | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | 0b | |
1b : Bit | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | 1b | |
toNatDigits : (base : ℕ) {base≤16 : True (1 ≤? base)} → ℕ → List ℕ | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | toNatDigits | |
Expansion : ℕ → Set | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | Expansion | |
fromDigits : ∀ {base} → Expansion base → ℕ | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | fromDigits | |
toDigits : (base : ℕ) {base≥2 : True (2 ≤? base)} (n : ℕ) → | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | toDigits | |
digitChars : Vec Char 16 | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | digitChars | |
showDigit : ∀ {base} {base≤16 : True (base ≤? 16)} → Digit base → Char | function | Data | [
"Data.Nat.Base",
"Data.Nat.Properties",
"Data.Fin.Base as Fin",
"Data.Bool.Base",
"Data.Char.Base",
"Data.List.Base",
"Data.Product.Base",
"Data.Vec.Base as Vec",
"Data.Nat.DivMod",
"Data.Nat.Induction",
"Function.Base",
"Relation.Nullary.Decidable",
"Relation.Binary.Definitions",
"Relatio... | Data/Digit.agda | showDigit | |
⊥ : Set | function | Data | [
"Data.Irrelevant"
] | Data/Empty.agda | ⊥ | |
⊥-elim : ∀ {w} {Whatever : Set w} → ⊥ → Whatever | function | Data | [
"Data.Irrelevant"
] | Data/Empty.agda | ⊥-elim | |
⊥-elim-irr : ∀ {w} {Whatever : Set w} → .⊥ → Whatever | function | Data | [
"Data.Irrelevant"
] | Data/Empty.agda | ⊥-elim-irr | |
show : ℤ → String | function | Data | [
"Data.Integer.Base public",
"Data.Integer.Properties public",
"Data.Integer.Properties public",
"Data.Nat.Show",
"Data.Sign.Base as Sign",
"Data.String.Base"
] | Data/Integer.agda | show | |
Irrelevant (A: Set a) : Set a
where
constructor [_]
field .irrelevant : A | record | Data | [
"Level"
] | Data/Irrelevant.agda | Irrelevant | |
map : (A → B) → Irrelevant A → Irrelevant B | function | Data | [
"Level"
] | Data/Irrelevant.agda | map | |
pure : A → Irrelevant A | function | Data | [
"Level"
] | Data/Irrelevant.agda | pure | |
_<*>_ : Irrelevant (A → B) → Irrelevant A → Irrelevant B | function | Data | [
"Level"
] | Data/Irrelevant.agda | _<*>_ | |
_>>=_ : Irrelevant A → (.A → Irrelevant B) → Irrelevant B | function | Data | [
"Level"
] | Data/Irrelevant.agda | _>>=_ | |
zipWith : (A → B → C) → Irrelevant A → Irrelevant B → Irrelevant C | function | Data | [
"Level"
] | Data/Irrelevant.agda | zipWith | |
Is-just : Maybe A → Set _ | function | Data | [
"Data.Empty",
"Data.Unit.Base",
"Data.Bool.Base",
"Data.Maybe.Relation.Unary.All",
"Data.Maybe.Relation.Unary.Any",
"Level",
"Data.Maybe.Base public"
] | Data/Maybe.agda | Is-just | |
Is-nothing : Maybe A → Set _ | function | Data | [
"Data.Empty",
"Data.Unit.Base",
"Data.Bool.Base",
"Data.Maybe.Relation.Unary.All",
"Data.Maybe.Relation.Unary.Any",
"Level",
"Data.Maybe.Base public"
] | Data/Maybe.agda | Is-nothing | |
to-witness : ∀ {m : Maybe A} → Is-just m → A | function | Data | [
"Data.Empty",
"Data.Unit.Base",
"Data.Bool.Base",
"Data.Maybe.Relation.Unary.All",
"Data.Maybe.Relation.Unary.Any",
"Level",
"Data.Maybe.Base public"
] | Data/Maybe.agda | to-witness | |
to-witness-T : ∀ (m : Maybe A) → T (is-just m) → A | function | Data | [
"Data.Empty",
"Data.Unit.Base",
"Data.Bool.Base",
"Data.Maybe.Relation.Unary.All",
"Data.Maybe.Relation.Unary.Any",
"Level",
"Data.Maybe.Base public"
] | Data/Maybe.agda | to-witness-T | |
map-Σ : {B : A → Set b} {P : A → Set p} {Q : {x : A} → P x → B x → Set q} → | function | Data | [
"Level",
"Relation.Nullary.Negation.Core",
"Data.Product.Base public"
] | Data/Product.agda | map-Σ | |
map-Σ′ : {B : A → Set b} {P : Set p} {Q : P → Set q} → | function | Data | [
"Level",
"Relation.Nullary.Negation.Core",
"Data.Product.Base public"
] | Data/Product.agda | map-Σ′ | |
zipWith : {P : A → Set p} {Q : B → Set q} {R : C → Set r} {S : (x : C) → R x → Set s} | function | Data | [
"Level",
"Relation.Nullary.Negation.Core",
"Data.Product.Base public"
] | Data/Product.agda | zipWith | |
∃! : {A : Set a} → (A → A → Set ℓ) → (A → Set b) → Set (a ⊔ b ⊔ ℓ) | function | Data | [
"Level",
"Relation.Nullary.Negation.Core",
"Data.Product.Base public"
] | Data/Product.agda | ∃! | |
show : ℚ → String | function | Data | [
"Data.Rational.Base public",
"Data.Rational.Properties public",
"Data.Rational.Properties public",
"Data.Integer.Show",
"Data.String.Base"
] | Data/Rational.agda | show | |
labels : ∀ {s} → Signature s → List Label | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | labels | |
_∈_ : ∀ {s} → Label → Signature s → Set | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | _∈_ | |
Restrict : ∀ {s} (Sig : Signature s) (ℓ : Label) → ℓ ∈ Sig → | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | Restrict | |
Restricted : ∀ {s} (Sig : Signature s) (ℓ : Label) → ℓ ∈ Sig → Set s | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | Restricted | |
Proj : ∀ {s} (Sig : Signature s) (ℓ : Label) {ℓ∈ : ℓ ∈ Sig} → | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | Proj | |
_∣_ : ∀ {s} {Sig : Signature s} → Record Sig → | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | _∣_ | |
_·_ : ∀ {s} {Sig : Signature s} (r : Record Sig) | function | Data | [
"Data.Bool.Base",
"Data.Empty",
"Data.List.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic",
"Function.Base",
"Level",
"Relation.Binary.Definitions",
"Relation.Nullary.Decidable"
] | Data/Record.agda | _·_ | |
toVec : (s : String) → Vec Char (length s) | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | toVec | |
fromVec : ∀ {n} → Vec Char n → String | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | fromVec | |
parensIfSpace : String → String | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | parensIfSpace | |
rectangle : ∀ {n} → Vec (ℕ → String → String) n → | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | rectangle | |
rectangleˡ : ∀ {n} → Char → Vec String n → Vec String n | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | rectangleˡ | |
rectangleʳ : ∀ {n} → Char → Vec String n → Vec String n | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | rectangleʳ | |
rectangleᶜ : ∀ {n} → Char → Char → Vec String n → Vec String n | function | Data | [
"Data.Bool.Base",
"Data.Char.Base as Char",
"Function.Base",
"Data.Nat.Base as ℕ",
"Data.Nat.Properties",
"Data.List.Base as List",
"Data.List.Extrema ℕ.≤-totalOrder",
"Data.Vec.Base as Vec",
"Data.Char.Base as Char",
"Data.Char.Properties",
"Relation.Nullary.Decidable.Core",
"Data.List.Member... | Data/String.agda | rectangleᶜ | |
fromThis : These A B → Maybe A | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | fromThis | |
fromThat : These A B → Maybe B | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | fromThat | |
leftMost : These A A → A | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | leftMost | |
rightMost : These A A → A | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | rightMost | |
mergeThese : (A → A → A) → These A A → A | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | mergeThese | |
deleteThis : These A B → Maybe (These A B) | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | deleteThis | |
deleteThat : These A B → Maybe (These A B) | function | Data | [
"Level",
"Data.Maybe.Base",
"Data.Sum.Base",
"Function.Base",
"Data.These.Base public"
] | Data/These.agda | deleteThat | |
Trie : ∀ {v} (V : Value v) → Size → Set (v ⊔ k ⊔ e ⊔ r) | function | Data | [
"Relation.Binary.Core",
"Relation.Binary.Bundles",
"Level",
"Size",
"Data.List.Base",
"Data.List.NonEmpty",
"Data.Maybe.Base as Maybe",
"Data.Product.Base",
"Data.These.Base as These",
"Function.Base",
"Relation.Unary",
"Data.List.Relation.Binary.Equality.Setoid Eq.setoid",
"Data.Tree.AVL.Va... | Data/Trie.agda | Trie | |
Universe u e: Set (suc (u ⊔ e))
where
field
U : Set u -- Codes.
El : U → Set e -- Decoding function. | record | Data | [
"Level"
] | Data/Universe.agda | Universe | |
sup-injective₁ : ∀ {s t : Shape C} {f : Position C s → W C} {g} → | function | Data | [
"Level",
"Function.Base",
"Data.Product.Base",
"Data.Container.Core",
"Data.Container.Relation.Unary.All",
"Relation.Nullary.Negation",
"Agda.Builtin.Equality"
] | Data/W.agda | sup-injective₁ | |
head : W C → Shape C | function | Data | [
"Level",
"Function.Base",
"Data.Product.Base",
"Data.Container.Core",
"Data.Container.Relation.Unary.All",
"Relation.Nullary.Negation",
"Agda.Builtin.Equality"
] | Data/W.agda | head | |
tail : (x : W C) → Position C (head x) → W C | function | Data | [
"Level",
"Function.Base",
"Data.Product.Base",
"Data.Container.Core",
"Data.Container.Relation.Unary.All",
"Relation.Nullary.Negation",
"Agda.Builtin.Equality"
] | Data/W.agda | tail | |
map : (m : C₁ ⇒ C₂) → W C₁ → W C₂ | function | Data | [
"Level",
"Function.Base",
"Data.Product.Base",
"Data.Container.Core",
"Data.Container.Relation.Unary.All",
"Relation.Nullary.Negation",
"Agda.Builtin.Equality"
] | Data/W.agda | map | |
inhabited⇒empty : (∀ s → Position C s) → ¬ W C | function | Data | [
"Level",
"Function.Base",
"Data.Product.Base",
"Data.Container.Core",
"Data.Container.Relation.Unary.All",
"Relation.Nullary.Negation",
"Agda.Builtin.Equality"
] | Data/W.agda | inhabited⇒empty | |
Wrap : ∀ {n ls} {A : Sets n ls} → A ⇉ Set ℓ → A ⇉ Set ℓ | function | Data | [
"Data.Product.Nary.NonDependent",
"Function.Nary.NonDependent",
"Level",
"Relation.Nary"
] | Data/Wrap.agda | Wrap | |
traceId : String → String | function | Debug | [
"Agda.Builtin.String",
"Agda.Builtin.Equality"
] | Debug/Trace.agda | traceId | |
RawApplicative (F: Set f → Set g) : Set (suc f ⊔ g)
where
infixl 4 _<*>_ _<*_ _*>_
infixl 4 _⊛_ _<⊛_ _⊛>_
infix 4 _⊗_
field
rawFunctor : RawFunctor F
pure : A → F A
_<*>_ : F (A → B) → F A → F B
open RawFunctor rawFunctor public
| record | Effect | [
"Data.Bool.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Functor as Fun",
"Function.Base",
"Level",
"Relation.Binary.PropositionalEquality.Core"
] | Effect/Applicative.agda | RawApplicative | |
RawApplicativeZero (F: Set f → Set g) : Set (suc f ⊔ g)
where
field
rawApplicative : RawApplicative F
rawEmpty : RawEmpty F
open RawApplicative rawApplicative public
open RawEmpty rawEmpty public
guard : Bool → F ⊤
guard true = pure _
guard false = empty | record | Effect | [
"Data.Bool.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Functor as Fun",
"Function.Base",
"Level",
"Relation.Binary.PropositionalEquality.Core"
] | Effect/Applicative.agda | RawApplicativeZero | |
RawAlternative (F: Set f → Set g) : Set (suc f ⊔ g)
where
field
rawApplicativeZero : RawApplicativeZero F
rawChoice : RawChoice F
open RawApplicativeZero rawApplicativeZero public
open RawChoice rawChoice public
------------------------------------------------------------------------ | record | Effect | [
"Data.Bool.Base",
"Data.Product.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Functor as Fun",
"Function.Base",
"Level",
"Relation.Binary.PropositionalEquality.Core"
] | Effect/Applicative.agda | RawAlternative | |
RawChoice (F: Set ℓ → Set ℓ′) : Set (suc ℓ ⊔ ℓ′)
where
infixr 3 _<|>_ _∣_
field
_<|>_ : F A → F A → F A
-- backwards compatibility: unicode variants
_∣_ : F A → F A → F A
_∣_ = _<|>_ | record | Effect | [
"Level"
] | Effect/Choice.agda | RawChoice | |
RawComonad (W: Set f → Set f) : Set (suc f)
where
infixl 1 _=>>_ _=>=_
infixr 1 _<<=_ _=<=_
field
extract : W A → A
extend : (W A → B) → (W A → W B)
duplicate : W A → W (W A)
duplicate = extend id
| record | Effect | [
"Level",
"Function.Base"
] | Effect/Comonad.agda | RawComonad | |
RawEmpty (F: Set ℓ → Set ℓ′) : Set (suc ℓ ⊔ ℓ′)
where
field
empty : F A
-- backwards compatibility: unicode variants
∅ : F A
∅ = empty | record | Effect | [
"Level"
] | Effect/Empty.agda | RawEmpty | |
RawFoldable (F: Set f → Set g) : Setω
where
field
foldMap : (M : RawMonoid c ℓ) (open RawMonoid M) →
(A → Carrier) → F A → Carrier
fold : (M : RawMonoid f ℓ) (open RawMonoid M) → F Carrier → Carrier
fold M = foldMap M id
field
foldr : (A -> C -> C) -> C -> F A -> C
foldl : (C -> A ->... | record | Effect | [
"Algebra.Bundles.Raw",
"Algebra.Bundles",
"Algebra.Construct.Flip.Op",
"Data.List.Base as List",
"Effect.Functor as Fun",
"Function.Base",
"Function.Endo.Propositional",
"Level",
"Relation.Binary.Bundles"
] | Effect/Foldable.agda | RawFoldable | |
RawFoldableWithDefaults (F: Set f → Set g) : Setω
where
field
foldMap : (M : RawMonoid c ℓ) (open RawMonoid M) →
(A → Carrier) → F A → Carrier
foldr : (A -> C -> C) -> C -> F A -> C
foldr {C = C} f z t = foldMap M₀ f t z
where M = ∘-id-monoid C ; M₀ = Monoid.rawMonoid M
foldl : (C -> A -... | record | Effect | [
"Algebra.Bundles.Raw",
"Algebra.Bundles",
"Algebra.Construct.Flip.Op",
"Data.List.Base as List",
"Effect.Functor as Fun",
"Function.Base",
"Function.Endo.Propositional",
"Level",
"Relation.Binary.Bundles"
] | Effect/Foldable.agda | RawFoldableWithDefaults | |
RawFunctor (F: Set ℓ → Set ℓ′) : Set (suc ℓ ⊔ ℓ′)
where
infixl 4 _<$>_ _<$_
infixl 1 _<&>_
field
_<$>_ : (A → B) → F A → F B
_<$_ : A → F B → F A
x <$ y = const x <$> y
_<&>_ : F A → (A → B) → F B
_<&>_ = flip _<$>_ | record | Effect | [
"Data.Unit.Polymorphic.Base",
"Function.Base",
"Level",
"Relation.Binary.PropositionalEquality.Core"
] | Effect/Functor.agda | RawFunctor | |
RawMonad (F: Set f → Set g) : Set (suc f ⊔ g)
where
infixl 1 _>>=_ _>>_ _>=>_
infixr 1 _=<<_ _<=<_
field
rawApplicative : RawApplicative F
_>>=_ : F A → (A → F B) → F B
open RawApplicative rawApplicative public
_>>_ : F A → F B → F B
_>>_ = _*>_ | record | Effect | [
"Data.Bool.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Applicative as App",
"Function.Base",
"Level"
] | Effect/Monad.agda | RawMonad | |
RawMonadZero (F: Set f → Set g) : Set (suc f ⊔ g)
where
field
rawMonad : RawMonad F
rawEmpty : RawEmpty F
open RawMonad rawMonad public
open RawEmpty rawEmpty public
rawApplicativeZero : RawApplicativeZero F
rawApplicativeZero = record
{ rawApplicative = rawApplicative | record | Effect | [
"Data.Bool.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Applicative as App",
"Function.Base",
"Level"
] | Effect/Monad.agda | RawMonadZero | |
RawMonadPlus (F: Set f → Set g) : Set (suc f ⊔ g)
where
field
rawMonadZero : RawMonadZero F
rawChoice : RawChoice F
open RawMonadZero rawMonadZero public
open RawChoice rawChoice public
rawAlternative : RawAlternative F
rawAlternative = record
{ rawApplicativeZero = rawApplicativeZero | record | Effect | [
"Data.Bool.Base",
"Data.Unit.Polymorphic.Base",
"Effect.Choice",
"Effect.Empty",
"Effect.Applicative as App",
"Function.Base",
"Level"
] | Effect/Monad.agda | RawMonadPlus |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.