fact stringlengths 9 8.64k | type stringclasses 3
values | library stringclasses 2
values | imports listlengths 0 30 | filename stringclasses 118
values | symbolic_name stringlengths 1 23 | docstring stringclasses 1
value |
|---|---|---|---|---|---|---|
fileIsEqual : ∀ {k} → Path k → Path k → IO Unit | function | test | [
"open import Prelude",
"open import System.File",
"open import System.FilePath",
"open import Prelude.Equality"
] | test/Files.agda | fileIsEqual | |
main : IO ⊤ | function | test | [
"open import Prelude",
"open import System.File",
"open import System.FilePath",
"open import Prelude.Equality"
] | test/Files.agda | main | |
N : Set where z : N s : N → N unquoteDecl eqN = deriveEq eqN (quote N) | data | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | N | |
putStrI : String → StateT Nat IO Unit | function | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | putStrI | |
main : IO ⊤ | function | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | main | |
downFrom : Nat → List Nat | function | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | downFrom | |
thm : ∀ n → 6 * sumR (map (_^ 2) (downFrom n)) ≡ n * (n + 1) * (2 * n + 1) | function | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | thm | |
thm₂ : (a b : Nat) → (a - b) * (a + b) ≡ a ^ 2 - b ^ 2 | function | test | [
"import Everything",
"open import Prelude",
"open import Container.Traversable",
"open import Container.Foldable",
"open import Container.List",
"open import Text.Parse",
"open import Text.Lex",
"open import Text.Printf.Prelude",
"open import Control.Monad.State",
"open import Control.Monad.Transf... | test/Main.agda | thm₂ | |
SemigroupAnd : Semigroup Bool | function | test | [
"open import Prelude",
"open import Container.Traversable",
"open import Tactic.Monoid",
"open import Tactic.Reflection"
] | test/MonoidTactic.agda | SemigroupAnd | |
MonoidAnd : Monoid Bool | function | test | [
"open import Prelude",
"open import Container.Traversable",
"open import Tactic.Monoid",
"open import Tactic.Reflection"
] | test/MonoidTactic.agda | MonoidAnd | |
test₁ : (a b : Bool) → (a && (b && a && true)) ≡ ((a && b) && a) | function | test | [
"open import Prelude",
"open import Container.Traversable",
"open import Tactic.Monoid",
"open import Tactic.Reflection"
] | test/MonoidTactic.agda | test₁ | |
test₃ : ∀ {a} {A : Set a} (xs ys zs : List A) → xs ++ ys ++ zs ≡ (xs ++ []) ++ (ys ++ []) ++ zs | function | test | [
"open import Prelude",
"open import Container.Traversable",
"open import Tactic.Monoid",
"open import Tactic.Reflection"
] | test/MonoidTactic.agda | test₃ | |
main : IO ⊤ | function | test | [
"open import Prelude",
"open import Numeric.Nat.Prime"
] | test/PrimeTest.agda | main | |
LessFloat (x y : Float) : Set where less-float : primFloatLess x y ≡ true → LessFloat x y instance OrdFloat : Ord Float OrdFloat = defaultOrd cmpFloat where cmpFloat : ∀ x y → Comparison LessFloat x y cmpFloat x y with inspect (primFloatLess x y) ... | true with≡ eq = less (less-float eq) ... | false with≡ _ with inspe... | data | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | LessFloat | |
natToFloat : Nat → Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | natToFloat | |
intToFloat : Int → Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | intToFloat | |
isFinite : Float → Bool | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | isFinite | |
π : Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | π | |
cos : Float → Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | cos | |
tan : Float → Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | tan | |
log : Float → Float → Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | log | |
NaN : Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | NaN | |
Inf : Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | Inf | |
-Inf : Float | function | src | [
"open import Prelude",
"open import Prelude.Equality.Unsafe",
"open import Agda.Builtin.Float"
] | src/Builtin/Float.agda | -Inf | |
LessName (x y : Name) : Set where less-name : primQNameLess x y ≡ true → LessName x y private cmpName : ∀ x y → Comparison LessName x y cmpName x y with inspect (primQNameLess x y) ... | true with≡ eq = less (less-name eq) ... | false with≡ _ with inspect (primQNameLess y x) ... | true with≡ eq = greater (less-name eq)... | data | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | LessName | |
LessMeta (x y : Meta) : Set where less-meta : primMetaLess x y ≡ true → LessMeta x y private cmpMeta : ∀ x y → Comparison LessMeta x y cmpMeta x y with inspect (primMetaLess x y) ... | true with≡ eq = less (less-meta eq) ... | false with≡ _ with inspect (primMetaLess y x) ... | true with≡ eq = greater (less-meta eq) ..... | data | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | LessMeta | |
unArg : Arg A → A | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | unArg | |
getArgInfo : Arg A → ArgInfo | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getArgInfo | |
getVisibility : Arg A → Visibility | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getVisibility | |
getModality : Arg A → Modality | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getModality | |
getRelevance : Arg A → Relevance | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getRelevance | |
getQuantity : Arg A → Quantity | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getQuantity | |
isVisible : Arg A → Bool | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | isVisible | |
unAbs : Abs A → A | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | unAbs | |
absurd-lam : Term | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | absurd-lam | |
mapTC : (A → B) → TC A → TC B | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | mapTC | |
give : Term → Tactic | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | give | |
define : Arg Name → Type → List Clause → TC ⊤ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | define | |
newMeta : Type → TC Term | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | newMeta | |
typeErrorS : ∀ {a} {A : Set a} → String → TC A | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | typeErrorS | |
inferNormalisedType : Term → TC Type | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | inferNormalisedType | |
getParameters : Name → TC Nat | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getParameters | |
getConstructors : Name → TC (List Name) | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getConstructors | |
getClauses : Name → TC (List Clause) | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | getClauses | |
recordConstructor : Name → TC Name | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | recordConstructor | |
arg-inj₁ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → i ≡ i′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | arg-inj₁ | |
arg-inj₂ : ∀ {i i′} {x x′ : A} → arg i x ≡ arg i′ x′ → x ≡ x′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | arg-inj₂ | |
arg-info-inj₁ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → v ≡ v′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | arg-info-inj₁ | |
arg-info-inj₂ : ∀ {v v′ r r′} → arg-info v r ≡ arg-info v′ r′ → r ≡ r′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | arg-info-inj₂ | |
modality-inj₁ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → r ≡ r′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | modality-inj₁ | |
modality-inj₂ : ∀ {r r′ q q′} → modality r q ≡ modality r′ q′ → q ≡ q′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | modality-inj₂ | |
abs-inj₁ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → s ≡ s′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | abs-inj₁ | |
abs-inj₂ : ∀ {s s′} {x x′ : A} → abs s x ≡ abs s′ x′ → x ≡ x′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | abs-inj₂ | |
var-inj₁ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → x ≡ x′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | var-inj₁ | |
var-inj₂ : ∀ {x x′ args args′} → Term.var x args ≡ var x′ args′ → args ≡ args′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | var-inj₂ | |
con-inj₁ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → c ≡ c′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | con-inj₁ | |
con-inj₂ : ∀ {c c′ args args′} → Term.con c args ≡ con c′ args′ → args ≡ args′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | con-inj₂ | |
def-inj₁ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → f ≡ f′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | def-inj₁ | |
def-inj₂ : ∀ {f f′ args args′} → def f args ≡ def f′ args′ → args ≡ args′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | def-inj₂ | |
meta-inj₁ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → f ≡ f′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | meta-inj₁ | |
meta-inj₂ : ∀ {f f′ args args′} → Term.meta f args ≡ meta f′ args′ → args ≡ args′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | meta-inj₂ | |
lam-inj₁ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → v ≡ v′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | lam-inj₁ | |
lam-inj₂ : ∀ {v v′ t t′} → lam v t ≡ lam v′ t′ → t ≡ t′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | lam-inj₂ | |
pat-lam-inj₁ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → v ≡ v′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pat-lam-inj₁ | |
pat-lam-inj₂ : ∀ {v v′ t t′} → pat-lam v t ≡ pat-lam v′ t′ → t ≡ t′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pat-lam-inj₂ | |
pi-inj₁ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₁ ≡ t₁′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pi-inj₁ | |
pi-inj₂ : ∀ {t₁ t₁′ t₂ t₂′} → pi t₁ t₂ ≡ pi t₁′ t₂′ → t₂ ≡ t₂′ | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pi-inj₂ | |
sort-inj : ∀ {x y} → agda-sort x ≡ agda-sort y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | sort-inj | |
lit-inj : ∀ {x y} → Term.lit x ≡ lit y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | lit-inj | |
set-inj : ∀ {x y} → set x ≡ set y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | set-inj | |
prop-inj : ∀ {x y} → prop x ≡ prop y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | prop-inj | |
slit-inj : ∀ {x y} → Sort.lit x ≡ lit y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | slit-inj | |
spropLit-inj : ∀ {x y} → Sort.propLit x ≡ propLit y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | spropLit-inj | |
sinf-inj : ∀ {x y} → Sort.inf x ≡ inf y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | sinf-inj | |
pcon-inj₁ : ∀ {x y z w} → Pattern.con x y ≡ con z w → x ≡ z | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pcon-inj₁ | |
pcon-inj₂ : ∀ {x y z w} → Pattern.con x y ≡ con z w → y ≡ w | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pcon-inj₂ | |
pvar-inj : ∀ {x y} → Pattern.var x ≡ var y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pvar-inj | |
pdot-inj : ∀ {x y} → Pattern.dot x ≡ dot y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | pdot-inj | |
plit-inj : ∀ {x y} → Pattern.lit x ≡ lit y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | plit-inj | |
proj-inj : ∀ {x y} → Pattern.proj x ≡ proj y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | proj-inj | |
absurd-inj : ∀ {x y} → absurd x ≡ absurd y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | absurd-inj | |
clause-inj₁ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → x ≡ u | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | clause-inj₁ | |
clause-inj₂ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → y ≡ v | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | clause-inj₂ | |
clause-inj₃ : ∀ {x y z u v w} → clause x y z ≡ clause u v w → z ≡ w | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | clause-inj₃ | |
absurd-clause-inj₁ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → x ≡ z | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | absurd-clause-inj₁ | |
absurd-clause-inj₂ : ∀ {x y z w} → absurd-clause x y ≡ absurd-clause z w → y ≡ w | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | absurd-clause-inj₂ | |
nat-inj : ∀ {x y} → nat x ≡ nat y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | nat-inj | |
word64-inj : ∀ {x y} → word64 x ≡ word64 y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | word64-inj | |
float-inj : ∀ {x y} → float x ≡ float y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | float-inj | |
char-inj : ∀ {x y} → char x ≡ char y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | char-inj | |
string-inj : ∀ {x y} → string x ≡ string y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | string-inj | |
name-inj : ∀ {x y} → name x ≡ name y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | name-inj | |
meta-inj : ∀ {x y} → Literal.meta x ≡ meta y → x ≡ y | function | src | [
"open import Prelude hiding (abs)",
"open import Prelude.Equality.Unsafe",
"open import Builtin.Float",
"open import Container.Traversable",
"open import Control.Monad.Zero",
"open import Prelude.Variables",
"open import Agda.Builtin.Reflection as Builtin"
] | src/Builtin/Reflection.agda | meta-inj | |
Bag : Set → Set | function | src | [
"open import Prelude"
] | src/Container/Bag.agda | Bag | |
FunctorBag : Functor Bag | function | src | [
"open import Prelude"
] | src/Container/Bag.agda | FunctorBag | |
union : {A : Set} {{OrdA : Ord A}} → Bag A → Bag A → Bag A | function | src | [
"open import Prelude"
] | src/Container/Bag.agda | union | |
Foldable {a b w} (F : Set a → Set b) : Set (lsuc w ⊔ lsuc a ⊔ b) where field foldMap : ∀ {A}{W : Set w} {{MonW : Monoid W}} → (A → W) → F A → W overlap {{super}} : Functor F | record | src | [
"open import Prelude"
] | src/Container/Foldable.agda | Foldable | |
fold : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{MonW : Monoid W}} → F W → W | function | src | [
"open import Prelude"
] | src/Container/Foldable.agda | fold | |
minimum : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{OrdW : Ord W}} → F W → Maybe W | function | src | [
"open import Prelude"
] | src/Container/Foldable.agda | minimum | |
maximum : ∀ {a w} {W : Set w} {F : Set w → Set a} {{FoldF : Foldable F}} {{OrdW : Ord W}} → F W → Maybe W | function | src | [
"open import Prelude"
] | src/Container/Foldable.agda | maximum |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.