├── .config ├── git │ ├── config │ └── ignoreRevs └── mustache.yaml ├── .dir-locals.el ├── .editorconfig ├── .envrc ├── .gitattributes ├── .github ├── settings.yml └── workflows │ └── pages.yml ├── .gitignore ├── .shellcheckrc ├── LICENSE ├── README.md ├── dhall ├── Adjunction │ ├── Type │ ├── impliedComonad │ ├── impliedMonad │ └── package.dhall ├── Bimonad │ ├── Type │ └── package.dhall ├── Bimonoid │ ├── Type │ └── package.dhall ├── Bool │ ├── commutativeRing │ ├── complementedLattice │ ├── eq │ └── package.dhall ├── Category │ ├── Cartesian │ │ ├── Kind │ │ ├── Type │ │ ├── extractCategory │ │ ├── impliedBimonoid │ │ ├── impliedHopfMonoid │ │ └── package.dhall │ ├── Cat │ │ ├── package.dhall │ │ └── semigroupal │ ├── Closed │ │ ├── Kind │ │ └── package.dhall │ ├── Dagger │ │ ├── Kind │ │ ├── category │ │ └── package.dhall │ ├── Duoidal │ │ ├── Kind │ │ ├── Sort │ │ ├── Type │ │ ├── extractCategory │ │ ├── extractDiamond │ │ ├── extractStar │ │ └── package.dhall │ ├── Endofunctor │ │ ├── duoidal │ │ ├── monoidal │ │ │ ├── functor │ │ │ ├── monadic │ │ │ └── package.dhall │ │ └── package.dhall │ ├── Functor │ │ ├── category │ │ ├── inducedFunctor │ │ ├── liftedDuoidal │ │ ├── liftedMonoidal │ │ ├── liftedRig │ │ ├── monoidal │ │ ├── package.dhall │ │ └── types.dhall │ ├── Kind │ ├── Kleisli │ │ ├── category │ │ └── package.dhall │ ├── Monoidal │ │ ├── Braided │ │ │ ├── Type │ │ │ └── package.dhall │ │ ├── Cartesian │ │ │ ├── Kind │ │ │ ├── extractCategory │ │ │ ├── extractMonoidal │ │ │ ├── extractSemigroupal │ │ │ └── package.dhall │ │ ├── Closed │ │ │ ├── Cartesian │ │ │ │ ├── Kind │ │ │ │ └── package.dhall │ │ │ ├── Kind │ │ │ ├── curry │ │ │ └── package.dhall │ │ ├── Kind │ │ ├── Sort │ │ ├── Symmetric │ │ │ ├── Type │ │ │ └── package.dhall │ │ ├── Type │ │ ├── extractCategory │ │ ├── extractCategoryInstance │ │ ├── extractSemigroupal │ │ ├── package.dhall │ │ └── types.dhall │ ├── Op │ │ ├── Kind │ │ ├── category │ │ ├── categorySort │ │ ├── duoidal │ │ ├── monoidal │ │ ├── package.dhall │ │ ├── semigroupal │ │ ├── semigroupalSort │ │ └── types.dhall │ ├── Product │ │ ├── Kind │ │ ├── Type │ │ ├── category │ │ ├── package.dhall │ │ └── types.dhall │ ├── Profunctor │ │ ├── monoidal │ │ ├── package.dhall │ │ ├── semigroupal │ │ └── types.dhall │ ├── Rig │ │ ├── Kind │ │ ├── Sort │ │ ├── Type │ │ ├── extractAdditive │ │ ├── extractAdditiveInstance │ │ ├── extractCategory │ │ ├── extractMultiplicative │ │ ├── extractMultiplicativeInstance │ │ ├── package.dhall │ │ └── separatorMonoid │ ├── Semigroupal │ │ ├── Kind │ │ ├── Sort │ │ ├── Type │ │ ├── extractCategory │ │ ├── extractCategoryInstance │ │ ├── extractCategorySort │ │ ├── package.dhall │ │ └── types.dhall │ ├── Set │ │ ├── category │ │ │ ├── instance │ │ │ ├── monoidal │ │ │ ├── package.dhall │ │ │ └── rig │ │ ├── comonoid │ │ ├── curry │ │ ├── monoidal │ │ │ ├── cartesian │ │ │ └── package.dhall │ │ ├── package.dhall │ │ ├── rig │ │ ├── semigroupoid │ │ └── types.dhall │ ├── Sort │ ├── Type │ ├── extractSemigroupoid │ ├── package.dhall │ ├── postcomposition │ ├── precomposition │ └── types.dhall ├── Codensity │ ├── Type │ ├── functor │ │ ├── endo │ │ ├── monoidal │ │ └── package.dhall │ ├── lift │ ├── lower │ ├── monad │ └── package.dhall ├── Comonad │ ├── Type │ └── package.dhall ├── Comonoid │ ├── Kind │ ├── Type │ └── package.dhall ├── Compose │ ├── Type │ ├── adjunction │ ├── comonad │ ├── functor │ │ ├── instance │ │ ├── monoidal │ │ └── package.dhall │ ├── monad │ └── package.dhall ├── Cosemigroup │ ├── Type │ └── package.dhall ├── Costar │ ├── Type │ ├── category │ ├── package.dhall │ └── semigroupoid ├── Coyoneda │ ├── Type │ ├── functor │ ├── lift │ ├── lower │ └── package.dhall ├── Day │ ├── Type │ ├── comonad │ ├── convolution │ ├── functor │ └── package.dhall ├── Density │ ├── Type │ ├── functor │ ├── lift │ ├── lower │ └── package.dhall ├── Duoid │ ├── Kind │ ├── Type │ └── package.dhall ├── Either │ ├── Kind │ ├── duoid │ ├── functor │ │ ├── endo │ │ │ ├── package.dhall │ │ │ └── star │ │ ├── monoidal │ │ │ ├── package.dhall │ │ │ ├── parallel │ │ │ └── sequential │ │ ├── package.dhall │ │ └── pair │ ├── monad │ └── package.dhall ├── Eq │ ├── Type │ ├── eqfn │ ├── functor │ │ ├── contravariant │ │ └── package.dhall │ └── package.dhall ├── Field │ ├── Kind │ ├── Ordered │ │ ├── Type │ │ ├── extractPartiallyOrderedField │ │ ├── package.dhall │ │ └── terms.dhall │ ├── PartiallyOrdered │ │ ├── Type │ │ ├── extractField │ │ ├── package.dhall │ │ └── terms.dhall │ ├── Set │ ├── Type │ ├── divide │ ├── extractCommutativeRing │ ├── extractRing │ ├── package.dhall │ └── terms.dhall ├── Functor │ ├── Bifunctor │ │ ├── Type │ │ ├── impliedFirstFunctor │ │ ├── impliedSecondFunctor │ │ └── package.dhall │ ├── Constant │ │ ├── Kind │ │ ├── Type │ │ ├── functor │ │ ├── package.dhall │ │ └── term │ ├── Contravariant │ ├── Costar │ ├── Endo │ │ ├── Star │ │ │ ├── Type │ │ │ ├── package.dhall │ │ │ └── sequence │ │ ├── Type │ │ └── package.dhall │ ├── Monoidal │ │ ├── Type │ │ ├── extractFunctor │ │ ├── extractMonoid │ │ └── package.dhall │ ├── Pair │ │ ├── Type │ │ └── package.dhall │ ├── Profunctor │ │ ├── Type │ │ └── package.dhall │ ├── SetValued │ ├── Star │ │ ├── Type │ │ ├── functor │ │ └── package.dhall │ ├── Strong │ │ ├── Type │ │ └── package.dhall │ ├── Type │ ├── laws │ ├── opposite │ ├── package.dhall │ └── void ├── Group │ ├── Commutative │ │ ├── Kind │ │ ├── Set │ │ ├── Type │ │ ├── extractCommutativeMonoid │ │ ├── extractGroup │ │ ├── extractMonoid │ │ ├── package.dhall │ │ └── quotient │ ├── Kind │ ├── Ordered │ │ ├── Order │ │ ├── Type │ │ ├── defaultCompare │ │ ├── defaultLE │ │ ├── extractPartiallyOrderedGroup │ │ └── package.dhall │ ├── OrderedCommutative │ │ ├── Type │ │ ├── extractPartiallyOrderedCommutativeGroup │ │ └── package.dhall │ ├── PartiallyOrdered │ │ ├── Type │ │ ├── defaultEq │ │ ├── extractEq │ │ ├── extractGroup │ │ └── package.dhall │ ├── PartiallyOrderedCommutative │ │ ├── Type │ │ ├── extractCommutativeGroup │ │ ├── extractSetCommutativeGroup │ │ └── package.dhall │ ├── Type │ ├── extractMonoid │ ├── leftQuotient │ ├── package.dhall │ ├── rightQuotient │ └── terms.dhall ├── Groupoid │ ├── Type │ └── package.dhall ├── Identity │ ├── Kind │ ├── Type │ ├── adjunction │ ├── bimonad │ ├── comonad │ ├── functor │ │ ├── endo │ │ ├── monoidal │ │ └── package.dhall │ ├── monad │ └── package.dhall ├── Isomorphism │ ├── Kind │ ├── Type │ └── package.dhall ├── Lan │ ├── Type │ ├── functor │ ├── lift │ ├── lower │ └── package.dhall ├── Lattice │ ├── Bounded │ │ ├── Set │ │ ├── Type │ │ └── package.dhall │ ├── Complemented │ │ ├── Set │ │ ├── Type │ │ └── package.dhall │ ├── Type │ ├── extractJoin │ ├── extractMeet │ └── package.dhall ├── Leibniz │ ├── Kind │ ├── groupoid │ └── package.dhall ├── List │ ├── functor │ │ ├── compactable │ │ ├── endo │ │ │ ├── package.dhall │ │ │ └── star │ │ ├── monoidal │ │ └── package.dhall │ ├── monad │ ├── monoid │ ├── package.dhall │ └── semigroup ├── Loop │ ├── Kind │ ├── Type │ └── package.dhall ├── Magma │ ├── Kind │ ├── Sort │ ├── Type │ └── package.dhall ├── Monad │ ├── Type │ ├── impliedMonoidalFunctor │ ├── impliedStarfunctor │ ├── package.dhall │ └── terms.dhall ├── Monoid │ ├── Commutative │ │ ├── Kind │ │ ├── Monus │ │ │ ├── Kind │ │ │ ├── Type │ │ │ ├── extractCommutativeMonoid │ │ │ └── package.dhall │ │ ├── Set │ │ ├── Type │ │ ├── extractMonoid │ │ ├── extractSemigroup │ │ └── package.dhall │ ├── Hopf │ │ ├── Type │ │ └── package.dhall │ ├── Kind │ ├── Sort │ ├── Type │ ├── extractSemigroup │ ├── laws │ ├── package.dhall │ └── terms.dhall ├── Natural │ ├── duoid │ ├── monoid │ ├── package.dhall │ └── rig ├── NaturalTransformation │ ├── Kind │ ├── Type │ ├── category │ └── package.dhall ├── Optional │ ├── eq │ ├── functor │ │ ├── compactable │ │ ├── endo │ │ │ ├── package.dhall │ │ │ └── star │ │ ├── monoidal │ │ └── package.dhall │ ├── monad │ └── package.dhall ├── Presheaf │ ├── Type │ └── package.dhall ├── Quasigroup │ ├── Kind │ ├── Type │ └── package.dhall ├── Ran │ ├── Type │ ├── functor │ ├── lift │ ├── lower │ └── package.dhall ├── Rig │ ├── Kind │ ├── Monus │ │ ├── Kind │ │ ├── Type │ │ ├── extractRig │ │ └── package.dhall │ ├── Near │ │ ├── Kind │ │ ├── Type │ │ └── package.dhall │ ├── Set │ ├── Type │ ├── extractSemiring │ ├── package.dhall │ └── terms.dhall ├── Ring │ ├── Commutative │ │ ├── Set │ │ ├── Type │ │ ├── extractRing │ │ └── package.dhall │ ├── Kind │ ├── Near │ │ ├── Kind │ │ ├── Type │ │ └── package.dhall │ ├── Ordered │ │ ├── Type │ │ ├── extractPartiallyOrderedRing │ │ └── package.dhall │ ├── PartiallyOrdered │ │ ├── Type │ │ ├── extractRing │ │ ├── extractSetRing │ │ └── package.dhall │ ├── Set │ ├── Type │ ├── extractRig │ ├── package.dhall │ ├── subtract │ └── terms.dhall ├── Rng │ ├── Kind │ ├── Type │ └── package.dhall ├── Semigroup │ ├── Commutative │ │ ├── Kind │ │ ├── Type │ │ └── package.dhall │ ├── Inverse │ │ ├── Kind │ │ ├── Type │ │ └── package.dhall │ ├── Kind │ ├── Sort │ ├── Type │ ├── functor │ ├── laws │ ├── package.dhall │ └── terms.dhall ├── Semigroupoid │ ├── Type │ └── package.dhall ├── Semilattice │ ├── Bounded │ │ ├── Kind │ │ ├── Set │ │ ├── Type │ │ └── package.dhall │ ├── Type │ └── package.dhall ├── Semiring │ ├── Kind │ ├── Near │ │ ├── Kind │ │ ├── Type │ │ └── package.dhall │ ├── Type │ ├── package.dhall │ └── terms.dhall ├── Star │ ├── Type │ ├── category │ ├── package.dhall │ └── semigroupoid ├── Text │ ├── monoid │ └── package.dhall ├── Tuple │ ├── adjunction │ ├── comonad │ ├── functor │ │ ├── endo │ │ │ ├── package.dhall │ │ │ └── star │ │ └── package.dhall │ └── package.dhall ├── Unit │ ├── eq │ ├── orderedGroup │ ├── package.dhall │ └── partiallyOrderedGroup ├── Void │ ├── eq │ ├── package.dhall │ └── semigroup ├── Yoneda │ ├── Type │ ├── functor │ │ ├── instance │ │ ├── monoidal │ │ └── package.dhall │ ├── lift │ ├── lower │ ├── monad │ └── package.dhall └── package.dhall ├── flake.lock ├── flake.nix ├── garnix.yaml ├── renovate.json └── scripts └── generate-packages /.config/git/config: -------------------------------------------------------------------------------- 1 | [blame] 2 | ignoreRevsFile = ignoreRevs 3 | -------------------------------------------------------------------------------- /.config/git/ignoreRevs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/sellout/caterwaul/6815cb0142902224e25629383c4432c7d6b212c4/.config/git/ignoreRevs -------------------------------------------------------------------------------- /.config/mustache.yaml: -------------------------------------------------------------------------------- 1 | { 2 | project: 3 | { 4 | description: 5 | "Attempting to push the limits of Dhall’s abstractions.", 6 | name: "caterwaul", 7 | repo: "sellout/caterwaul", 8 | summary: "Wailing into the primordial ooze of category theory", 9 | version: "0.1.0", 10 | }, 11 | type: { name: "dhall" }, 12 | } 13 | -------------------------------------------------------------------------------- /.dir-locals.el: -------------------------------------------------------------------------------- 1 | ((nil 2 | (fill-column . 80) 3 | (indent-tabs-mode . nil) 4 | (projectile-project-configure-cmd . "nix flake update") 5 | (sentence-end-double-space . nil)) 6 | ("dhall" 7 | ;; These files generally don’t have an extension 8 | (mode . dhall))) 9 | -------------------------------------------------------------------------------- /.editorconfig: -------------------------------------------------------------------------------- 1 | ### This configures basic cross-editor formatting. 2 | ### 3 | ### See https://editorconfig.org/ for more info, and to see if your editor 4 | ### requires a plugin to take advantage of it. 5 | 6 | root = true 7 | 8 | [*] 9 | charset = utf-8 10 | end_of_line = lf 11 | indent_size = 2 12 | indent_style = space 13 | insert_final_newline = true 14 | trim_trailing_whitespace = true 15 | ## for shfmt 16 | binary_next_line = true 17 | space_redirects = true 18 | switch_case_indent = true 19 | 20 | [*.{diff,patch}] 21 | trim_trailing_whitespace = false 22 | 23 | [*.{el,lisp}] 24 | ## Lisps have a fairly consistent indentation style that doesn’t collapse well 25 | ## to a single value, so we let the editor do what it wants here. 26 | indent_size = unset 27 | -------------------------------------------------------------------------------- /.envrc: -------------------------------------------------------------------------------- 1 | use flake 2 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | * linguist-language=Dhall 2 | 3 | # The rest of this is just un-Dhalling the other bits of the repo. 4 | .* -linguist-language 5 | LICENSE -linguist-language 6 | README.md -linguist-language 7 | docs/* -linguist-language 8 | scripts/* -linguist-language 9 | shell.nix -linguist-language 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /.direnv/ 2 | 3 | # Nix build 4 | /result 5 | /source 6 | -------------------------------------------------------------------------------- /.shellcheckrc: -------------------------------------------------------------------------------- 1 | ## -*- mode: sh -*- 2 | 3 | # Unicode quotes are good, and Shellcheck gets this wrong a lot. 4 | disable=SC1111,SC1112 5 | -------------------------------------------------------------------------------- /dhall/Adjunction/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Category = ../Category/Kind cat 4 | 5 | let vObject = Type 6 | 7 | in λ(cObject : Kind) → 8 | λ(dObject : Kind) → 9 | λ(v : Category Type vObject) → 10 | λ(c : Category vObject cObject) → 11 | λ(d : Category vObject dObject) → 12 | λ(f : cat.arrow dObject cObject) → 13 | λ(g : cat.arrow cObject dObject) → 14 | { unit : ∀(a : dObject) → d.arrow { _1 = a, _2 = g (f a) } 15 | , counit : ∀(a : cObject) → c.arrow { _1 = f (g a), _2 = a } 16 | , leftAdjunct : 17 | ∀(a : dObject) → 18 | ∀(b : cObject) → 19 | v.arrow 20 | { _1 = c.arrow { _1 = f a, _2 = b } 21 | , _2 = d.arrow { _1 = a, _2 = g b } 22 | } 23 | , rightAdjunct : 24 | ∀(a : dObject) → 25 | ∀(b : cObject) → 26 | v.arrow 27 | { _1 = d.arrow { _1 = a, _2 = g b } 28 | , _2 = c.arrow { _1 = f a, _2 = b } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /dhall/Adjunction/impliedComonad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Functor = ../Functor/Type 4 | 5 | let Adjunction = ./Type 6 | 7 | let Comonad = ../Comonad/Type 8 | 9 | let Compose = ../Compose/Type 10 | 11 | let vObject = Type 12 | 13 | let v = 14 | ../Category/Monoidal/Cartesian/extractCategory 15 | cat 16 | Type 17 | vObject 18 | ../Category/Set/monoidal/cartesian 19 | 20 | let Category = ../Category/Kind cat vObject 21 | 22 | in λ(cObject : Kind) → 23 | λ(dObject : Kind) → 24 | λ(c : Category cObject) → 25 | λ(d : Category dObject) → 26 | λ(f : cat.arrow dObject cObject) → 27 | λ(functor : Functor vObject dObject cObject v d c f) → 28 | λ(g : cat.arrow cObject dObject) → 29 | λ(adjunction : Adjunction cObject dObject v c d f g) → 30 | { unit = adjunction.counit 31 | , product = 32 | λ(a : cObject) → 33 | functor.map (g a) (g (f (g a))) (adjunction.unit (g a)) 34 | } 35 | : Comonad cObject c (Compose cObject dObject cObject { _1 = f, _2 = g }) 36 | -------------------------------------------------------------------------------- /dhall/Adjunction/impliedMonad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Functor = ../Functor/Type 4 | 5 | let Adjunction = ./Type 6 | 7 | let Monad = ../Monad/Type 8 | 9 | let Compose = ../Compose/Type 10 | 11 | let vObject = Type 12 | 13 | let v = 14 | ../Category/Monoidal/Cartesian/extractCategory 15 | cat 16 | Type 17 | vObject 18 | ../Category/Set/monoidal/cartesian 19 | 20 | let Category = ../Category/Kind cat vObject 21 | 22 | in λ(cObject : Kind) → 23 | λ(dObject : Kind) → 24 | λ(c : Category cObject) → 25 | λ(d : Category dObject) → 26 | λ(f : cat.arrow dObject cObject) → 27 | λ(g : cat.arrow cObject dObject) → 28 | λ(functor : Functor vObject cObject dObject v c d g) → 29 | λ(adjunction : Adjunction cObject dObject v c d f g) → 30 | { unit = adjunction.unit 31 | , product = 32 | λ(a : dObject) → 33 | functor.map (f (g (f a))) (f a) (adjunction.counit (f a)) 34 | } 35 | : Monad dObject d (Compose dObject cObject dObject { _1 = g, _2 = f }) 36 | -------------------------------------------------------------------------------- /dhall/Adjunction/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , impliedComonad = ./impliedComonad 3 | , impliedMonad = ./impliedMonad 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Bimonad/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Category/Kind kCat Type vObject) → 7 | λ(cat : ../Category/Kind kCat vObject object) → 8 | ../Bimonoid/Type 9 | (kCat.arrow object object) 10 | (../Category/Endofunctor/monoidal/monadic object v cat) 11 | -------------------------------------------------------------------------------- /dhall/Bimonad/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Bimonoid/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { monoid : ../Monoid/Type object cat m 9 | , comonoid : ../Comonoid/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Bimonoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Bool/commutativeRing: -------------------------------------------------------------------------------- 1 | { additive = 2 | { unit = λ(_ : {}) → False 3 | , product = λ(p : { _1 : Bool, _2 : Bool }) → p._1 != p._2 4 | , inverse = λ(a : Bool) → a == False 5 | , le = λ(a : Bool) → λ(b : Bool) → if a == False then True else b 6 | } 7 | , multiplicative = 8 | { unit = λ(_ : {}) → True 9 | , product = λ(p : { _1 : Bool, _2 : Bool }) → p._1 && p._2 10 | , le = λ(a : Bool) → λ(b : Bool) → if b == False then True else a 11 | } 12 | } 13 | : ../Ring/Commutative/Set Bool 14 | -------------------------------------------------------------------------------- /dhall/Bool/complementedLattice: -------------------------------------------------------------------------------- 1 | { join = 2 | { unit = λ(_ : {}) → False 3 | , product = λ(p : { _1 : Bool, _2 : Bool }) → p._1 || p._2 4 | , le = λ(a : Bool) → λ(b : Bool) → if a == False then True else b 5 | } 6 | , meet = 7 | { unit = λ(_ : {}) → True 8 | , product = λ(p : { _1 : Bool, _2 : Bool }) → p._1 && p._2 9 | , le = λ(a : Bool) → λ(b : Bool) → if b == False then True else a 10 | } 11 | , complement = λ(a : Bool) → a == False 12 | } 13 | : ../Lattice/Complemented/Set Bool 14 | -------------------------------------------------------------------------------- /dhall/Bool/eq: -------------------------------------------------------------------------------- 1 | { eq = λ(x : Bool) → λ(y : Bool) → x == y } : ../Eq/Type Bool 2 | -------------------------------------------------------------------------------- /dhall/Bool/package.dhall: -------------------------------------------------------------------------------- 1 | { commutativeRing = ./commutativeRing 2 | , complementedLattice = ./complementedLattice 3 | , eq = ./eq 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **NB**: Can’t define `augmentation` at this level, because we have no unit 4 | `Kind`. 5 | -} 6 | λ(cat : ../Monoidal/Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | { diagonal : cat.arrow object (cat.product object object) } 10 | ⩓ ../Monoidal/Kind cat vObject object 11 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let MonoidalCategory = ../Monoidal/Kind kCat 4 | 5 | let base = ../Monoidal/extractCategory kCat 6 | 7 | let vObject = Type 8 | 9 | in λ(object : Kind) → 10 | λ(v : MonoidalCategory Type vObject) → 11 | λ(cat : MonoidalCategory vObject object) → 12 | λ(m : object) → 13 | { category : ../Type object v (base vObject object cat) } 14 | ⩓ ../../Bimonoid/Type object cat m 15 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/extractCategory: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: Should be able to do `cartesian.{ arrow, product }`, but Dhall 4 | doesn’t like that for some reason. 5 | -} 6 | λ(cat : ../Monoidal/Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(cartesian : ./Kind cat vObject object) → 10 | { constraint = cartesian.constraint, arrow = cartesian.arrow } 11 | : ../Kind cat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/impliedBimonoid: -------------------------------------------------------------------------------- 1 | {-| 2 | Every monoid in a cartesian category is a bimonoid in a unique way. 3 | -} 4 | let kCat = ../Cat/semigroupal 5 | 6 | let Bimonoid = ../../Bimonoid/Type 7 | 8 | let CartesianCategory = ./Type 9 | 10 | let Monoid = ../../Monoid/Type 11 | 12 | let MonoidalCategory = ../Monoidal/Kind kCat 13 | 14 | let vObject = Type 15 | 16 | in λ(object : Kind) → 17 | λ(v : MonoidalCategory Type vObject) → 18 | λ(cat : MonoidalCategory vObject object) → 19 | λ(m : object) → 20 | λ(cartesian : CartesianCategory object v cat m) → 21 | λ(monoid : Monoid object cat m) → 22 | { monoid, comonoid = cartesian.comonoid } : Bimonoid object cat m 23 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/impliedHopfMonoid: -------------------------------------------------------------------------------- 1 | {-| 2 | Every group in a cartesian category is a Hopf monoid in a unique way. 3 | -} 4 | let kCat = ../../Category/Cat/semigroupal 5 | 6 | let CartesianCategory = ./Type 7 | 8 | let Group = ../../Group/Type 9 | 10 | let extractMonoid = ../../Group/extractMonoid 11 | 12 | let HopfMonoid = ../../Monoid/Hopf/Type 13 | 14 | let MonoidalCategory = ../Monoidal/Kind kCat 15 | 16 | let vObject = Type 17 | 18 | in λ(object : Kind) → 19 | λ(v : MonoidalCategory Type vObject) → 20 | λ(cat : MonoidalCategory vObject object) → 21 | λ(m : object) → 22 | λ(cartesian : CartesianCategory object v cat m) → 23 | λ(group : Group object cat m) → 24 | { antipode = group.inverse } 25 | ∧ ./impliedBimonoid 26 | object 27 | v 28 | cat 29 | m 30 | cartesian 31 | (extractMonoid object cat m group) 32 | : HopfMonoid object cat m 33 | -------------------------------------------------------------------------------- /dhall/Category/Cartesian/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , extractCategory = ./extractCategory 4 | , impliedBimonoid = ./impliedBimonoid 5 | , impliedHopfMonoid = ./impliedHopfMonoid 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Category/Cat/package.dhall: -------------------------------------------------------------------------------- 1 | { semigroupal = ./semigroupal } 2 | -------------------------------------------------------------------------------- /dhall/Category/Cat/semigroupal: -------------------------------------------------------------------------------- 1 | { arrow = λ(a : Kind) → λ(b : Kind) → a → b 2 | , product = λ(a : Kind) → λ(b : Kind) → { _1 : a, _2 : b } 3 | } 4 | : ../Semigroupal/Sort 5 | -------------------------------------------------------------------------------- /dhall/Category/Closed/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | A category enriched over itself. 3 | -} 4 | λ(cat : ../Semigroupal/Sort) → λ(object : Kind) → ../Kind cat object object 5 | -------------------------------------------------------------------------------- /dhall/Category/Closed/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind } 2 | -------------------------------------------------------------------------------- /dhall/Category/Dagger/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | A true †-category has a contravariant endofunctor on C that reverses the 3 | morphisms. I’m not sure how to implement that, so this structure simply uses 4 | pairs of morphisms as the morphism. 5 | -} 6 | let kCat = ../Cat/semigroupal 7 | 8 | let vObject = Type 9 | 10 | in λ(object : Kind) → 11 | λ(cat : ../Kind kCat vObject object) → 12 | { constraint = cat.constraint 13 | , arrow = ../../Isomorphism/Type object cat 14 | } 15 | : ../Kind kCat vObject object 16 | -------------------------------------------------------------------------------- /dhall/Category/Dagger/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, category = ./category } 2 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | ../Kind cat vObject object ⩓ ../../Duoid/Kind cat object 5 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/Sort: -------------------------------------------------------------------------------- 1 | ../Sort ⩓ { diamond : ../../Monoid/Sort, star : ../../Monoid/Sort } 2 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/extractCategory: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | **FIXME**: Should be able to do `duoidal.{ arrow, product }`, but Dhall doesn’t 4 | like that for some reason. 5 | -} 6 | λ(cat : ../Monoidal/Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(duoidal : ./Kind cat vObject object) → 10 | { constraint = duoidal.constraint, arrow = duoidal.arrow } 11 | : ../Kind cat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/extractDiamond: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(duoidal : ./Kind cat vObject object) → 5 | duoidal.diamond ∧ ./extractCategory cat vObject object duoidal 6 | : ../Monoidal/Kind cat vObject object 7 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/extractStar: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(duoidal : ./Kind cat vObject object) → 5 | duoidal.star ∧ ./extractCategory cat vObject object duoidal 6 | : ../Monoidal/Kind cat vObject object 7 | -------------------------------------------------------------------------------- /dhall/Category/Duoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , extractCategory = ./extractCategory 4 | , extractDiamond = ./extractDiamond 5 | , extractStar = ./extractStar 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Category/Endofunctor/duoidal: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **NB**: This is defined in terms of the monoidal categories instead of the other 4 | way around because this is more restrictive than either monoidal category. 5 | - Applicative requires that the target category is **Set** and 6 | - monadic requires an endofunctor`object`. 7 | 8 | When you combine these two restrictions, you end up only being able to support 9 | endofunctors in **Set**. 10 | -} 11 | let kCat = ../Cat/semigroupal 12 | 13 | let vObject = Type 14 | 15 | let object = Type 16 | 17 | in λ(v : ../../Category/Kind kCat Type vObject) → 18 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 19 | let applicative = ../Functor/monoidal object v cat cat 20 | 21 | let monadic = 22 | ./monoidal/monadic 23 | object 24 | v 25 | (../../Category/Monoidal/extractCategory kCat vObject object cat) 26 | 27 | in { constraint = monadic.constraint 28 | , arrow = applicative.arrow 29 | , diamond = 30 | { unit = applicative.unit, product = applicative.product } 31 | , star = { unit = monadic.unit, product = monadic.product } 32 | } 33 | : ../Duoidal/Kind kCat vObject (kCat.arrow object object) 34 | -------------------------------------------------------------------------------- /dhall/Category/Endofunctor/monoidal/functor: -------------------------------------------------------------------------------- 1 | let kCat = ../../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | in λ(v : ../../Kind kCat Type vObject) → 8 | λ(cat : ../../Monoidal/Kind kCat vObject object) → 9 | ../../Duoidal/extractDiamond 10 | kCat 11 | vObject 12 | (kCat.arrow object object) 13 | (../duoidal v cat) 14 | -------------------------------------------------------------------------------- /dhall/Category/Endofunctor/monoidal/monadic: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **NB**: This doesn’t use `Duoidal/extractMultiplicative` because that has a 4 | fixed `object`. 5 | -} 6 | let kCat = ../../Cat/semigroupal 7 | 8 | let Endofunctor = ../../../Functor/Endo/Type 9 | 10 | let Category = ../../Kind kCat 11 | 12 | let vObject = Type 13 | 14 | in λ(object : Kind) → 15 | λ(v : Category Type vObject) → 16 | λ(cat : Category vObject object) → 17 | { constraint = Endofunctor vObject object v cat 18 | , arrow = ../../../NaturalTransformation/Type object object cat 19 | , unit = ../../../Identity/Type object 20 | , product = ../../../Compose/Type object object object 21 | } 22 | : ../../Monoidal/Kind kCat vObject (kCat.arrow object object) 23 | -------------------------------------------------------------------------------- /dhall/Category/Endofunctor/monoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { functor = ./functor, monadic = ./monadic } 2 | -------------------------------------------------------------------------------- /dhall/Category/Endofunctor/package.dhall: -------------------------------------------------------------------------------- 1 | { duoidal = ./duoidal, monoidal = ./monoidal/package.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Category/Functor/category: -------------------------------------------------------------------------------- 1 | {-| 2 | This cheats a bit on the unit, since `dObject` is Type, we don’t need a functor 3 | **Set** → 𝒟. 4 | -} 5 | let cat = ../../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let Category = ../Kind cat 10 | 11 | in λ(cObject : Kind) → 12 | λ(dObject : Kind) → 13 | λ(v : Category Type vObject) → 14 | λ(c : Category vObject cObject) → 15 | λ(d : Category vObject dObject) → 16 | { constraint = ../../Functor/Type vObject cObject dObject v c d 17 | , arrow = ../../NaturalTransformation/Type cObject dObject d 18 | } 19 | : Category vObject (cat.arrow cObject dObject) 20 | -------------------------------------------------------------------------------- /dhall/Category/Functor/liftedMonoidal: -------------------------------------------------------------------------------- 1 | {-| 2 | For any monoidal category 𝒞, any 𝒞-valued functor category is monoidal in the 3 | same way by “lifting” the monoidal structure of 𝒞. 4 | -} 5 | let cat = ../Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let Category = ../Kind cat 10 | 11 | let MonoidalCategory = ../Monoidal/Kind cat 12 | 13 | in λ(cObject : Kind) → 14 | let dObject = Type 15 | 16 | in λ(v : Category Type vObject) → 17 | λ(c : Category vObject cObject) → 18 | λ(d : MonoidalCategory vObject dObject) → 19 | let base = ../Monoidal/extractCategory cat vObject 20 | 21 | let object = cat.arrow cObject dObject 22 | 23 | in { unit = 24 | λ(x : cObject) → 25 | ../../Functor/Constant/Type 26 | dObject 27 | cObject 28 | { _1 = d.unit, _2 = x } 29 | , product = 30 | λ(f : { _1 : object, _2 : object }) → 31 | λ(x : cObject) → 32 | d.product { _1 = f._1 x, _2 = f._2 x } 33 | } 34 | ∧ ./category cObject dObject v c (base dObject d) 35 | : MonoidalCategory vObject object 36 | -------------------------------------------------------------------------------- /dhall/Category/Functor/monoidal: -------------------------------------------------------------------------------- 1 | {-| 2 | This cheats a bit on the unit, since `dObject` is Type, we don’t need a functor 3 | **Set** → 𝒟. 4 | -} 5 | let cat = ../../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let MonoidalCategory = ../Monoidal/Kind cat vObject 10 | 11 | in λ(cObject : Kind) → 12 | let dObject = Type 13 | 14 | in λ(v : ../Kind cat Type vObject) → 15 | λ(c : MonoidalCategory cObject) → 16 | λ(d : MonoidalCategory dObject) → 17 | let base = ../Monoidal/extractCategory cat vObject 18 | 19 | in { unit = λ(x : cObject) → c.arrow { _1 = c.unit, _2 = x } 20 | , product = ../../Day/Type cObject d c 21 | } 22 | ∧ ./category 23 | cObject 24 | dObject 25 | v 26 | (base cObject c) 27 | (base dObject d) 28 | : MonoidalCategory (cat.arrow cObject dObject) 29 | -------------------------------------------------------------------------------- /dhall/Category/Functor/package.dhall: -------------------------------------------------------------------------------- 1 | { category = ./category 2 | , inducedFunctor = ./inducedFunctor 3 | , liftedDuoidal = ./liftedDuoidal 4 | , liftedMonoidal = ./liftedMonoidal 5 | , liftedRig = ./liftedRig 6 | , monoidal = ./monoidal 7 | , types = ./types.dhall 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Category/Functor/types.dhall: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Category = ../Kind cat 6 | 7 | let MonoidalCategory = ../Monoidal/Kind cat 8 | 9 | let base = ../Monoidal/extractCategory cat 10 | 11 | in λ(cObject : Kind) → 12 | λ(dObject : Kind) → 13 | λ(v : MonoidalCategory Type vObject) → 14 | λ(c : Category vObject cObject) → 15 | λ(d : Category vObject dObject) → 16 | ../types.dhall 17 | (cat.arrow cObject dObject) 18 | v 19 | (./category cObject dObject (base Type vObject v) c d) 20 | -------------------------------------------------------------------------------- /dhall/Category/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ./Semigroupal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | { constraint : object → Type 5 | , arrow : cat.arrow (cat.product object object) vObject 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Category/Kleisli/category: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Kind kCat vObject object) → 6 | λ(m : kCat.arrow object object) → 7 | { constraint = cat.constraint 8 | , arrow = ../../Star/Type vObject object cat m 9 | } 10 | : ../Kind kCat vObject object 11 | -------------------------------------------------------------------------------- /dhall/Category/Kleisli/package.dhall: -------------------------------------------------------------------------------- 1 | { category = ./category } 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Braided/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Kind kCat Type vObject) → 7 | λ(cat : ../Kind kCat vObject object) → 8 | { braid : 9 | ∀(x : object) → 10 | ∀(y : object) → 11 | cat.arrow 12 | { _1 = cat.product { _1 = x, _2 = y } 13 | , _2 = cat.product { _1 = y, _2 = x } 14 | } 15 | } 16 | ⩓ ../Type object v cat 17 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Braided/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Cartesian/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | Can’t define `augmentation` at this level, because we have no unit `Kind`. 3 | -} 4 | λ(cat : ../Sort) → 5 | λ(vObject : Kind) → 6 | λ(object : Kind) → 7 | { diagonal : cat.arrow object (cat.product object object) } 8 | ⩓ ../Kind cat vObject object 9 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Cartesian/extractCategory: -------------------------------------------------------------------------------- 1 | λ(cat : ../Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(cartesian : ./Kind cat vObject object) → 5 | cartesian.{ constraint, arrow } : ../../Kind cat vObject object 6 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Cartesian/extractMonoidal: -------------------------------------------------------------------------------- 1 | λ(cat : ../Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(cartesian : ./Kind cat vObject object) → 5 | cartesian.{ constraint, arrow, unit, product } : ../Kind cat vObject object 6 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Cartesian/extractSemigroupal: -------------------------------------------------------------------------------- 1 | λ(cat : ../Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(cartesian : ./Kind cat vObject object) → 5 | cartesian.{ constraint, arrow, product } 6 | : ../../Semigroupal/Kind cat vObject object 7 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Cartesian/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , extractCategory = ./extractCategory 3 | , extractMonoidal = ./extractMonoidal 4 | , extractSemigroupal = ./extractSemigroupal 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Closed/Cartesian/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Sort) → λ(object : Kind) → ../../Cartesian/Kind cat object object 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Closed/Cartesian/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind } 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Closed/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Sort) → λ(object : Kind) → ../Kind cat object object 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Closed/curry: -------------------------------------------------------------------------------- 1 | {- 2 | The currying isomorphism is defined for any closed monoidal (semigroupal?) 3 | category (semigroupoid?), based on the – ⊗ X ⊣ Hom(X, –) odjunction. 4 | 5 | **FIXME**: Because closed categories are self-enriched and `Isomorphism` 6 | currently has to be enriched by a category where the objects are types, this is 7 | currently restricted to categories where the objects are types. 8 | -} 9 | let kCat = ../../Cat/semigroupal 10 | 11 | let object = Type 12 | 13 | in λ(cat : ./Kind kCat object) → 14 | ∀(a : object) → 15 | ∀(b : object) → 16 | ∀(c : object) → 17 | ../../../Isomorphism/Type 18 | object 19 | (../extractCategory kCat object object cat) 20 | { _1 = cat.arrow { _1 = cat.product { _1 = a, _2 = b }, _2 = c } 21 | , _2 = cat.arrow { _1 = a, _2 = cat.arrow { _1 = b, _2 = c } } 22 | } 23 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Closed/package.dhall: -------------------------------------------------------------------------------- 1 | { Cartesian = ./Cartesian/package.dhall, Kind = ./Kind, curry = ./curry } 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ./Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | ../Kind cat vObject object ⩓ ../../Monoid/Kind cat object 5 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Sort: -------------------------------------------------------------------------------- 1 | ../Sort ⩓ ../../Monoid/Sort 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Symmetric/Type: -------------------------------------------------------------------------------- 1 | ../Braided/Type 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Symmetric/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ./Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | let Isomorphism = 9 | ../../Isomorphism/Type 10 | object 11 | (./extractCategory kCat vObject object cat) 12 | 13 | in { leftIdentity : 14 | ∀(a : object) → 15 | Isomorphism 16 | { _1 = cat.product { _1 = cat.unit, _2 = a }, _2 = a } 17 | , rightIdentity : 18 | ∀(a : object) → 19 | Isomorphism 20 | { _1 = cat.product { _1 = a, _2 = cat.unit }, _2 = a } 21 | } 22 | ⩓ ../Semigroupal/Type 23 | object 24 | v 25 | (./extractSemigroupal kCat vObject object cat) 26 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/extractCategory: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: Should be able to do `monoidal.{ arrow, product }`, but Dhall doesn’t 4 | like that for some reason. 5 | -} 6 | λ(cat : ./Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(monoidal : ./Kind cat vObject object) → 10 | { constraint = monoidal.constraint, arrow = monoidal.arrow } 11 | : ../Kind cat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/extractCategoryInstance: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | λ(category : ./Type object v cat) → 9 | category.{ unit, product, hom } 10 | : ../Type object v (./extractCategory kCat vObject object cat) 11 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/extractSemigroupal: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: Should be able to do `monoidal.{ arrow, product }`, but Dhall doesn’t 4 | like that for some reason. 5 | -} 6 | λ(cat : ./Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(monoidal : ./Kind cat vObject object) → 10 | { constraint = monoidal.constraint 11 | , arrow = monoidal.arrow 12 | , product = monoidal.product 13 | } 14 | : ../Semigroupal/Kind cat vObject object 15 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { Braided = ./Braided/package.dhall 2 | , Cartesian = ./Cartesian/package.dhall 3 | , Closed = ./Closed/package.dhall 4 | , Kind = ./Kind 5 | , Symmetric = ./Symmetric/package.dhall 6 | , Type = ./Type 7 | , extractCategory = ./extractCategory 8 | , extractCategoryInstance = ./extractCategoryInstance 9 | , extractSemigroupal = ./extractSemigroupal 10 | , types = ./types.dhall 11 | } 12 | -------------------------------------------------------------------------------- /dhall/Category/Monoidal/types.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ./Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | let Set = 9 | ./Cartesian/extractMonoidal 10 | kCat 11 | vObject 12 | Type 13 | ../Set/monoidal/cartesian 14 | 15 | let vBase = ./extractCategory kCat Type vObject v 16 | 17 | in { CommutativeGroup = ../../Group/Commutative/Type object cat 18 | , CommutativeMonoid = ../../Monoid/Commutative/Type object cat 19 | , Day = ../../Day/Type object Set cat 20 | , Field = ../../Field/Type object cat 21 | , Group = ../../Group/Type object cat 22 | , Monoid = ../../Monoid/Type object cat 23 | , MonoidalFunctor = ../../Functor/Monoidal/Type object vBase cat Set 24 | , Rig = ../../Rig/Type object cat 25 | , Ring = ../../Ring/Type object cat 26 | , Semiring = ../../Semiring/Type object cat 27 | , StrongFunctor = ../../Functor/Strong/Type object vBase cat 28 | } 29 | ∧ ../Semigroupal/types.dhall 30 | object 31 | v 32 | (./extractSemigroupal kCat vObject object cat) 33 | -------------------------------------------------------------------------------- /dhall/Category/Op/Kind: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Kind kCat vObject object) → 6 | { constraint = cat.constraint 7 | , arrow = 8 | λ(a : { _1 : object, _2 : object }) → 9 | cat.arrow { _1 = a._2, _2 = a._1 } 10 | } 11 | : ../Kind kCat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Op/categorySort: -------------------------------------------------------------------------------- 1 | λ(cat : ../Sort) → 2 | { arrow = λ(a : Kind) → λ(b : Kind) → cat.arrow b a } : ../Sort 3 | -------------------------------------------------------------------------------- /dhall/Category/Op/duoidal: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Duoidal/Kind kCat vObject object) → 6 | { diamond = cat.diamond, star = cat.star } 7 | ∧ ./Kind 8 | vObject 9 | object 10 | (../Duoidal/extractCategory kCat vObject object cat) 11 | : ../Duoidal/Kind kCat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Op/monoidal: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Monoidal/Kind kCat vObject object) → 6 | { unit = cat.unit } 7 | ∧ ./semigroupal 8 | vObject 9 | object 10 | (../Monoidal/extractSemigroupal kCat vObject object cat) 11 | : ../Monoidal/Kind kCat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Op/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , category = ./category 3 | , categorySort = ./categorySort 4 | , duoidal = ./duoidal 5 | , monoidal = ./monoidal 6 | , semigroupal = ./semigroupal 7 | , semigroupalSort = ./semigroupalSort 8 | , types = ./types.dhall 9 | } 10 | -------------------------------------------------------------------------------- /dhall/Category/Op/semigroupal: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Semigroupal/Kind kCat vObject object) → 6 | { product = cat.product } 7 | ∧ ./Kind 8 | vObject 9 | object 10 | (../../Category/Semigroupal/extractCategory kCat vObject object cat) 11 | : ../Semigroupal/Kind kCat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Op/semigroupalSort: -------------------------------------------------------------------------------- 1 | λ(cat : ../Semigroupal/Sort) → 2 | { arrow = λ(a : Kind) → λ(b : Kind) → cat.arrow b a, product = cat.product } 3 | : ../Semigroupal/Sort 4 | -------------------------------------------------------------------------------- /dhall/Category/Op/types.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let MonoidalCategory = ../Monoidal/Kind kCat 4 | 5 | let vObject = Type 6 | 7 | in λ(object : Kind) → 8 | λ(v : MonoidalCategory Type vObject) → 9 | λ(cat : MonoidalCategory vObject object) → 10 | ../Monoidal/types.dhall object v (./monoidal vObject object cat) 11 | -------------------------------------------------------------------------------- /dhall/Category/Product/Kind: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Category = ../Kind cat vObject 6 | 7 | in λ(cObject : Kind) → 8 | λ(dObject : Kind) → 9 | λ(v : ../Semigroupal/Kind cat Type vObject) → 10 | λ(c : Category cObject) → 11 | λ(d : Category dObject) → 12 | let object = cat.product cObject dObject 13 | 14 | in { constraint = 15 | λ(x : object) → 16 | { _1 : c.constraint x._1, _2 : d.constraint x._2 } 17 | , arrow = 18 | λ(a : cat.product object object) → 19 | v.product 20 | { _1 = c.arrow { _1 = a._1._1, _2 = a._2._1 } 21 | , _2 = d.arrow { _1 = a._1._2, _2 = a._2._2 } 22 | } 23 | } 24 | : Category object 25 | -------------------------------------------------------------------------------- /dhall/Category/Product/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let Category = ../Kind cat 4 | 5 | let MonoidalCategory = ../Monoidal/Kind cat 6 | 7 | in λ(vObject : Kind) → 8 | λ(cObject : Kind) → 9 | λ(dObject : Kind) → 10 | λ(v : MonoidalCategory Type vObject) → 11 | λ(c : Category vObject cObject) → 12 | λ(d : Category vObject dObject) → 13 | let object = { _1 : cObject, _2 : dObject } 14 | 15 | in { constraint = 16 | λ(obj : object) → 17 | { _1 : c.constraint obj._1, _2 : d.constraint obj._2 } 18 | , arrow = 19 | λ(a : { _1 : object, _2 : object }) → 20 | v.product 21 | { _1 = c.arrow { _1 = a._1._1, _2 = a._2._1 } 22 | , _2 = d.arrow { _1 = a._1._2, _2 = a._2._2 } 23 | } 24 | } 25 | : Category vObject object 26 | -------------------------------------------------------------------------------- /dhall/Category/Product/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type, category = ./category, types = ./types.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Category/Product/types.dhall: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Category = ../Kind cat 6 | 7 | let MonoidalCategory = ../Monoidal/Kind cat 8 | 9 | in λ(cObject : Kind) → 10 | λ(dObject : Kind) → 11 | λ(v : MonoidalCategory Type vObject) → 12 | λ(c : Category vObject cObject) → 13 | λ(d : Category vObject dObject) → 14 | ../types.dhall 15 | { _1 : cObject, _2 : dObject } 16 | v 17 | ( ./Kind 18 | cObject 19 | dObject 20 | (../Monoidal/extractSemigroupal cat Type vObject v) 21 | c 22 | d 23 | ) 24 | -------------------------------------------------------------------------------- /dhall/Category/Profunctor/monoidal: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let Category = ../Kind kCat 4 | 5 | let MonoidalCategory = ../Monoidal/Kind kCat 6 | 7 | let vObject = Type 8 | 9 | in λ(object : Kind) → 10 | λ(v : MonoidalCategory Type vObject) → 11 | λ(cat : Category vObject object) → 12 | let profunctor = kCat.arrow (kCat.product object object) vObject 13 | 14 | in λ(morphism : profunctor) → 15 | { unit = morphism } ∧ ./semigroupal object v cat 16 | : MonoidalCategory vObject profunctor 17 | -------------------------------------------------------------------------------- /dhall/Category/Profunctor/package.dhall: -------------------------------------------------------------------------------- 1 | { monoidal = ./monoidal, semigroupal = ./semigroupal, types = ./types.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Category/Profunctor/semigroupal: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | This doesn’t use `extractSemigroupal` because I don’t know how to apply the 4 | `morphism` in the monoidal category instance. 5 | -} 6 | let kCat = ../../Category/Cat/semigroupal 7 | 8 | let vObject = Type 9 | 10 | in λ(object : Kind) → 11 | λ(v : ../../Category/Monoidal/Kind kCat Type vObject) → 12 | λ(cat : ../Kind kCat vObject object) → 13 | let profunctor = kCat.arrow (kCat.product object object) vObject 14 | 15 | in { constraint = ../../Functor/Profunctor/Type object object v cat cat 16 | , arrow = 17 | λ(p : { _1 : profunctor, _2 : profunctor }) → 18 | ∀(a : { _1 : object, _2 : object }) → p._1 a → p._2 a 19 | , product = 20 | λ(p : { _1 : profunctor, _2 : profunctor }) → 21 | λ(a : { _1 : object, _2 : object }) → 22 | ∀(r : Type) → 23 | ( ∀(z : object) → 24 | p._1 { _1 = z, _2 = a._2 } → 25 | p._2 { _1 = a._1, _2 = z } → 26 | r 27 | ) → 28 | r 29 | } 30 | : ../Semigroupal/Kind kCat vObject profunctor 31 | -------------------------------------------------------------------------------- /dhall/Category/Profunctor/types.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let Category = ../Kind kCat 4 | 5 | let MonoidalCategory = ../Monoidal/Kind kCat 6 | 7 | let vObject = Type 8 | 9 | in λ(object : Kind) → 10 | λ(v : MonoidalCategory Type vObject) → 11 | λ(cat : Category vObject object) → 12 | ../Semigroupal/types.dhall 13 | (kCat.arrow (kCat.product object object) vObject) 14 | v 15 | (./semigroupal object v cat) 16 | -------------------------------------------------------------------------------- /dhall/Category/Rig/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | ../Kind cat vObject object ⩓ ../../Rig/Kind cat object 5 | -------------------------------------------------------------------------------- /dhall/Category/Rig/Sort: -------------------------------------------------------------------------------- 1 | ../Sort ⩓ { additive : ../../Monoid/Sort, multiplicative : ../../Monoid/Sort } 2 | -------------------------------------------------------------------------------- /dhall/Category/Rig/extractAdditive: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(rig : ./Kind cat vObject object) → 5 | { unit = rig.additive.unit, product = rig.additive.product } 6 | ∧ ./extractCategory cat vObject object rig 7 | : ../Monoidal/Kind cat vObject object 8 | -------------------------------------------------------------------------------- /dhall/Category/Rig/extractAdditiveInstance: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | λ(rig : ./Type object v cat) → 9 | rig.additive 10 | : ../Monoidal/Type object v (./extractAdditive kCat vObject object cat) 11 | -------------------------------------------------------------------------------- /dhall/Category/Rig/extractCategory: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(rig : ./Kind cat vObject object) → 5 | { constraint = rig.constraint, arrow = rig.arrow } 6 | : ../Kind cat vObject object 7 | -------------------------------------------------------------------------------- /dhall/Category/Rig/extractMultiplicative: -------------------------------------------------------------------------------- 1 | λ(cat : ../Monoidal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | λ(rig : ./Kind cat vObject object) → 5 | { unit = rig.multiplicative.unit, product = rig.multiplicative.product } 6 | ∧ ./extractCategory cat vObject object rig 7 | : ../Monoidal/Kind cat vObject object 8 | -------------------------------------------------------------------------------- /dhall/Category/Rig/extractMultiplicativeInstance: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | λ(rig : ./Type object v cat) → 9 | rig.multiplicative 10 | : ../Monoidal/Type 11 | object 12 | v 13 | (./extractMultiplicative kCat vObject object cat) 14 | -------------------------------------------------------------------------------- /dhall/Category/Rig/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , extractAdditive = ./extractAdditive 4 | , extractAdditiveInstance = ./extractAdditiveInstance 5 | , extractCategory = ./extractCategory 6 | , extractMultiplicative = ./extractMultiplicative 7 | , extractMultiplicativeInstance = ./extractMultiplicativeInstance 8 | , separatorMonoid = ./separatorMonoid 9 | } 10 | -------------------------------------------------------------------------------- /dhall/Category/Rig/separatorMonoid: -------------------------------------------------------------------------------- 1 | {-| 2 | Every rig category has an additional family of “separator”-based monoidal 3 | structures. That is, for any object `s` there is a generalization of the 4 | additive monoidal structure: 5 | 6 | > (a ⊗ s ⊗ b) ⊕ a ⊕ b 7 | 8 | When `s` is the additive unit, this structure is isomorphic to the additive 9 | product. 10 | -} 11 | let kCat = ../Cat/semigroupal 12 | 13 | in λ(vObject : Kind) → 14 | λ(object : Kind) → 15 | λ(cat : ./Kind kCat vObject object) → 16 | λ(s : object) → 17 | let mult = cat.multiplicative.product 18 | 19 | let add = cat.additive.product 20 | 21 | in { constraint = cat.constraint 22 | , arrow = cat.arrow 23 | , product = 24 | λ(a : kCat.product object object) → 25 | add 26 | { _1 = 27 | add 28 | { _1 = 29 | mult 30 | { _1 = mult { _1 = a._1, _2 = s }, _2 = a._2 } 31 | , _2 = a._1 32 | } 33 | , _2 = a._2 34 | } 35 | , unit = cat.additive.unit 36 | } 37 | : ../Monoidal/Kind kCat vObject object 38 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Semigroupal/Sort) → 2 | λ(vObject : Kind) → 3 | λ(object : Kind) → 4 | ../Kind cat vObject object ⩓ ../../Semigroup/Kind cat object 5 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/Sort: -------------------------------------------------------------------------------- 1 | ../Sort ⩓ ../../Semigroup/Sort 2 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | let base = ./extractCategory kCat vObject object cat 9 | 10 | let Isomorphism = ../../Isomorphism/Type object base 11 | 12 | in { associativity : 13 | ∀(a : object) → 14 | ∀(b : object) → 15 | ∀(c : object) → 16 | Isomorphism 17 | { _1 = 18 | cat.product 19 | { _1 = cat.product { _1 = a, _2 = b }, _2 = c } 20 | , _2 = 21 | cat.product 22 | { _1 = a, _2 = cat.product { _1 = b, _2 = c } } 23 | } 24 | , tensor : ../../Functor/Pair/Type vObject object v base cat.product 25 | } 26 | ⩓ ../Type object v base 27 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/extractCategory: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: Should be able to do `semigroupal.{ arrow, product }`, but Dhall 4 | doesn’t like that for some reason. 5 | -} 6 | λ(cat : ./Sort) → 7 | λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(semigroupal : ./Kind cat vObject object) → 10 | { constraint = semigroupal.constraint, arrow = semigroupal.arrow } 11 | : ../Kind cat vObject object 12 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/extractCategoryInstance: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | λ(category : ./Type object v cat) → 9 | category.{ unit, product, hom } 10 | : ../Type object v (./extractCategory kCat vObject object cat) 11 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/extractCategorySort: -------------------------------------------------------------------------------- 1 | λ(semigroupal : ./Sort) → semigroupal.{ arrow } 2 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , extractCategory = ./extractCategory 4 | , extractCategoryInstance = ./extractCategoryInstance 5 | , extractCategorySort = ./extractCategorySort 6 | , types = ./types.dhall 7 | } 8 | -------------------------------------------------------------------------------- /dhall/Category/Semigroupal/types.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | { Semigroup = ../../Semigroup/Type object cat } 9 | ∧ ../types.dhall object v (./extractCategory kCat vObject object cat) 10 | -------------------------------------------------------------------------------- /dhall/Category/Set/category/instance: -------------------------------------------------------------------------------- 1 | let Cat = ../../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Monoidal/Cartesian/extractMonoidal 7 | Cat 8 | Type 9 | vObject 10 | ../monoidal/cartesian 11 | 12 | let Set = 13 | ../../Monoidal/Cartesian/extractMonoidal 14 | Cat 15 | vObject 16 | Type 17 | ../monoidal/cartesian 18 | 19 | in ../../Monoidal/extractCategoryInstance Type v Set ./monoidal 20 | -------------------------------------------------------------------------------- /dhall/Category/Set/category/monoidal: -------------------------------------------------------------------------------- 1 | let Cat = ../../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Monoidal/Cartesian/extractMonoidal 7 | Cat 8 | Type 9 | vObject 10 | ../monoidal/cartesian 11 | 12 | in ../../Rig/extractMultiplicativeInstance Type v ../rig ./rig 13 | -------------------------------------------------------------------------------- /dhall/Category/Set/category/package.dhall: -------------------------------------------------------------------------------- 1 | { instance = ./instance, monoidal = ./monoidal, rig = ./rig } 2 | -------------------------------------------------------------------------------- /dhall/Category/Set/comonoid: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ./monoidal/cartesian 11 | 12 | in λ(a : Type) → 13 | { unit = λ(_ : a) → {=}, product = λ(x : a) → { _1 = x, _2 = x } } 14 | : ../../Comonoid/Type Type Set a 15 | -------------------------------------------------------------------------------- /dhall/Category/Set/curry: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let Set = ./monoidal/cartesian 4 | 5 | in ( λ(a : Type) → 6 | λ(b : Type) → 7 | λ(c : Type) → 8 | { to = 9 | λ(f : Set.arrow { _1 = Set.product { _1 = a, _2 = b }, _2 = c }) → 10 | λ(x : a) → 11 | λ(y : b) → 12 | f { _1 = x, _2 = y } 13 | , from = 14 | λ(f : Set.arrow { _1 = a, _2 = Set.arrow { _1 = b, _2 = c } }) → 15 | λ(p : Set.product { _1 = a, _2 = b }) → 16 | f p._1 p._2 17 | } 18 | ) 19 | : ../Monoidal/Closed/curry 20 | (../Monoidal/Cartesian/extractMonoidal cat Type Type Set) 21 | -------------------------------------------------------------------------------- /dhall/Category/Set/monoidal/cartesian: -------------------------------------------------------------------------------- 1 | let cat = ../../Cat/semigroupal 2 | 3 | in { diagonal = λ(a : Type) → { _1 = a, _2 = a } } 4 | ∧ ../../Rig/extractMultiplicative cat Type Type ../rig 5 | : ../../../Category/Monoidal/Closed/Cartesian/Kind cat Type 6 | -------------------------------------------------------------------------------- /dhall/Category/Set/monoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { cartesian = ./cartesian } 2 | -------------------------------------------------------------------------------- /dhall/Category/Set/package.dhall: -------------------------------------------------------------------------------- 1 | { category = ./category/package.dhall 2 | , comonoid = ./comonoid 3 | , curry = ./curry 4 | , monoidal = ./monoidal/package.dhall 5 | , rig = ./rig 6 | , semigroupoid = ./semigroupoid 7 | , types = ./types.dhall 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Category/Set/rig: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in { constraint = 6 | λ(t : Type) → 7 | ../../Functor/Constant/Type Type Type { _1 = {}, _2 = t } 8 | , arrow = λ(a : { _1 : Type, _2 : Type }) → a._1 → a._2 9 | , additive = 10 | { unit = <> 11 | , product = 12 | λ(a : { _1 : Type, _2 : Type }) → < Left : a._1 | Right : a._2 > 13 | } 14 | , multiplicative = 15 | { unit = {} 16 | , product = λ(a : { _1 : Type, _2 : Type }) → { _1 : a._1, _2 : a._2 } 17 | } 18 | } 19 | : ../Rig/Kind cat vObject Type 20 | -------------------------------------------------------------------------------- /dhall/Category/Set/semigroupoid: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ./monoidal/cartesian 11 | 12 | let Set = 13 | ../Monoidal/Cartesian/extractMonoidal 14 | cat 15 | vObject 16 | Type 17 | ./monoidal/cartesian 18 | 19 | in ../../Category/extractSemigroupoid 20 | Type 21 | v 22 | (../Monoidal/extractCategory cat vObject Type Set) 23 | ( ../../Category/Monoidal/extractCategoryInstance 24 | Type 25 | v 26 | Set 27 | ( ../../Category/Rig/extractMultiplicativeInstance 28 | Type 29 | v 30 | ./rig 31 | ./category/rig 32 | ) 33 | ) 34 | -------------------------------------------------------------------------------- /dhall/Category/Set/types.dhall: -------------------------------------------------------------------------------- 1 | let cat = ../Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(v : ../Monoidal/Kind cat Type vObject) → 6 | let Set = 7 | ../Monoidal/Cartesian/extractMonoidal 8 | cat 9 | vObject 10 | Type 11 | ./monoidal/cartesian 12 | 13 | in { Eq = ../../Eq/Type 14 | , OrderedField = ../../Field/Ordered/Type 15 | , OrderedGroup = ../../Group/Ordered/Type 16 | , OrderedRing = ../../Ring/Ordered/Type 17 | , PartiallyOrderedField = ../../Field/PartiallyOrdered/Type 18 | , PartiallyOrderedGroup = ../../Group/PartiallyOrdered/Type 19 | , PartiallyOrderedRing = ../../Ring/PartiallyOrdered/Type 20 | } 21 | ∧ ../Monoidal/types.dhall Type v Set 22 | -------------------------------------------------------------------------------- /dhall/Category/Sort: -------------------------------------------------------------------------------- 1 | let object = Kind let vObject = Kind in { arrow : object → object → vObject } 2 | -------------------------------------------------------------------------------- /dhall/Category/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: This should use `./../Monoid/Type … 4 | (./../Category/Monoidal/Profunctor object morphism)`, but the unit in that 5 | monoidal category definition isn’t correct (or, if it is, I can’t figure out how 6 | to use it). So instead, we just build the `Semigroup`, and then write a custom 7 | unit. But this means we’re not structurally a `Monoid`. 8 | -} 9 | let kCat = ./Cat/semigroupal 10 | 11 | let vObject = Type 12 | 13 | in λ(object : Kind) → 14 | λ(v : ./Monoidal/Kind kCat Type vObject) → 15 | λ(cat : ./Kind kCat vObject object) → 16 | { unit : ∀(a : object) → cat.arrow { _1 = a, _2 = a } } 17 | ⩓ ../Semigroupoid/Type object v cat cat.arrow 18 | -------------------------------------------------------------------------------- /dhall/Category/extractSemigroupoid: -------------------------------------------------------------------------------- 1 | let kCat = ./Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ./Monoidal/Kind kCat Type vObject) → 7 | λ(cat : ./Kind kCat vObject object) → 8 | λ(category : ./Type object v cat) → 9 | category.{ product, hom } : ../Semigroupoid/Type object v cat cat.arrow 10 | -------------------------------------------------------------------------------- /dhall/Category/package.dhall: -------------------------------------------------------------------------------- 1 | { Cartesian = ./Cartesian/package.dhall 2 | , Cat = ./Cat/package.dhall 3 | , Closed = ./Closed/package.dhall 4 | , Dagger = ./Dagger/package.dhall 5 | , Duoidal = ./Duoidal/package.dhall 6 | , Endofunctor = ./Endofunctor/package.dhall 7 | , Functor = ./Functor/package.dhall 8 | , Kind = ./Kind 9 | , Kleisli = ./Kleisli/package.dhall 10 | , Monoidal = ./Monoidal/package.dhall 11 | , Op = ./Op/package.dhall 12 | , Product = ./Product/package.dhall 13 | , Profunctor = ./Profunctor/package.dhall 14 | , Rig = ./Rig/package.dhall 15 | , Semigroupal = ./Semigroupal/package.dhall 16 | , Set = ./Set/package.dhall 17 | , Type = ./Type 18 | , extractSemigroupoid = ./extractSemigroupoid 19 | , postcomposition = ./postcomposition 20 | , precomposition = ./precomposition 21 | , types = ./types.dhall 22 | } 23 | -------------------------------------------------------------------------------- /dhall/Category/postcomposition: -------------------------------------------------------------------------------- 1 | let kCat = ./Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ./Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ./Set/monoidal/cartesian 11 | 12 | let vBase = ./Monoidal/extractCategory kCat Type vObject v 13 | 14 | in λ(object : Kind) → 15 | λ(cat : ./Kind kCat vObject object) → 16 | λ(category : ./Type object v cat) → 17 | λ(c : object) → 18 | { map = 19 | λ(x : object) → 20 | λ(y : object) → 21 | λ(fn : cat.arrow { _1 = x, _2 = y }) → 22 | λ(input : cat.arrow { _1 = c, _2 = x }) → 23 | category.product 24 | { _1 = c, _2 = y } 25 | ( λ(r : Type) → 26 | λ ( arrowsOut 27 | : ∀(z : object) → 28 | cat.arrow { _1 = z, _2 = y } → 29 | cat.arrow { _1 = c, _2 = z } → 30 | r 31 | ) → 32 | arrowsOut x fn input 33 | ) 34 | } 35 | : ../Functor/Type 36 | vObject 37 | object 38 | vObject 39 | vBase 40 | cat 41 | vBase 42 | (λ(x : object) → cat.arrow { _1 = c, _2 = x }) 43 | -------------------------------------------------------------------------------- /dhall/Category/precomposition: -------------------------------------------------------------------------------- 1 | let kCat = ./Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ./Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ./Set/monoidal/cartesian 11 | 12 | let vBase = ./Monoidal/extractCategory kCat Type vObject v 13 | 14 | in λ(object : Kind) → 15 | λ(cat : ./Kind kCat vObject object) → 16 | λ(category : ./Type object v cat) → 17 | λ(c : object) → 18 | { map = 19 | λ(x : object) → 20 | λ(y : object) → 21 | λ(fn : cat.arrow { _1 = y, _2 = x }) → 22 | λ(input : cat.arrow { _1 = x, _2 = c }) → 23 | category.product 24 | { _1 = y, _2 = c } 25 | ( λ(r : Type) → 26 | λ ( arrowsOut 27 | : ∀(z : object) → 28 | cat.arrow { _1 = z, _2 = c } → 29 | cat.arrow { _1 = y, _2 = z } → 30 | r 31 | ) → 32 | arrowsOut x input fn 33 | ) 34 | } 35 | : ../Functor/Contravariant 36 | vObject 37 | object 38 | vObject 39 | vBase 40 | cat 41 | vBase 42 | (λ(x : object) → cat.arrow { _1 = x, _2 = c }) 43 | -------------------------------------------------------------------------------- /dhall/Codensity/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(cObject : Kind) → 6 | let dObject = Type 7 | 8 | in λ(d : ../Category/Kind cat vObject dObject) → 9 | λ(m : cat.arrow cObject dObject) → 10 | ../Ran/Type cObject dObject d m m 11 | -------------------------------------------------------------------------------- /dhall/Codensity/functor/endo: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let monoidalBase = ../../Category/Monoidal/Cartesian/extractMonoidal kCat 4 | 5 | let base = ../../Category/Monoidal/extractCategory kCat 6 | 7 | let vObject = Type 8 | 9 | let v = 10 | base 11 | Type 12 | vObject 13 | (monoidalBase Type vObject ../../Category/Set/monoidal/cartesian) 14 | 15 | let object = Type 16 | 17 | let cat = monoidalBase vObject object ../../Category/Set/monoidal/cartesian 18 | 19 | in λ(m : kCat.arrow object object) → 20 | ../../Functor/Monoidal/extractFunctor 21 | object 22 | v 23 | cat 24 | cat 25 | (../Type object (base vObject object cat) m) 26 | (./monoidal m) 27 | -------------------------------------------------------------------------------- /dhall/Codensity/functor/monoidal: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let category = ../../Category/Set/category/instance 4 | 5 | let semigroupoid = ../../Category/Set/semigroupoid 6 | 7 | let vObject = Type 8 | 9 | let object = Type 10 | 11 | let cat = 12 | ../../Category/Monoidal/Cartesian/extractCategory 13 | kCat 14 | vObject 15 | object 16 | ../../Category/Set/monoidal/cartesian 17 | 18 | in λ(m : kCat.arrow object object) → 19 | ../../Monad/impliedMonoidalFunctor 20 | (../Type object cat m) 21 | (../../Ran/functor object object cat semigroupoid m m) 22 | (../monad category m) 23 | -------------------------------------------------------------------------------- /dhall/Codensity/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { endo = ./endo, monoidal = ./monoidal } 2 | -------------------------------------------------------------------------------- /dhall/Codensity/lift: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 15 | λ(f : kCat.arrow object object) → 16 | λ ( functor 17 | : ../Functor/Endo/Type 18 | vObject 19 | object 20 | (../Category/Monoidal/extractCategory kCat Type vObject v) 21 | cat 22 | f 23 | ) → 24 | λ(monad : ../Monad/Type object cat f) → 25 | ../Ran/lift 26 | object 27 | object 28 | object 29 | cat 30 | cat 31 | semigroupoid 32 | f 33 | functor 34 | f 35 | f 36 | monad.product 37 | -------------------------------------------------------------------------------- /dhall/Codensity/lower: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractCategory 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let object = Type 13 | 14 | let cat = 15 | ../Category/Monoidal/Cartesian/extractMonoidal 16 | kCat 17 | vObject 18 | object 19 | ../Category/Set/monoidal/cartesian 20 | 21 | in λ(m : kCat.arrow object object) → 22 | λ(monoidal : ../Functor/Monoidal/Type object v cat cat m) → 23 | ../Ran/lower m monoidal m 24 | -------------------------------------------------------------------------------- /dhall/Codensity/monad: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let object = Type 13 | 14 | let cat = 15 | ../Category/Monoidal/Cartesian/extractCategory 16 | kCat 17 | vObject 18 | object 19 | ../Category/Set/monoidal/cartesian 20 | 21 | in λ(category : ../Category/Type object v cat) → 22 | let Codensity = ./Type object cat 23 | 24 | in λ(m : kCat.arrow object object) → 25 | { unit = 26 | λ(a : object) → 27 | λ(x : a) → 28 | λ(b : object) → 29 | λ(k : cat.arrow { _1 = a, _2 = m b }) → 30 | k x 31 | , product = 32 | λ(a : object) → 33 | λ(codensity : Codensity m (Codensity m a)) → 34 | λ(c : object) → 35 | λ(l : cat.arrow { _1 = a, _2 = m c }) → 36 | codensity 37 | c 38 | ( λ(x : Codensity m a) → 39 | category.unit (Codensity m a) x c l 40 | ) 41 | } 42 | : ../Monad/Type object cat (Codensity m) 43 | -------------------------------------------------------------------------------- /dhall/Codensity/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , functor = ./functor/package.dhall 3 | , lift = ./lift 4 | , lower = ./lower 5 | , monad = ./monad 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Comonad/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Kind kCat vObject object) → 7 | ../Monad/Type object (../Category/Op/Kind vObject object cat) 8 | -------------------------------------------------------------------------------- /dhall/Comonad/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Comonoid/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | ../Monoid/Kind (../Category/Op/semigroupalSort cat) 3 | -------------------------------------------------------------------------------- /dhall/Comonoid/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | ../Monoid/Type object (../Category/Op/monoidal vObject object cat) 8 | -------------------------------------------------------------------------------- /dhall/Comonoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Compose/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | in λ(cObject : Kind) → 4 | λ(dObject : Kind) → 5 | λ(eObject : Kind) → 6 | ( λ ( f 7 | : { _1 : cat.arrow dObject eObject, _2 : cat.arrow cObject dObject } 8 | ) → 9 | λ(a : cObject) → 10 | f._1 (f._2 a) 11 | ) 12 | : cat.arrow 13 | (cat.product (cat.arrow dObject eObject) (cat.arrow cObject dObject)) 14 | (cat.arrow cObject eObject) 15 | -------------------------------------------------------------------------------- /dhall/Compose/comonad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractCategory 7 | cat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let Category = ../Category/Kind cat vObject 13 | 14 | in λ(cObject : Kind) → 15 | λ(c : Category cObject) → 16 | λ(dObject : Kind) → 17 | λ(d : Category dObject) → 18 | λ(f : cat.arrow dObject cObject) → 19 | λ(fFunctor : ../Functor/Type vObject dObject cObject v d c f) → 20 | λ(g : cat.arrow cObject dObject) → 21 | λ(adjunction : ../Adjunction/Type cObject dObject v c d f g) → 22 | { unit = adjunction.counit 23 | , product = 24 | λ(a : cObject) → 25 | fFunctor.map (g a) (g (f (g a))) (adjunction.unit (g a)) 26 | } 27 | : ../Comonad/Type 28 | cObject 29 | c 30 | (./Type cObject dObject cObject { _1 = f, _2 = g }) 31 | -------------------------------------------------------------------------------- /dhall/Compose/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { instance = ./instance, monoidal = ./monoidal } 2 | -------------------------------------------------------------------------------- /dhall/Compose/monad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractCategory 7 | cat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let Category = ../Category/Kind cat vObject 13 | 14 | in λ(cObject : Kind) → 15 | λ(c : Category cObject) → 16 | λ(dObject : Kind) → 17 | λ(d : Category dObject) → 18 | λ(f : cat.arrow dObject cObject) → 19 | λ(g : cat.arrow cObject dObject) → 20 | λ(gFunctor : ../Functor/Type vObject cObject dObject v c d g) → 21 | λ(adjunction : ../Adjunction/Type cObject dObject v c d f g) → 22 | { unit = adjunction.unit 23 | , product = 24 | λ(a : dObject) → 25 | gFunctor.map (f (g (f a))) (f a) (adjunction.counit (f a)) 26 | } 27 | : ../Monad/Type 28 | dObject 29 | d 30 | (./Type dObject cObject dObject { _1 = g, _2 = f }) 31 | -------------------------------------------------------------------------------- /dhall/Compose/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , adjunction = ./adjunction 3 | , comonad = ./comonad 4 | , functor = ./functor/package.dhall 5 | , monad = ./monad 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Cosemigroup/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | ../Semigroup/Type object (../Category/Op/semigroupal vObject object cat) 8 | -------------------------------------------------------------------------------- /dhall/Cosemigroup/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Costar/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Category/Kind kCat vObject object) → 6 | ../Star/Type vObject object (../Category/Op/Kind vObject object cat) 7 | -------------------------------------------------------------------------------- /dhall/Costar/category: -------------------------------------------------------------------------------- 1 | -- λ(object : Kind) 2 | -- → λ(arrow : object → object → Type) 3 | -- → λ(semigroupoid : ./../Semigroupoid/Type object arrow) 4 | -- → λ(w : object → object) 5 | -- → let costarArrow = ./Type object arrow w 6 | 7 | -- in λ(comonad : ./../Comonad/Type object arrow w) 8 | -- → let extend = 9 | -- ( ./../Comonad/impliedCostarfunctor 10 | -- object 11 | -- arrow 12 | -- semigroupoid 13 | -- w 14 | -- comonad 15 | -- ).map 16 | 17 | -- in { unit = 18 | -- comonad.unit 19 | -- , compose = 20 | -- λ(a : object) 21 | -- → λ(b : object) 22 | -- → λ(c : object) 23 | -- → λ(g : costarArrow b c) 24 | -- → λ(f : costarArrow a b) 25 | -- → semigroupoid.compose (w a) (w b) c g (extend a b f) 26 | -- } 27 | -- : ./../Category/Type object costarArrow 28 | <> 29 | -------------------------------------------------------------------------------- /dhall/Costar/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, category = ./category, semigroupoid = ./semigroupoid } 2 | -------------------------------------------------------------------------------- /dhall/Costar/semigroupoid: -------------------------------------------------------------------------------- 1 | -- λ(object : Kind) 2 | -- → λ(arrow : object → object → Type) 3 | -- → λ(semigroupoid : ./../Semigroupoid/Type object arrow) 4 | -- → λ(w : object → object) 5 | -- → λ(comonad : ./../Comonad/Type object arrow w) 6 | -- → ./../Category/extractSemigroupoid 7 | -- object 8 | -- arrow 9 | -- (./category object arrow semigroupoid w comonad) 10 | <> 11 | -------------------------------------------------------------------------------- /dhall/Coyoneda/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Kind kCat vObject object) → 7 | ../Lan/Type object object cat (../Identity/Type object) 8 | -------------------------------------------------------------------------------- /dhall/Coyoneda/functor: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 15 | ../Lan/functor object object cat semigroupoid (../Identity/Type object) 16 | -------------------------------------------------------------------------------- /dhall/Coyoneda/lift: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let v = 8 | ../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | Type 11 | vObject 12 | ../Category/Set/monoidal/cartesian 13 | 14 | in λ(cat : ../Category/Kind kCat vObject object) → 15 | λ(category : ../Category/Type object v cat) → 16 | ../Lan/lift 17 | v 18 | cat 19 | (../Category/extractSemigroupoid object v cat category) 20 | (../Identity/Type object) 21 | (../Identity/comonad object cat category) 22 | -------------------------------------------------------------------------------- /dhall/Coyoneda/lower: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let base = ../Category/Monoidal/Cartesian/extractCategory cat 4 | 5 | let vObject = Type 6 | 7 | let v = base Type vObject ../Category/Set/monoidal/cartesian 8 | 9 | in λ(cObject : Kind) → 10 | λ(c : ../Category/Kind cat vObject cObject) → 11 | let dCategory = ../Category/Set/category/instance 12 | 13 | let dObject = Type 14 | 15 | let d = base vObject dObject ../Category/Set/monoidal/cartesian 16 | 17 | in λ(f : cat.arrow cObject dObject) → 18 | λ(functor : ../Functor/Type vObject cObject dObject v c d f) → 19 | ../Lan/lower 20 | cObject 21 | cObject 22 | c 23 | f 24 | functor 25 | (../Identity/Type cObject) 26 | f 27 | (λ(b : cObject) → dCategory.unit (f b)) 28 | -------------------------------------------------------------------------------- /dhall/Coyoneda/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, functor = ./functor, lift = ./lift, lower = ./lower } 2 | -------------------------------------------------------------------------------- /dhall/Day/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let MonoidalCategory = ../Category/Monoidal/Kind cat 4 | 5 | let base = ../Category/Monoidal/extractCategory cat 6 | 7 | let vObject = Type 8 | 9 | in λ(cObject : Kind) → 10 | λ(v : MonoidalCategory Type vObject) → 11 | λ(c : MonoidalCategory vObject cObject) → 12 | ( λ ( f 13 | : { _1 : cat.arrow cObject vObject, _2 : cat.arrow cObject vObject } 14 | ) → 15 | ../Lan/Type 16 | { _1 : cObject, _2 : cObject } 17 | cObject 18 | (base vObject cObject c) 19 | c.product 20 | ( λ(p : { _1 : cObject, _2 : cObject }) → 21 | v.product { _1 = f._1 p._1, _2 = f._2 p._2 } 22 | ) 23 | ) 24 | : cat.arrow 25 | (cat.product (cat.arrow cObject vObject) (cat.arrow cObject vObject)) 26 | (cat.arrow cObject vObject) 27 | -------------------------------------------------------------------------------- /dhall/Day/convolution: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let MonoidalCategory = ../Category/Monoidal/Kind cat 6 | 7 | in λ(cObject : Kind) → 8 | λ(v : MonoidalCategory Type vObject) → 9 | λ(c : MonoidalCategory vObject cObject) → 10 | λ(f : cat.arrow cObject vObject) → 11 | λ(g : cat.arrow cObject vObject) → 12 | λ(a : cObject) → 13 | λ(r : vObject) → 14 | ∀(b : { _1 : cObject, _2 : cObject }) → 15 | c.arrow { _1 = c.product b, _2 = a } → 16 | v.arrow { _1 = v.product { _1 = f b._1, _2 = g b._2 }, _2 = r } 17 | -------------------------------------------------------------------------------- /dhall/Day/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , comonad = ./comonad 3 | , convolution = ./convolution 4 | , functor = ./functor 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Density/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(cObject : Kind) → 6 | let dObject = Type 7 | 8 | in λ(d : ../Category/Kind cat vObject dObject) → 9 | λ(f : cat.arrow cObject dObject) → 10 | ../Lan/Type cObject dObject d f f 11 | -------------------------------------------------------------------------------- /dhall/Density/functor: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(cObject : Kind) → 13 | let dObject = Type 14 | 15 | in λ(d : ../Category/Kind cat vObject dObject) → 16 | λ(dSemigroupoid : ../Semigroupoid/Type dObject v d d.arrow) → 17 | λ(f : cat.arrow cObject dObject) → 18 | ../Lan/functor cObject dObject d dSemigroupoid f f 19 | -------------------------------------------------------------------------------- /dhall/Density/lift: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | in λ(v : ../Category/Monoidal/Kind kCat Type vObject) → 8 | λ(cat : ../Category/Kind kCat vObject object) → 9 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 10 | λ(f : kCat.arrow object object) → 11 | λ(comonad : ../Comonad/Type object cat f) → 12 | ../Lan/lift v cat semigroupoid f comonad f 13 | -------------------------------------------------------------------------------- /dhall/Density/lower: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let base = ../Category/Monoidal/Cartesian/extractCategory kCat 4 | 5 | let vObject = Type 6 | 7 | let v = base Type vObject ../Category/Set/monoidal/cartesian 8 | 9 | let object = Type 10 | 11 | let cat = base vObject object ../Category/Set/monoidal/cartesian 12 | 13 | in λ(f : kCat.arrow object object) → 14 | λ(functor : ../Functor/Endo/Type vObject object v cat f) → 15 | λ(comonad : ../Comonad/Type object cat f) → 16 | ../Lan/lower object object cat f functor f f comonad.product 17 | -------------------------------------------------------------------------------- /dhall/Density/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, functor = ./functor, lift = ./lift, lower = ./lower } 2 | -------------------------------------------------------------------------------- /dhall/Duoid/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | A duoid (also known as a “united monoid”) is actually a pair of monoids with a 3 | shared `unit`. 4 | -} 5 | λ(cat : ../Category/Monoidal/Sort) → 6 | λ(m : Kind) → 7 | { diamond : ../Semilattice/Bounded/Kind cat m, star : ../Monoid/Kind cat m } 8 | -------------------------------------------------------------------------------- /dhall/Duoid/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A duoid (also known as a “united monoid”) is actually a pair of monoids with a 3 | shared `unit`. The `additive.product` distributes over the 4 | `multiplicative.product` as well. 5 | -} 6 | let kCat = ../Category/Cat/semigroupal 7 | 8 | let vObject = Type 9 | 10 | in λ(object : Kind) → 11 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 12 | λ(m : object) → 13 | { additive : ../Semilattice/Bounded/Type object cat m 14 | , multiplicative : ../Monoid/Type object cat m 15 | } 16 | -------------------------------------------------------------------------------- /dhall/Duoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Either/Kind: -------------------------------------------------------------------------------- 1 | λ(a : Kind) → λ(b : Kind) → < Left : a | Right : b > 2 | -------------------------------------------------------------------------------- /dhall/Either/duoid: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let Set = ../Category/Set/rig 4 | 5 | let vObject = Type 6 | 7 | let v = 8 | ../Category/Monoidal/Cartesian/extractCategory 9 | kCat 10 | Type 11 | vObject 12 | ../Category/Set/monoidal/cartesian 13 | 14 | let object = Type 15 | 16 | let cat = ../Category/Rig/extractMultiplicative kCat vObject object Set 17 | 18 | let CommutativeSemigroup = 19 | ../Semigroup/Commutative/Type 20 | object 21 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 22 | 23 | let extractMonoid = ../Functor/Monoidal/extractMonoid object v cat cat 24 | 25 | in λ(a : object) → 26 | λ(semigroup : CommutativeSemigroup a) → 27 | { additive = 28 | extractMonoid 29 | (λ(b : object) → Set.additive.product { _1 = a, _2 = b }) 30 | (./functor/monoidal/parallel a semigroup) 31 | , multiplicative = 32 | extractMonoid 33 | (λ(b : object) → Set.additive.product { _1 = a, _2 = b }) 34 | (./functor/monoidal/sequential a) 35 | } 36 | : ../Duoid/Type 37 | (kCat.arrow object object) 38 | (../Category/Endofunctor/monoidal/functor v cat) 39 | (λ(b : object) → Set.additive.product { _1 = a, _2 = b }) 40 | -------------------------------------------------------------------------------- /dhall/Either/functor/endo/package.dhall: -------------------------------------------------------------------------------- 1 | { star = ./star } 2 | -------------------------------------------------------------------------------- /dhall/Either/functor/monoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { parallel = ./parallel, sequential = ./sequential } 2 | -------------------------------------------------------------------------------- /dhall/Either/functor/monoidal/sequential: -------------------------------------------------------------------------------- 1 | let Set = ../../../Category/Set/rig 2 | 3 | in λ(a : Type) → 4 | ../../../Monad/impliedMonoidalFunctor 5 | (λ(b : Type) → Set.additive.product { _1 = a, _2 = b }) 6 | ( ../endo/star 7 | (../../../Identity/Type Type) 8 | ../../../Identity/functor/monoidal 9 | a 10 | ) 11 | (../../monad a) 12 | -------------------------------------------------------------------------------- /dhall/Either/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { endo = ./endo/package.dhall 2 | , monoidal = ./monoidal/package.dhall 3 | , pair = ./pair 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Either/monad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = ../Category/Rig/extractAdditive cat vObject Type ../Category/Set/rig 6 | 7 | in λ(a : Type) → 8 | { unit = λ(b : Type) → (Set.product { _1 = a, _2 = b }).Right 9 | , product = 10 | λ(b : Type) → 11 | λ ( fa 12 | : Set.product { _1 = a, _2 = Set.product { _1 = a, _2 = b } } 13 | ) → 14 | merge 15 | { Left = (Set.product { _1 = a, _2 = b }).Left 16 | , Right = λ(e : Set.product { _1 = a, _2 = b }) → e 17 | } 18 | ( merge 19 | { Left = 20 | ( Set.product 21 | { _1 = a, _2 = Set.product { _1 = a, _2 = b } } 22 | ).Left 23 | , Right = 24 | ( Set.product 25 | { _1 = a, _2 = Set.product { _1 = a, _2 = b } } 26 | ).Right 27 | } 28 | fa 29 | ) 30 | } 31 | : ../Monad/Type 32 | Type 33 | ( ../Category/Monoidal/Cartesian/extractCategory 34 | cat 35 | vObject 36 | Type 37 | ../Category/Set/monoidal/cartesian 38 | ) 39 | (λ(b : Type) → Set.product { _1 = a, _2 = b }) 40 | -------------------------------------------------------------------------------- /dhall/Either/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , duoid = ./duoid 3 | , functor = ./functor/package.dhall 4 | , monad = ./monad 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Eq/Type: -------------------------------------------------------------------------------- 1 | -- {-| 2 | -- `bool` is some sort of `Const` functor in the correct category that can be 3 | -- converted to a `Bool`. 4 | -- -} 5 | -- λ(object : Kind) 6 | -- → λ(cat : ./../Category/Monoidal/Kind kCat object) 7 | -- → λ(bool : object) 8 | -- → λ(a : object) 9 | -- → { eq : cat.arrow { _1 = cat.product { _1 = a, _2 = a }, _2 = bool } } 10 | λ(a : Type) → { eq : a → a → Bool } 11 | -------------------------------------------------------------------------------- /dhall/Eq/eqfn: -------------------------------------------------------------------------------- 1 | {-| 2 | When defining properties, you almost always are trying to show the equivalence 3 | of two functions. This makes that easier. 4 | -} 5 | λ(a : Type) → 6 | λ(b : Type) → 7 | λ(eq : ./Type b) → 8 | λ(f : a → b) → 9 | λ(g : a → b) → 10 | λ(x : a) → 11 | eq.eq (f x) (g x) 12 | -------------------------------------------------------------------------------- /dhall/Eq/functor/contravariant: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let Eq = ../Type 4 | 5 | let base = ../../Category/Monoidal/Cartesian/extractCategory cat 6 | 7 | let vObject = Type 8 | 9 | let v = base Type vObject ../../Category/Set/monoidal/cartesian 10 | 11 | let Set = base vObject Type ../../Category/Set/monoidal/cartesian 12 | 13 | in { map = 14 | λ(a : Type) → 15 | λ(b : Type) → 16 | λ(fn : b → a) → 17 | λ(fa : Eq a) → 18 | { eq = λ(x : b) → λ(y : b) → fa.eq (fn x) (fn y) } 19 | } 20 | : ../../Functor/Contravariant vObject Type Type v Set Set Eq 21 | -------------------------------------------------------------------------------- /dhall/Eq/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { contravariant = ./contravariant } 2 | -------------------------------------------------------------------------------- /dhall/Eq/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, eqfn = ./eqfn, functor = ./functor/package.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Field/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../Group/Commutative/Kind cat m 4 | , multiplicative : ../Group/Commutative/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Field/Ordered/Type: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | { additive : ../../Group/OrderedCommutative/Type m 5 | , multiplicative : ../../Group/Commutative/Set m 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Field/Ordered/extractPartiallyOrderedField: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(field : ./Type m) → 5 | { additive = 6 | ../../Group/OrderedCommutative/extractPartiallyOrderedCommutativeGroup 7 | m 8 | field.additive 9 | , multiplicative = field.multiplicative 10 | } 11 | : ../PartiallyOrdered/Type m 12 | -------------------------------------------------------------------------------- /dhall/Field/Ordered/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , extractPartiallyOrderedField = ./extractPartiallyOrderedField 3 | , terms = ./terms.dhall 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Field/Ordered/terms.dhall: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(field : ./Type m) → 5 | { compare = field.additive.compare } 6 | ∧ ../PartiallyOrdered/terms.dhall 7 | m 8 | (./extractPartiallyOrderedField m field) 9 | -------------------------------------------------------------------------------- /dhall/Field/PartiallyOrdered/Type: -------------------------------------------------------------------------------- 1 | λ(m : Type) → 2 | { additive : ../../Group/PartiallyOrderedCommutative/Type m 3 | , multiplicative : ../../Group/Commutative/Set m 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Field/PartiallyOrdered/extractField: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(field : ./Type m) → 16 | { additive = 17 | ../../Group/PartiallyOrderedCommutative/extractCommutativeGroup 18 | m 19 | field.additive 20 | , multiplicative = field.multiplicative.{ unit, inverse, product } 21 | } 22 | : ../Type object cat m 23 | -------------------------------------------------------------------------------- /dhall/Field/PartiallyOrdered/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, extractField = ./extractField, terms = ./terms.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Field/PartiallyOrdered/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let category = ../../Category/Set/category/monoidal 4 | 5 | let vObject = Type 6 | 7 | let object = Type 8 | 9 | let cat = 10 | ../../Category/Monoidal/Cartesian/extractMonoidal 11 | kCat 12 | vObject 13 | object 14 | ../../Category/Set/monoidal/cartesian 15 | 16 | in λ(m : object) → 17 | λ(field : ./Type m) → 18 | { eq = field.additive.eq, le = field.additive.le } 19 | ∧ ../terms.dhall object cat category m (./extractField m field) 20 | -------------------------------------------------------------------------------- /dhall/Field/Set: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | { additive : ../Group/Commutative/Set m 5 | , multiplicative : ../Group/Commutative/Set m 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Field/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../Group/Commutative/Type object cat m 9 | , multiplicative : ../Group/Commutative/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Field/divide: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(field : ./Type object cat m) → 17 | ../Group/Commutative/quotient object cat category m field.multiplicative 18 | -------------------------------------------------------------------------------- /dhall/Field/extractCommutativeRing: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(field : ./Type object cat m) → 9 | { additive = field.additive 10 | , multiplicative = 11 | ../Group/Commutative/extractCommutativeMonoid 12 | object 13 | cat 14 | m 15 | field.multiplicative 16 | } 17 | : ../Ring/Commutative/Type object cat m 18 | -------------------------------------------------------------------------------- /dhall/Field/extractRing: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(field : ./Type object cat m) → 9 | { additive = field.additive 10 | , multiplicative = 11 | ../Group/Commutative/extractMonoid object cat m field.multiplicative 12 | } 13 | : ../Ring/Type object cat m 14 | -------------------------------------------------------------------------------- /dhall/Field/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Ordered = ./Ordered/package.dhall 3 | , PartiallyOrdered = ./PartiallyOrdered/package.dhall 4 | , Set = ./Set 5 | , Type = ./Type 6 | , divide = ./divide 7 | , extractCommutativeRing = ./extractCommutativeRing 8 | , extractRing = ./extractRing 9 | , terms = ./terms.dhall 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Field/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(field : ./Type object cat m) → 17 | { divide = ./divide object cat category m field 18 | , reciprocal = field.multiplicative.inverse 19 | } 20 | ∧ ../Ring/terms.dhall 21 | object 22 | cat 23 | category 24 | m 25 | (./extractRing object cat m field) 26 | -------------------------------------------------------------------------------- /dhall/Functor/Bifunctor/Type: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let Functor = ../Type 4 | 5 | let Category/Product = ../../Category/Product/Type 6 | 7 | let Category = ../../Category/Kind cat 8 | 9 | let MonoidalCategory = ../../Category/Monoidal/Kind cat 10 | 11 | in λ(vObject : Kind) → 12 | λ(cObject : Kind) → 13 | λ(dObject : Kind) → 14 | λ(eObject : Kind) → 15 | λ(v : MonoidalCategory Type vObject) → 16 | λ(c : Category vObject cObject) → 17 | λ(d : Category vObject dObject) → 18 | Functor 19 | vObject 20 | (cat.product cObject dObject) 21 | eObject 22 | (../../Category/Monoidal/extractCategory cat Type vObject v) 23 | (Category/Product vObject cObject dObject v c d) 24 | -------------------------------------------------------------------------------- /dhall/Functor/Bifunctor/impliedFirstFunctor: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | let Category = ../../Category/Kind cat vObject 13 | 14 | in λ(cObject : Kind) → 15 | λ(c : Category cObject) → 16 | λ(dObject : Kind) → 17 | λ(d : Category dObject) → 18 | λ(dCategory : ../../Category/Type dObject v d) → 19 | λ(eObject : Kind) → 20 | λ(e : Category eObject) → 21 | λ(f : cat.arrow (cat.product cObject dObject) eObject) → 22 | λ(bifunctor : ./Type vObject cObject dObject eObject v c d e f) → 23 | λ(a : dObject) → 24 | { map = 25 | λ(g : cObject) → 26 | λ(h : cObject) → 27 | λ(fn : c.arrow { _1 = g, _2 = h }) → 28 | bifunctor.map 29 | { _1 = g, _2 = a } 30 | { _1 = h, _2 = a } 31 | { _1 = fn, _2 = dCategory.unit a } 32 | } 33 | : ../Type 34 | vObject 35 | cObject 36 | eObject 37 | (../../Category/Monoidal/extractCategory cat Type vObject v) 38 | c 39 | e 40 | (λ(g : cObject) → f { _1 = g, _2 = a }) 41 | -------------------------------------------------------------------------------- /dhall/Functor/Bifunctor/impliedSecondFunctor: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | let Category = ../../Category/Kind cat vObject 13 | 14 | in λ(cObject : Kind) → 15 | λ(c : Category cObject) → 16 | λ(cCategory : ../../Category/Type cObject v c) → 17 | λ(dObject : Kind) → 18 | λ(d : Category dObject) → 19 | λ(eObject : Kind) → 20 | λ(e : Category eObject) → 21 | λ(f : cat.arrow (cat.product cObject dObject) eObject) → 22 | λ(bifunctor : ./Type vObject cObject dObject eObject v c d e f) → 23 | λ(a : cObject) → 24 | { map = 25 | λ(b : dObject) → 26 | λ(c : dObject) → 27 | λ(fn : d.arrow { _1 = b, _2 = c }) → 28 | bifunctor.map 29 | { _1 = a, _2 = b } 30 | { _1 = a, _2 = c } 31 | { _1 = cCategory.unit a, _2 = fn } 32 | } 33 | : ../Type 34 | vObject 35 | dObject 36 | eObject 37 | (../../Category/Monoidal/extractCategory cat Type vObject v) 38 | d 39 | e 40 | (λ(b : dObject) → f { _1 = a, _2 = b }) 41 | -------------------------------------------------------------------------------- /dhall/Functor/Bifunctor/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , impliedFirstFunctor = ./impliedFirstFunctor 3 | , impliedSecondFunctor = ./impliedSecondFunctor 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Functor/Constant/Kind: -------------------------------------------------------------------------------- 1 | λ(a : { _1 : Kind, _2 : Kind }) → a._1 2 | -------------------------------------------------------------------------------- /dhall/Functor/Constant/Type: -------------------------------------------------------------------------------- 1 | λ(cObject : Kind) → 2 | λ(dObject : Kind) → 3 | λ(a : { _1 : cObject, _2 : dObject }) → 4 | a._1 5 | -------------------------------------------------------------------------------- /dhall/Functor/Constant/functor: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(cObject : Kind) → 13 | λ(c : ../../Category/Kind cat vObject cObject) → 14 | λ(cCategory : ../../Category/Type cObject v c) → 15 | λ(dObject : Kind) → 16 | λ(d : ../../Category/Kind cat vObject dObject) → 17 | { map = 18 | λ(a : { _1 : cObject, _2 : dObject }) → 19 | λ(b : { _1 : cObject, _2 : dObject }) → 20 | λ ( f 21 | : { _1 : c.arrow { _1 = a._1, _2 = b._1 } 22 | , _2 : d.arrow { _1 = a._2, _2 = b._2 } 23 | } 24 | ) → 25 | f._1 26 | } 27 | : ../Bifunctor/Type 28 | vObject 29 | cObject 30 | dObject 31 | cObject 32 | v 33 | c 34 | d 35 | c 36 | (./Type cObject dObject) 37 | -------------------------------------------------------------------------------- /dhall/Functor/Constant/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type, functor = ./functor, term = ./term } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Constant/term: -------------------------------------------------------------------------------- 1 | λ(cObject : Type) → 2 | λ(dObject : Type) → 3 | λ(a : { _1 : cObject, _2 : dObject }) → 4 | a._1 5 | -------------------------------------------------------------------------------- /dhall/Functor/Contravariant: -------------------------------------------------------------------------------- 1 | {-| 2 | A contravariant functor `C → D` is equivalent to a covariant functor `C^op → D`. 3 | -} 4 | let cat = ../Category/Cat/semigroupal 5 | 6 | in λ(vObject : Kind) → 7 | λ(cObject : Kind) → 8 | λ(dObject : Kind) → 9 | λ(v : ../Category/Kind cat Type vObject) → 10 | λ(c : ../Category/Kind cat vObject cObject) → 11 | ./Type vObject cObject dObject v (../Category/Op/Kind vObject cObject c) 12 | -------------------------------------------------------------------------------- /dhall/Functor/Costar: -------------------------------------------------------------------------------- 1 | {-| 2 | A functor from a Cokleisli category to the underlying category. 3 | -} 4 | let kCat = ../Category/Cat/semigroupal 5 | 6 | in λ(vObject : Kind) → 7 | λ(object : Kind) → 8 | λ(v : ../Category/Kind kCat Type vObject) → 9 | λ(cat : ../Category/Kind kCat vObject object) → 10 | ./Star/Type vObject object v (../Category/Op/Kind vObject object cat) 11 | -------------------------------------------------------------------------------- /dhall/Functor/Endo/Star/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | This is very similar to Haskell’s `Traversable`, except that it can be 3 | implemented for an arbitrary `m`, doesn’t necessarily require an `Applicative` 4 | instance, and also may be _more_ constrained than `Applicative`. 5 | -} 6 | let kCat = ../../../Category/Cat/semigroupal 7 | 8 | in λ(vObject : Kind) → 9 | λ(object : Kind) → 10 | λ(v : ../../../Category/Kind kCat Type vObject) → 11 | λ(cat : ../../../Category/Kind kCat vObject object) → 12 | λ(m : kCat.arrow object object) → 13 | ../Type 14 | vObject 15 | object 16 | v 17 | (../../../Category/Kleisli/category vObject object cat m) 18 | -------------------------------------------------------------------------------- /dhall/Functor/Endo/Star/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, sequence = ./sequence } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Endo/Star/sequence: -------------------------------------------------------------------------------- 1 | let kCat = ../../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../../../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../../../Category/Kind kCat vObject object) → 14 | λ(category : ../../../Category/Type object v cat) → 15 | λ(f : kCat.arrow object object) → 16 | λ(g : kCat.arrow object object) → 17 | λ ( functor 18 | : ./Type 19 | vObject 20 | object 21 | (../../../Category/Monoidal/extractCategory kCat Type vObject v) 22 | cat 23 | f 24 | g 25 | ) → 26 | λ(a : object) → 27 | functor.map (f a) a (category.unit (f a)) 28 | -------------------------------------------------------------------------------- /dhall/Functor/Endo/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let Functor = ../Type 4 | 5 | let Category = ../../Category/Kind kCat 6 | 7 | in λ(vObject : Kind) → 8 | λ(object : Kind) → 9 | λ(v : Category Type vObject) → 10 | λ(cat : Category vObject object) → 11 | Functor vObject object object v cat cat 12 | -------------------------------------------------------------------------------- /dhall/Functor/Endo/package.dhall: -------------------------------------------------------------------------------- 1 | { Star = ./Star/package.dhall, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Monoidal/Type: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let MonoidalCategory = ../../Category/Monoidal/Kind cat vObject 6 | 7 | in λ(cObject : Kind) → 8 | λ(v : ../../Category/Kind cat Type vObject) → 9 | λ(c : MonoidalCategory cObject) → 10 | let dObject = Type 11 | 12 | in λ(d : MonoidalCategory dObject) → 13 | λ(f : cat.arrow cObject dObject) → 14 | let base = ../../Category/Monoidal/extractCategory cat vObject 15 | 16 | in ../Type 17 | vObject 18 | cObject 19 | dObject 20 | v 21 | (base cObject c) 22 | (base dObject d) 23 | f 24 | ⩓ ../../Monoid/Type 25 | (cat.arrow cObject dObject) 26 | (../../Category/Functor/monoidal cObject v c d) 27 | f 28 | -------------------------------------------------------------------------------- /dhall/Functor/Monoidal/extractFunctor: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let MonoidalCategory = ../../Category/Monoidal/Kind cat vObject 6 | 7 | in λ(cObject : Kind) → 8 | λ(v : ../../Category/Kind cat Type vObject) → 9 | λ(c : MonoidalCategory cObject) → 10 | let dObject = Type 11 | 12 | in λ(d : MonoidalCategory dObject) → 13 | λ(f : cat.arrow cObject dObject) → 14 | λ(monoidal : ./Type cObject v c d f) → 15 | let base = ../../Category/Monoidal/extractCategory cat vObject 16 | 17 | in monoidal.{ map } 18 | : ../../Functor/Type 19 | vObject 20 | cObject 21 | dObject 22 | v 23 | (base cObject c) 24 | (base dObject d) 25 | f 26 | -------------------------------------------------------------------------------- /dhall/Functor/Monoidal/extractMonoid: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let MonoidalCategory = ../../Category/Monoidal/Kind cat vObject 6 | 7 | in λ(cObject : Kind) → 8 | λ(v : ../../Category/Kind cat Type vObject) → 9 | λ(c : MonoidalCategory cObject) → 10 | let dObject = Type 11 | 12 | in λ(d : MonoidalCategory dObject) → 13 | λ(f : cat.arrow cObject dObject) → 14 | λ(monoidal : ./Type cObject v c d f) → 15 | monoidal.{ unit, product } 16 | : ../../Monoid/Type 17 | (cat.arrow cObject dObject) 18 | (../../Category/Functor/monoidal cObject v c d) 19 | f 20 | -------------------------------------------------------------------------------- /dhall/Functor/Monoidal/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , extractFunctor = ./extractFunctor 3 | , extractMonoid = ./extractMonoid 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Functor/Pair/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(v : ../../Category/Monoidal/Kind kCat Type vObject) → 6 | λ(cat : ../../Category/Kind kCat vObject object) → 7 | ../Bifunctor/Type vObject object object object v cat cat cat 8 | -------------------------------------------------------------------------------- /dhall/Functor/Pair/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Profunctor/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A profunctor `𝒞 ↛ 𝒟` is represented as the bifunctor `(𝒟^op, 𝒞) → 𝒱`. This is 3 | much more general than Haskell’s `Profunctor`. It also requires that 𝒱 is 4 | closed. 5 | -} 6 | let cat = ../../Category/Cat/semigroupal 7 | 8 | let Category = ../../Category/Kind cat 9 | 10 | let vObject = Type 11 | 12 | in λ(cObject : Kind) → 13 | λ(dObject : Kind) → 14 | λ(v : ../../Category/Monoidal/Closed/Kind cat vObject) → 15 | λ(c : Category vObject cObject) → 16 | λ(d : Category vObject dObject) → 17 | ../Bifunctor/Type 18 | vObject 19 | dObject 20 | cObject 21 | vObject 22 | v 23 | (../../Category/Op/Kind vObject dObject d) 24 | c 25 | (../../Category/Monoidal/extractCategory cat vObject vObject v) 26 | -------------------------------------------------------------------------------- /dhall/Functor/Profunctor/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Functor/SetValued: -------------------------------------------------------------------------------- 1 | {-| 2 | A functor to **Set** from some other category. 3 | -} 4 | let kCat = ../Category/Cat/semigroupal 5 | 6 | let vObject = Type 7 | 8 | in λ(object : Kind) → 9 | λ(v : ../Category/Kind kCat Type vObject) → 10 | λ(cat : ../Category/Kind kCat vObject object) → 11 | ./Type 12 | vObject 13 | object 14 | Type 15 | v 16 | cat 17 | ( ../Category/Monoidal/Cartesian/extractCategory 18 | kCat 19 | vObject 20 | Type 21 | ../Category/Set/monoidal/cartesian 22 | ) 23 | -------------------------------------------------------------------------------- /dhall/Functor/Star/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A functor from a Kleisli category to the underlying non-Kleisli category. 3 | -} 4 | let kCat = ../../Category/Cat/semigroupal 5 | 6 | in λ(vObject : Kind) → 7 | λ(object : Kind) → 8 | λ(v : ../../Category/Kind kCat Type vObject) → 9 | λ(cat : ../../Category/Kind kCat vObject object) → 10 | λ(m : kCat.arrow object object) → 11 | ../Type 12 | vObject 13 | object 14 | object 15 | v 16 | (../../Category/Kleisli/category vObject object cat m) 17 | cat 18 | -------------------------------------------------------------------------------- /dhall/Functor/Star/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, functor = ./functor } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Strong/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(v : ../../Category/Kind kCat Type vObject) → 7 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 8 | λ(f : kCat.arrow object object) → 9 | { strengthen : 10 | ∀(a : object) → 11 | ∀(b : object) → 12 | cat.arrow 13 | { _1 = cat.product { _1 = a, _2 = f b } 14 | , _2 = f (cat.product { _1 = a, _2 = b }) 15 | } 16 | } 17 | ⩓ ../Endo/Type 18 | vObject 19 | object 20 | v 21 | (../../Category/Monoidal/extractCategory kCat vObject object cat) 22 | f 23 | -------------------------------------------------------------------------------- /dhall/Functor/Strong/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Functor/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Category = ../Category/Kind cat 4 | 5 | in λ(vObject : Kind) → 6 | λ(cObject : Kind) → 7 | λ(dObject : Kind) → 8 | λ(v : Category Type vObject) → 9 | λ(c : Category vObject cObject) → 10 | λ(d : Category vObject dObject) → 11 | λ(f : cat.arrow cObject dObject) → 12 | { map : 13 | ∀(a : cObject) → 14 | ∀(b : cObject) → 15 | v.arrow 16 | { _1 = c.arrow { _1 = a, _2 = b } 17 | , _2 = d.arrow { _1 = f a, _2 = f b } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /dhall/Functor/opposite: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(cObject : Kind) → 5 | λ(dObject : Kind) → 6 | λ(v : ../Category/Kind cat Type vObject) → 7 | λ(c : ../Category/Kind cat vObject cObject) → 8 | λ(d : ../Category/Kind cat vObject dObject) → 9 | λ(f : cat.arrow cObject dObject) → 10 | λ(functor : ./Type vObject cObject dObject v c d f) → 11 | { map = λ(a : cObject) → λ(b : cObject) → functor.map b a } 12 | : ./Type 13 | vObject 14 | cObject 15 | dObject 16 | v 17 | (../Category/Op/Kind vObject cObject c) 18 | (../Category/Op/Kind vObject dObject d) 19 | f 20 | -------------------------------------------------------------------------------- /dhall/Functor/package.dhall: -------------------------------------------------------------------------------- 1 | { Bifunctor = ./Bifunctor/package.dhall 2 | , Constant = ./Constant/package.dhall 3 | , Contravariant = ./Contravariant 4 | , Costar = ./Costar 5 | , Endo = ./Endo/package.dhall 6 | , Monoidal = ./Monoidal/package.dhall 7 | , Pair = ./Pair/package.dhall 8 | , Profunctor = ./Profunctor/package.dhall 9 | , SetValued = ./SetValued 10 | , Star = ./Star/package.dhall 11 | , Strong = ./Strong/package.dhall 12 | , Type = ./Type 13 | , laws = ./laws 14 | , opposite = ./opposite 15 | , void = ./void 16 | } 17 | -------------------------------------------------------------------------------- /dhall/Functor/void: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let c = ../Category/Set/monoidal/cartesian 4 | 5 | let vObject = Type 6 | 7 | let v = 8 | ../Category/Monoidal/Cartesian/extractCategory 9 | cat 10 | Type 11 | vObject 12 | ../Category/Set/monoidal/cartesian 13 | 14 | let cObject = Type 15 | 16 | in λ(dObject : Kind) → 17 | λ(d : ../Category/Kind cat vObject dObject) → 18 | λ(f : cat.arrow cObject dObject) → 19 | λ ( functor 20 | : ./Type 21 | vObject 22 | cObject 23 | dObject 24 | v 25 | (../Category/Monoidal/Cartesian/extractCategory cat vObject cObject c) 26 | d 27 | f 28 | ) → 29 | λ(a : cObject) → 30 | functor.map a c.unit (λ(_ : a) → {=}) 31 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | A commutative monoid implies a preorder. However, that currently forces us 3 | into **Set**, so we instead just alias the non-commutative type to avoid 4 | specializing. 5 | -} 6 | ../Kind 7 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/Set: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(m : Type) → { le : m → m → Bool } ⩓ ../Type Type Set m 13 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A commutative monoid implies a preorder. However, that currently forces us into 3 | **Set**, so we instead just alias the non-commutative type to avoid 4 | specializing. 5 | -} 6 | ../Type 7 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/extractCommutativeMonoid: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(group : ./Type object cat m) → 9 | group.{ unit, product } : ../../Monoid/Commutative/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/extractGroup: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(group : ./Type object cat m) → 9 | group.{ unit, inverse, product } : ../Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/extractMonoid: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(group : ./Type object cat m) → 9 | group.{ unit, product } : ../../Monoid/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Set = ./Set 3 | , Type = ./Type 4 | , extractCommutativeMonoid = ./extractCommutativeMonoid 5 | , extractGroup = ./extractGroup 6 | , extractMonoid = ./extractMonoid 7 | , quotient = ./quotient 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Group/Commutative/quotient: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(group : ./Type object cat m) → 17 | ../rightQuotient object cat category m (./extractGroup object cat m group) 18 | -------------------------------------------------------------------------------- /dhall/Group/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { inverse : cat.arrow m m } ⩓ ../Monoid/Kind cat m 4 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/Order: -------------------------------------------------------------------------------- 1 | < LT | EQ | GT > 2 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | `compare` exists to distinguish this from a Group/PartiallyOrdered, since 3 | `compare` requires a total order. 4 | -} 5 | λ(m : Type) → { compare : m → m → ./Order } ⩓ ../PartiallyOrdered/Type m 6 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/defaultCompare: -------------------------------------------------------------------------------- 1 | let Order = ./Order 2 | 3 | in λ(m : Type) → 4 | λ(totalLE : m → m → Bool) → 5 | λ(a : m) → 6 | λ(b : m) → 7 | if totalLE a b 8 | then if totalLE b a then Order.EQ else Order.LT 9 | else Order.GT 10 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/defaultLE: -------------------------------------------------------------------------------- 1 | λ(m : Type) → 2 | λ(compare : m → m → ./Order) → 3 | λ(a : m) → 4 | λ(b : m) → 5 | merge { LT = True, EQ = True, GT = False } (compare a b) 6 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/extractPartiallyOrderedGroup: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(group : ./Type m) → 5 | group.{ eq, unit, inverse, le, product } : ../PartiallyOrdered/Type m 6 | -------------------------------------------------------------------------------- /dhall/Group/Ordered/package.dhall: -------------------------------------------------------------------------------- 1 | { Order = ./Order 2 | , Type = ./Type 3 | , defaultCompare = ./defaultCompare 4 | , defaultLE = ./defaultLE 5 | , extractPartiallyOrderedGroup = ./extractPartiallyOrderedGroup 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Group/OrderedCommutative/Type: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | { compare : m → m → ../Ordered/Order } 5 | ⩓ ../PartiallyOrderedCommutative/Type m 6 | -------------------------------------------------------------------------------- /dhall/Group/OrderedCommutative/extractPartiallyOrderedCommutativeGroup: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(group : ./Type m) → 5 | group.{ eq, unit, inverse, le, product } 6 | : ../PartiallyOrderedCommutative/Type m 7 | -------------------------------------------------------------------------------- /dhall/Group/OrderedCommutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , extractPartiallyOrderedCommutativeGroup = 3 | ./extractPartiallyOrderedCommutativeGroup 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrdered/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | This is the weakest form of order provided. There is no standalone preorder, 3 | partial order, or anything, because there are too many possible instances. For 4 | the general case, just define regular functions. A `Group/PartiallyOrdered` 5 | constrains the instances enough for a generic “less than” to be meaningful. 6 | -} 7 | let cat = ../../Category/Cat/semigroupal 8 | 9 | let vObject = Type 10 | 11 | let Set = 12 | ../../Category/Monoidal/Cartesian/extractMonoidal 13 | cat 14 | Type 15 | vObject 16 | ../../Category/Set/monoidal/cartesian 17 | 18 | in λ(m : Type) → { le : m → m → Bool } ⩓ ../../Eq/Type m ⩓ ../Type Type Set m 19 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrdered/defaultEq: -------------------------------------------------------------------------------- 1 | λ(m : Type) → 2 | λ(partialLE : m → m → Bool) → 3 | λ(a : m) → 4 | λ(b : m) → 5 | partialLE a b && partialLE b a 6 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrdered/extractEq: -------------------------------------------------------------------------------- 1 | λ(m : Type) → λ(group : ./Type m) → group.{ eq } : ../../Eq/Type m 2 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrdered/extractGroup: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(group : ./Type m) → 16 | group.{ unit, inverse, product } : ../Type object cat m 17 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrdered/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , defaultEq = ./defaultEq 3 | , extractEq = ./extractEq 4 | , extractGroup = ./extractGroup 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrderedCommutative/Type: -------------------------------------------------------------------------------- 1 | ../PartiallyOrdered/Type 2 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrderedCommutative/extractCommutativeGroup: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(group : ./Type m) → 16 | group.{ unit, inverse, product } : ../Commutative/Type object cat m 17 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrderedCommutative/extractSetCommutativeGroup: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(group : ./Type m) → 5 | group.{ unit, inverse, le, product } : ../Commutative/Set m 6 | -------------------------------------------------------------------------------- /dhall/Group/PartiallyOrderedCommutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , extractCommutativeGroup = ./extractCommutativeGroup 3 | , extractSetCommutativeGroup = ./extractSetCommutativeGroup 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Group/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { inverse : cat.arrow { _1 = m, _2 = m } } ⩓ ../Monoid/Type object cat m 9 | -------------------------------------------------------------------------------- /dhall/Group/extractMonoid: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(group : ./Type object cat m) → 9 | group.{ unit, product } : ../Monoid/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Group/package.dhall: -------------------------------------------------------------------------------- 1 | { Commutative = ./Commutative/package.dhall 2 | , Kind = ./Kind 3 | , Ordered = ./Ordered/package.dhall 4 | , OrderedCommutative = ./OrderedCommutative/package.dhall 5 | , PartiallyOrdered = ./PartiallyOrdered/package.dhall 6 | , PartiallyOrderedCommutative = ./PartiallyOrderedCommutative/package.dhall 7 | , Type = ./Type 8 | , extractMonoid = ./extractMonoid 9 | , leftQuotient = ./leftQuotient 10 | , rightQuotient = ./rightQuotient 11 | , terms = ./terms.dhall 12 | } 13 | -------------------------------------------------------------------------------- /dhall/Group/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(group : ./Type object cat m) → 17 | { inverse = group.inverse 18 | , leftQuotient = ./leftQuotient object cat category m group 19 | , rightQuotient = ./rightQuotient object cat category m group 20 | } 21 | ∧ ../Monoid/terms.dhall object cat m (./extractMonoid object cat m group) 22 | -------------------------------------------------------------------------------- /dhall/Groupoid/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **TODO**: This would be `./../Group/Type … (./../Category/Monoidal/Profunctor 4 | object morphism)`, but `Category` isn’t defined via `Monoid`, so we prefer 5 | compatibility with that. 6 | -} 7 | let kCat = ../Category/Cat/semigroupal 8 | 9 | let vObject = Type 10 | 11 | in λ(object : Kind) → 12 | λ(v : ../Category/Monoidal/Kind kCat Type vObject) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | { inverse : 15 | ∀(a : kCat.product object object) → 16 | cat.arrow a → 17 | cat.arrow { _1 = a._2, _2 = a._1 } 18 | } 19 | ⩓ ../Category/Type object v cat 20 | -------------------------------------------------------------------------------- /dhall/Groupoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Identity/Kind: -------------------------------------------------------------------------------- 1 | λ(a : Kind) → a 2 | -------------------------------------------------------------------------------- /dhall/Identity/Type: -------------------------------------------------------------------------------- 1 | λ(object : Kind) → λ(a : object) → a 2 | -------------------------------------------------------------------------------- /dhall/Identity/adjunction: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractCategory 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let object = Type 13 | 14 | let cat = 15 | ../Category/Monoidal/Cartesian/extractCategory 16 | kCat 17 | vObject 18 | object 19 | ../Category/Set/monoidal/cartesian 20 | 21 | in { unit = λ(a : object) → λ(x : a) → x 22 | , counit = λ(a : object) → λ(x : a) → x 23 | , leftAdjunct = λ(a : object) → λ(b : object) → λ(f : a → b) → f 24 | , rightAdjunct = λ(a : object) → λ(b : object) → λ(f : a → b) → f 25 | } 26 | : ../Adjunction/Type object object v cat cat (./Type object) (./Type object) 27 | -------------------------------------------------------------------------------- /dhall/Identity/bimonad: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | λ(category : ../Category/Type object v cat) → 15 | { monoid = ./monad object cat category 16 | , comonoid = 17 | ./monad 18 | object 19 | (../Category/Op/Kind vObject object cat) 20 | (../Category/Op/category object cat category) 21 | } 22 | : ../Bimonad/Type 23 | object 24 | (../Category/Monoidal/extractCategory kCat Type vObject v) 25 | cat 26 | (./Type object) 27 | -------------------------------------------------------------------------------- /dhall/Identity/comonad: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | λ(category : ../Category/Type object v cat) → 15 | ./monad 16 | object 17 | (../Category/Op/Kind vObject object cat) 18 | (../Category/Op/category object cat category) 19 | -------------------------------------------------------------------------------- /dhall/Identity/functor/endo: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(v : ../../Category/Kind kCat Type vObject) → 6 | λ ( vCategory 7 | : ../../Category/Type 8 | vObject 9 | ( ../../Category/Monoidal/Cartesian/extractMonoidal 10 | kCat 11 | Type 12 | Type 13 | ../../Category/Set/monoidal/cartesian 14 | ) 15 | v 16 | ) → 17 | λ(cat : ../../Category/Kind kCat vObject object) → 18 | { map = 19 | λ(a : object) → 20 | λ(b : object) → 21 | vCategory.unit (cat.arrow { _1 = a, _2 = b }) 22 | } 23 | : ../../Functor/Endo/Type vObject object v cat (../Type object) 24 | -------------------------------------------------------------------------------- /dhall/Identity/functor/monoidal: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vCategory = ../../Category/Set/category/instance 4 | 5 | let category = ../../Category/Set/category/instance 6 | 7 | let base = ../../Category/Monoidal/Cartesian/extractCategory kCat 8 | 9 | let vObject = Type 10 | 11 | let v = base Type vObject ../../Category/Set/monoidal/cartesian 12 | 13 | let object = Type 14 | 15 | let cat = base vObject object ../../Category/Set/monoidal/cartesian 16 | 17 | in ../../Monad/impliedMonoidalFunctor 18 | (../Type object) 19 | (./endo vObject object v vCategory cat) 20 | (../monad object cat category) 21 | -------------------------------------------------------------------------------- /dhall/Identity/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { endo = ./endo, monoidal = ./monoidal } 2 | -------------------------------------------------------------------------------- /dhall/Identity/monad: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Kind kCat vObject object) → 14 | λ(category : ../Category/Type object v cat) → 15 | { unit = category.unit, product = category.unit } 16 | : ../Monad/Type object cat (./Type object) 17 | -------------------------------------------------------------------------------- /dhall/Identity/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , adjunction = ./adjunction 4 | , bimonad = ./bimonad 5 | , comonad = ./comonad 6 | , functor = ./functor/package.dhall 7 | , monad = ./monad 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Isomorphism/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Sort) → 2 | λ(a : Kind) → 3 | λ(b : Kind) → 4 | { to : cat.arrow a b, from : cat.arrow b a } 5 | -------------------------------------------------------------------------------- /dhall/Isomorphism/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | The 2-morphism in the 2-category 𝐂𝐚𝐭. 3 | -} 4 | let kCat = ../Category/Cat/semigroupal 5 | 6 | let vObject = Type 7 | 8 | in λ(object : Kind) → 9 | λ(cat : ../Category/Kind kCat vObject object) → 10 | ( λ(a : { _1 : object, _2 : object }) → 11 | { to : cat.arrow a, from : cat.arrow { _1 = a._2, _2 = a._1 } } 12 | ) 13 | : kCat.arrow (kCat.product object object) vObject 14 | -------------------------------------------------------------------------------- /dhall/Isomorphism/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Lan/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Category = ../Category/Kind cat 4 | 5 | let vObject = Type 6 | 7 | in λ(cObject : Kind) → 8 | λ(cpObject : Kind) → 9 | λ(cp : Category vObject cpObject) → 10 | let dObject = Type 11 | 12 | in λ(p : cat.arrow cObject cpObject) → 13 | ( λ(f : cat.arrow cObject dObject) → 14 | λ(a : cpObject) → 15 | ∀(r : Type) → 16 | (∀(b : cObject) → cp.arrow { _1 = p b, _2 = a } → f b → r) → 17 | r 18 | ) 19 | : cat.arrow (cat.arrow cObject dObject) (cat.arrow cpObject dObject) 20 | -------------------------------------------------------------------------------- /dhall/Lan/lift: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | in λ(v : ../Category/Monoidal/Kind kCat Type vObject) → 8 | λ(cat : ../Category/Kind kCat vObject object) → 9 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 10 | λ(f : kCat.arrow object object) → 11 | λ(comonad : ../Comonad/Type object cat f) → 12 | λ(g : kCat.arrow object object) → 13 | λ(a : object) → 14 | λ(x : g a) → 15 | λ(r : Type) → 16 | λ(k : ∀(b : object) → cat.arrow { _1 = f b, _2 = a } → g b → r) → 17 | k a (comonad.unit a) x 18 | -------------------------------------------------------------------------------- /dhall/Lan/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, functor = ./functor, lift = ./lift, lower = ./lower } 2 | -------------------------------------------------------------------------------- /dhall/Lattice/Bounded/Set: -------------------------------------------------------------------------------- 1 | λ(m : Type) → 2 | { join : ../../Semilattice/Bounded/Set m 3 | , meet : ../../Semilattice/Bounded/Set m 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Lattice/Bounded/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { join : ../../Semilattice/Bounded/Type object cat m 9 | , meet : ../../Semilattice/Bounded/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Lattice/Bounded/package.dhall: -------------------------------------------------------------------------------- 1 | { Set = ./Set, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Lattice/Complemented/Set: -------------------------------------------------------------------------------- 1 | λ(m : Type) → { complement : m → m } ⩓ ../Bounded/Set m 2 | -------------------------------------------------------------------------------- /dhall/Lattice/Complemented/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { complement : cat.arrow { _1 = m, _2 = m } } 9 | ⩓ ../Bounded/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Lattice/Complemented/package.dhall: -------------------------------------------------------------------------------- 1 | { Set = ./Set, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Lattice/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { join : ../Semilattice/Type object cat m 9 | , meet : ../Semilattice/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Lattice/extractJoin: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(lattice : ./Type object cat m) → 9 | lattice.join : ../Semigroup/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Lattice/extractMeet: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(lattice : ./Type object cat m) → 9 | lattice.meet : ../Semilattice/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Lattice/package.dhall: -------------------------------------------------------------------------------- 1 | { Bounded = ./Bounded/package.dhall 2 | , Complemented = ./Complemented/package.dhall 3 | , Type = ./Type 4 | , extractJoin = ./extractJoin 5 | , extractMeet = ./extractMeet 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Leibniz/Kind: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Category = ../Category/Kind cat 4 | 5 | let vObject = Type 6 | 7 | in λ(cObject : Kind) → 8 | λ(dObject : Kind) → 9 | λ(c : Category vObject cObject) → 10 | λ(d : Category vObject dObject) → 11 | { constraint = c.constraint 12 | , arrow = 13 | λ(a : { _1 : cObject, _2 : cObject }) → 14 | ∀(f : cat.arrow cObject dObject) → 15 | d.arrow { _1 = f a._1, _2 = f a._2 } 16 | } 17 | : ../Category/Kind cat vObject cObject 18 | -------------------------------------------------------------------------------- /dhall/Leibniz/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, groupoid = ./groupoid } 2 | -------------------------------------------------------------------------------- /dhall/List/functor/compactable: -------------------------------------------------------------------------------- 1 | let P = 2 | https://prelude.dhall-lang.org/v20.1.0/package.dhall 3 | sha256:26b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98 4 | 5 | let cat = ../../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let Set = 10 | ../../Category/Monoidal/Cartesian/extractCategory 11 | cat 12 | vObject 13 | Type 14 | ../../Category/Set/monoidal/cartesian 15 | 16 | let v = Set 17 | 18 | in { map = 19 | λ(a : Type) → 20 | λ(b : Type) → 21 | λ(f : a → Optional b) → 22 | λ(l : List a) → 23 | List/fold 24 | a 25 | l 26 | (List b) 27 | ( λ(x : a) → 28 | λ(acc : List b) → 29 | P.Optional.fold b (f x) (List b) (λ(y : b) → [ y ] # acc) acc 30 | ) 31 | ([] : List b) 32 | } 33 | : ../../Functor/Star/Type vObject Type v Set Optional List 34 | -------------------------------------------------------------------------------- /dhall/List/functor/endo/package.dhall: -------------------------------------------------------------------------------- 1 | { star = ./star } 2 | -------------------------------------------------------------------------------- /dhall/List/functor/monoidal: -------------------------------------------------------------------------------- 1 | ../../Monad/impliedMonoidalFunctor 2 | List 3 | (./endo/star (../../Identity/Type Type) ../../Identity/functor/monoidal) 4 | ../monad 5 | -------------------------------------------------------------------------------- /dhall/List/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { compactable = ./compactable 2 | , endo = ./endo/package.dhall 3 | , monoidal = ./monoidal 4 | } 5 | -------------------------------------------------------------------------------- /dhall/List/monad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractCategory 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in { unit = λ(a : Type) → λ(x : a) → [ x ] 13 | , product = 14 | λ(a : Type) → 15 | λ(mma : List (List a)) → 16 | List/fold 17 | (List a) 18 | mma 19 | (List a) 20 | (λ(x : List a) → λ(y : List a) → x # y) 21 | ([] : List a) 22 | } 23 | : ../Monad/Type Type Set List 24 | -------------------------------------------------------------------------------- /dhall/List/monoid: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(a : Type) → 13 | { unit = λ(_ : {}) → [] : List a 14 | , product = λ(x : { _1 : List a, _2 : List a }) → x._1 # x._2 15 | } 16 | : ../Monoid/Type Type Set (List a) 17 | -------------------------------------------------------------------------------- /dhall/List/package.dhall: -------------------------------------------------------------------------------- 1 | { functor = ./functor/package.dhall 2 | , monad = ./monad 3 | , monoid = ./monoid 4 | , semigroup = ./semigroup 5 | } 6 | -------------------------------------------------------------------------------- /dhall/List/semigroup: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(a : Type) → ../Monoid/extractSemigroup Type Set (List a) (./monoid a) 13 | -------------------------------------------------------------------------------- /dhall/Loop/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **NB**: `unit` would ideally be defined with `: cat.arrow cat.unit m`, but 4 | there’s no Kind-level `{}` to use there. 5 | -} 6 | λ(cat : ../Category/Monoidal/Sort) → 7 | λ(m : Kind) → 8 | { unit : m } ⩓ ../Quasigroup/Kind cat m 9 | -------------------------------------------------------------------------------- /dhall/Loop/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { unit : cat.arrow { _1 = cat.unit, _2 = m } } 9 | ⩓ ../Quasigroup/Type 10 | object 11 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 12 | m 13 | -------------------------------------------------------------------------------- /dhall/Loop/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Magma/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Semigroupal/Sort) → 2 | λ(m : Kind) → 3 | { product : cat.arrow (cat.product m m) m } 4 | -------------------------------------------------------------------------------- /dhall/Magma/Sort: -------------------------------------------------------------------------------- 1 | let object = Kind in { product : object → object → object } 2 | -------------------------------------------------------------------------------- /dhall/Magma/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let SemigroupalCategory = ../Category/Semigroupal/Kind kCat 4 | 5 | let vObject = Type 6 | 7 | in λ(object : Kind) → 8 | λ(cat : SemigroupalCategory vObject object) → 9 | λ(m : object) → 10 | { product : cat.arrow { _1 = cat.product { _1 = m, _2 = m }, _2 = m } } 11 | -------------------------------------------------------------------------------- /dhall/Magma/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Monad/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A monad on a category C is a monoid object in the category of endofunctors in C 3 | induced by composition. 4 | -} 5 | let kCat = ../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let v = 10 | ../Category/Monoidal/Cartesian/extractCategory 11 | kCat 12 | Type 13 | vObject 14 | ../Category/Set/monoidal/cartesian 15 | 16 | in λ(object : Kind) → 17 | λ(cat : ../Category/Kind kCat vObject object) → 18 | ../Monoid/Type 19 | (kCat.arrow object object) 20 | (../Category/Endofunctor/monoidal/monadic object v cat) 21 | -------------------------------------------------------------------------------- /dhall/Monad/impliedStarfunctor: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let vBase = ../Category/Monoidal/extractCategory kCat Type vObject v 13 | 14 | in λ(object : Kind) → 15 | λ(cat : ../Category/Kind kCat vObject object) → 16 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 17 | λ(m : kCat.arrow object object) → 18 | λ(functor : ../Functor/Endo/Type vObject object vBase cat m) → 19 | λ(monad : ./Type object cat m) → 20 | { map = 21 | λ(a : object) → 22 | λ(b : object) → 23 | λ(f : cat.arrow { _1 = a, _2 = m b }) → 24 | semigroupoid.product 25 | { _1 = m a, _2 = m b } 26 | ( λ(r : Type) → 27 | λ ( arrowsOut 28 | : ∀(z : object) → 29 | cat.arrow { _1 = z, _2 = m b } → 30 | cat.arrow { _1 = m a, _2 = z } → 31 | r 32 | ) → 33 | arrowsOut 34 | (m (m b)) 35 | (monad.product b) 36 | (functor.map a (m b) f) 37 | ) 38 | } 39 | : ../Functor/Star/Type vObject object vBase cat m m 40 | -------------------------------------------------------------------------------- /dhall/Monad/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , impliedMonoidalFunctor = ./impliedMonoidalFunctor 3 | , impliedStarfunctor = ./impliedStarfunctor 4 | , terms = ./terms.dhall 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Monad/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let vBase = ../Category/Monoidal/extractCategory kCat Type vObject v 13 | 14 | in λ(object : Kind) → 15 | λ(cat : ../Category/Kind kCat vObject object) → 16 | λ(semigroupoid : ../Semigroupoid/Type object v cat cat.arrow) → 17 | λ(m : kCat.arrow object object) → 18 | λ(functor : ../Functor/Endo/Type vObject object vBase cat m) → 19 | λ(monad : ./Type object cat m) → 20 | let extractStarfunctor = 21 | ./impliedStarfunctor object cat semigroupoid m functor monad 22 | 23 | in { map = functor.map 24 | , pure = monad.unit 25 | , join = monad.product 26 | , bind = extractStarfunctor.map 27 | , extractStarfunctor 28 | } 29 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | A commutative monoid implies a preorder. However, that currently forces us into 3 | **Set**, so we instead just alias the non-commutative type to avoid specializing. 4 | -} 5 | ../Kind 6 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Monus/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { monus : cat.arrow (cat.product m m) m } ⩓ ../Kind cat m 4 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Monus/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | Monus (`∸`, to illustrate its similarity to subtraction) is an operation on some 3 | commutative monoids that aren’t groups. It has the following laws: 4 | - a + (b ∸ a) = b + (a ∸ b) 5 | - (a ∸ b) ∸ c = a ∸ (b + c) 6 | - a ∸ a = unit 7 | - unit ∸ a = unit 8 | -} 9 | let kCat = ../../../Category/Cat/semigroupal 10 | 11 | let vObject = Type 12 | 13 | in λ(object : Kind) → 14 | λ(cat : ../../../Category/Monoidal/Kind kCat vObject object) → 15 | λ(m : object) → 16 | { monus : cat.arrow { _1 = cat.product { _1 = m, _2 = m }, _2 = m } } 17 | ⩓ ../Type object cat m 18 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Monus/extractCommutativeMonoid: -------------------------------------------------------------------------------- 1 | let kCat = ../../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(monoid : ./Type object cat m) → 9 | monoid.{ product, unit } : ../Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Monus/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Type = ./Type 3 | , extractCommutativeMonoid = ./extractCommutativeMonoid 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Set: -------------------------------------------------------------------------------- 1 | {-| 2 | A commutative monoid implies a preorder. Technically, a preorder could be 3 | defined with `≤` where both `x ≤ y` and `y ≤ x` may be false. However, with 4 | structural typing it makes it impossible to distinguish a preordered structure 5 | from a totally-ordered structure. 6 | -} 7 | let kCat = ../../Category/Cat/semigroupal 8 | 9 | let vObject = Type 10 | 11 | let object = Type 12 | 13 | let cat = 14 | ../../Category/Monoidal/Cartesian/extractMonoidal 15 | kCat 16 | vObject 17 | object 18 | ../../Category/Set/monoidal/cartesian 19 | 20 | in λ(m : object) → { le : m → m → Bool } ⩓ ./Type object cat m 21 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A commutative monoid implies a preorder. However, that currently forces us into 3 | **Set**, so we instead just alias the non-commutative type to avoid specializing. 4 | -} 5 | ../Type 6 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/extractMonoid: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../../Category/Monoidal/Cartesian/extractMonoidal 9 | cat 10 | vObject 11 | object 12 | ../../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(monoid : ./Set m) → 16 | monoid.{ unit, product } : ../Type object cat m 17 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/extractSemigroup: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(monoid : ./Type object cat m) → 9 | monoid.{ product } 10 | : ../../Semigroup/Type 11 | object 12 | (../../Category/Monoidal/extractSemigroupal kCat vObject object cat) 13 | m 14 | -------------------------------------------------------------------------------- /dhall/Monoid/Commutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Monus = ./Monus/package.dhall 3 | , Set = ./Set 4 | , Type = ./Type 5 | , extractMonoid = ./extractMonoid 6 | , extractSemigroup = ./extractSemigroup 7 | } 8 | -------------------------------------------------------------------------------- /dhall/Monoid/Hopf/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { antipode : cat.arrow { _1 = m, _2 = m } } 9 | ⩓ ../../Bimonoid/Type object cat m 10 | -------------------------------------------------------------------------------- /dhall/Monoid/Hopf/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Monoid/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **NB**: `unit` would ideally be defined with `: cat.arrow cat.unit m`, but 4 | there’s no Kind-level `{}` to use there. 5 | -} 6 | λ(cat : ../Category/Monoidal/Sort) → 7 | λ(m : Kind) → 8 | { unit : m } ⩓ ../Semigroup/Kind cat m 9 | -------------------------------------------------------------------------------- /dhall/Monoid/Sort: -------------------------------------------------------------------------------- 1 | {- 2 | 3 | **TODO**: Unfortunately, we don’t have the common kind-level units available. So 4 | rather than making a type that can’t be used, we just stick with Semigroup, and 5 | let the desired type be _named_ even if it can’t be implemented yet. 6 | -} 7 | ../Semigroup/Sort 8 | -------------------------------------------------------------------------------- /dhall/Monoid/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { unit : cat.arrow { _1 = cat.unit, _2 = m } } 9 | ⩓ ../Semigroup/Type 10 | object 11 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 12 | m 13 | -------------------------------------------------------------------------------- /dhall/Monoid/extractSemigroup: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(monoid : ./Type object cat m) → 9 | monoid.{ product } 10 | : ../Semigroup/Type 11 | object 12 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 13 | m 14 | -------------------------------------------------------------------------------- /dhall/Monoid/laws: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(eq : ../Eq/Type m) → 16 | λ(monoid : ./Type object cat m) → 17 | { leftIdentity = 18 | λ(a : m) → eq.eq (monoid.product { _1 = monoid.unit {=}, _2 = a }) a 19 | , rightIdentity = 20 | λ(a : m) → eq.eq (monoid.product { _1 = a, _2 = monoid.unit {=} }) a 21 | } 22 | ∧ ../Semigroup/laws m eq (./extractSemigroup object cat m monoid) 23 | -------------------------------------------------------------------------------- /dhall/Monoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Commutative = ./Commutative/package.dhall 2 | , Hopf = ./Hopf/package.dhall 3 | , Kind = ./Kind 4 | , Type = ./Type 5 | , extractSemigroup = ./extractSemigroup 6 | , laws = ./laws 7 | , terms = ./terms.dhall 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Monoid/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(monoid : ./Type object cat m) → 9 | monoid.{ unit } 10 | ∧ ../Semigroup/terms.dhall 11 | object 12 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 13 | m 14 | (./extractSemigroup object cat m monoid) 15 | -------------------------------------------------------------------------------- /dhall/Natural/duoid: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(max : { _1 : Natural, _2 : Natural } → Natural) → 13 | { additive = { unit = λ(_ : {}) → 0, product = max } 14 | , multiplicative = ./monoid 15 | } 16 | : ../Duoid/Type Type Set Natural 17 | -------------------------------------------------------------------------------- /dhall/Natural/monoid: -------------------------------------------------------------------------------- 1 | {-| 2 | Should use ../Monoid/Commutative/Monus/Type, but `monus` is complicated with 3 | recursion, so need to figure out how dada ties into this. 4 | -} 5 | let cat = ../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let Set = 10 | ../Category/Monoidal/Cartesian/extractMonoidal 11 | cat 12 | vObject 13 | Type 14 | ../Category/Set/monoidal/cartesian 15 | 16 | in { unit = λ(_ : {}) → 0 17 | , product = λ(t : { _1 : Natural, _2 : Natural }) → t._1 + t._2 18 | } 19 | : ../Monoid/Commutative/Type Type Set Natural 20 | -------------------------------------------------------------------------------- /dhall/Natural/package.dhall: -------------------------------------------------------------------------------- 1 | { duoid = ./duoid, monoid = ./monoid, rig = ./rig } 2 | -------------------------------------------------------------------------------- /dhall/Natural/rig: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **TODO**: Should be a Rig/Commutative 4 | -} 5 | let cat = ../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | let Set = 10 | ../Category/Monoidal/Cartesian/extractMonoidal 11 | cat 12 | vObject 13 | Type 14 | ../Category/Set/monoidal/cartesian 15 | 16 | in { additive = 17 | { unit = λ(_ : {}) → 0 18 | , product = λ(t : { _1 : Natural, _2 : Natural }) → t._1 + t._2 19 | } 20 | , multiplicative = 21 | { unit = λ(_ : {}) → 1 22 | , product = λ(t : { _1 : Natural, _2 : Natural }) → t._1 * t._2 23 | } 24 | } 25 | : ../Rig/Type Type Set Natural 26 | -------------------------------------------------------------------------------- /dhall/NaturalTransformation/Kind: -------------------------------------------------------------------------------- 1 | λ(f : Kind → Kind) → 2 | λ(g : Kind → Kind) → 3 | (λ(a : Kind) → f a → g a) : Kind → Kind 4 | -------------------------------------------------------------------------------- /dhall/NaturalTransformation/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(cObject : Kind) → 6 | λ(dObject : Kind) → 7 | λ(d : ../Category/Kind cat vObject dObject) → 8 | let object = cat.arrow cObject dObject 9 | 10 | in ( λ(f : { _1 : object, _2 : object }) → 11 | ∀(a : cObject) → d.arrow { _1 = f._1 a, _2 = f._2 a } 12 | ) 13 | : cat.arrow (cat.product object object) vObject 14 | -------------------------------------------------------------------------------- /dhall/NaturalTransformation/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type, category = ./category } 2 | -------------------------------------------------------------------------------- /dhall/Optional/eq: -------------------------------------------------------------------------------- 1 | let P = 2 | https://prelude.dhall-lang.org/v20.1.0/package.dhall 3 | sha256:26b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98 4 | 5 | let Equality = ../Eq/Type 6 | 7 | in λ(a : Type) → 8 | λ(eq : Equality a) → 9 | { eq = 10 | λ(x : Optional a) → 11 | λ(y : Optional a) → 12 | P.Optional.fold 13 | a 14 | x 15 | Bool 16 | (λ(xx : a) → P.Optional.fold a y Bool (eq.eq xx) False) 17 | (P.Optional.fold a y Bool (λ(yy : a) → False) True) 18 | } 19 | : Equality (Optional a) 20 | -------------------------------------------------------------------------------- /dhall/Optional/functor/compactable: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let base = ../../Category/Monoidal/Cartesian/extractCategory cat 4 | 5 | let vObject = Type 6 | 7 | let v = base Type vObject ../../Category/Set/monoidal/cartesian 8 | 9 | let Set = base vObject Type ../../Category/Set/monoidal/cartesian 10 | 11 | in ../../Monad/impliedStarfunctor 12 | Type 13 | Set 14 | ../../Category/Set/semigroupoid 15 | Optional 16 | ( ../functor/endo/star 17 | (../../Identity/Type Type) 18 | ../../Identity/functor/monoidal 19 | ) 20 | ../monad 21 | : ../../Functor/Star/Type vObject Type v Set Optional Optional 22 | -------------------------------------------------------------------------------- /dhall/Optional/functor/endo/package.dhall: -------------------------------------------------------------------------------- 1 | { star = ./star } 2 | -------------------------------------------------------------------------------- /dhall/Optional/functor/monoidal: -------------------------------------------------------------------------------- 1 | ../../Monad/impliedMonoidalFunctor 2 | Optional 3 | (./endo/star (../../Identity/Type Type) ../../Identity/functor/monoidal) 4 | ../monad 5 | -------------------------------------------------------------------------------- /dhall/Optional/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { compactable = ./compactable 2 | , endo = ./endo/package.dhall 3 | , monoidal = ./monoidal 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Optional/monad: -------------------------------------------------------------------------------- 1 | let P = 2 | https://prelude.dhall-lang.org/v20.1.0/package.dhall 3 | sha256:26b0ef498663d269e4dc6a82b0ee289ec565d683ef4c00d0ebdd25333a5a3c98 4 | 5 | let cat = ../Category/Cat/semigroupal 6 | 7 | let category = ../Category/Set/category/instance 8 | 9 | let vObject = Type 10 | 11 | let Set = 12 | ../Category/Monoidal/Cartesian/extractCategory 13 | cat 14 | vObject 15 | Type 16 | ../Category/Set/monoidal/cartesian 17 | 18 | in { unit = λ(a : Type) → λ(x : a) → Some x 19 | , product = 20 | λ(a : Type) → 21 | λ(mma : Optional (Optional a)) → 22 | P.Optional.fold 23 | (Optional a) 24 | mma 25 | (Optional a) 26 | (category.unit (Optional a)) 27 | (None a) 28 | } 29 | : ../Monad/Type Type Set Optional 30 | -------------------------------------------------------------------------------- /dhall/Optional/package.dhall: -------------------------------------------------------------------------------- 1 | { eq = ./eq, functor = ./functor/package.dhall, monad = ./monad } 2 | -------------------------------------------------------------------------------- /dhall/Presheaf/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | A presheaf on a category 𝒞 is a functor 𝒞 ^op^ → 𝐒𝐞𝐭. 3 | -} 4 | let cat = ../Category/Cat/semigroupal 5 | 6 | let Category = ../Category/Kind cat 7 | 8 | let vObject = Type 9 | 10 | in λ(cObject : Kind) → 11 | λ(v : Category Type vObject) → 12 | λ(c : Category vObject cObject) → 13 | ../Functor/Type 14 | vObject 15 | cObject 16 | Type 17 | v 18 | (../Category/Op/Kind vObject cObject c) 19 | ( ../Category/Monoidal/Cartesian/extractCategory 20 | cat 21 | vObject 22 | Type 23 | ../Category/Set/monoidal/cartesian 24 | ) 25 | -------------------------------------------------------------------------------- /dhall/Presheaf/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Quasigroup/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Semigroupal/Sort) → 2 | λ(m : Kind) → 3 | { inverse : cat.arrow m m } ⩓ ../Magma/Kind cat m 4 | -------------------------------------------------------------------------------- /dhall/Quasigroup/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { inverse : cat.arrow { _1 = m, _2 = m } } ⩓ ../Magma/Type object cat m 9 | -------------------------------------------------------------------------------- /dhall/Quasigroup/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Ran/Type: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Category = ../Category/Kind cat 4 | 5 | let vObject = Type 6 | 7 | in λ(cObject : Kind) → 8 | λ(cpObject : Kind) → 9 | λ(cp : Category vObject cpObject) → 10 | let dObject = Type 11 | 12 | in λ(p : cat.arrow cObject cpObject) → 13 | ( λ(f : cat.arrow cObject dObject) → 14 | λ(a : cpObject) → 15 | ∀(b : cObject) → cp.arrow { _1 = a, _2 = p b } → f b 16 | ) 17 | : cat.arrow (cat.arrow cObject dObject) (cat.arrow cpObject dObject) 18 | -------------------------------------------------------------------------------- /dhall/Ran/lower: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let monoidalBase = ../Category/Monoidal/Cartesian/extractMonoidal cat 4 | 5 | let base = ../Category/Monoidal/extractCategory cat 6 | 7 | let vObject = Type 8 | 9 | let v = 10 | base 11 | Type 12 | vObject 13 | (monoidalBase Type vObject ../Category/Set/monoidal/cartesian) 14 | 15 | let cObject = Type 16 | 17 | let cpObject = Type 18 | 19 | let dObject = Type 20 | 21 | let c = monoidalBase vObject cObject ../Category/Set/monoidal/cartesian 22 | 23 | let cp = monoidalBase vObject cpObject ../Category/Set/monoidal/cartesian 24 | 25 | in λ(p : cat.arrow cObject cpObject) → 26 | λ(monoidal : ../Functor/Monoidal/Type cObject v c cp p) → 27 | λ(f : cat.arrow cObject dObject) → 28 | λ(a : cpObject) → 29 | λ(ran : ./Type cObject cpObject (base vObject cpObject cp) p f a) → 30 | ran a (λ(x : a) → monoidal.unit a (λ(_ : c.unit) → x)) 31 | -------------------------------------------------------------------------------- /dhall/Ran/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, functor = ./functor, lift = ./lift, lower = ./lower } 2 | -------------------------------------------------------------------------------- /dhall/Rig/Kind: -------------------------------------------------------------------------------- 1 | {-| 2 | This is what is often called a “semiring”, but here we follow the convention 3 | described in https://ncatlab.org/nlab/show/rig, reserving “semiring” for a rig 4 | without multiplicative unit. 5 | -} 6 | λ(cat : ../Category/Monoidal/Sort) → 7 | λ(m : Kind) → 8 | { additive : ../Monoid/Commutative/Kind cat m 9 | , multiplicative : ../Monoid/Kind cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Rig/Monus/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../../Monoid/Commutative/Monus/Kind cat m 4 | , multiplicative : ../../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Rig/Monus/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | Like the semiring/rig distinction, this is often “semigroup with monus” or 3 | “m-semigroup”, but here it’s “rig with monus”. 4 | -} 5 | let kCat = ../../Category/Cat/semigroupal 6 | 7 | let vObject = Type 8 | 9 | in λ(object : Kind) → 10 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 11 | λ(m : object) → 12 | { additive : ../../Monoid/Commutative/Monus/Type object cat m 13 | , multiplicative : ../../Monoid/Type object cat m 14 | } 15 | -------------------------------------------------------------------------------- /dhall/Rig/Monus/extractRig: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(rig : ./Type object cat m) → 9 | { additive = 10 | ../../Monoid/Commutative/Monus/extractCommutativeMonoid 11 | object 12 | cat 13 | m 14 | rig.additive 15 | , multiplicative = rig.multiplicative 16 | } 17 | : ../Type object cat m 18 | -------------------------------------------------------------------------------- /dhall/Rig/Monus/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type, extractRig = ./extractRig } 2 | -------------------------------------------------------------------------------- /dhall/Rig/Near/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../../Monoid/Kind cat m 4 | , multiplicative : ../../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Rig/Near/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../../Monoid/Type object cat m 9 | , multiplicative : ../../Monoid/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Rig/Near/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Rig/Set: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | { additive : ../Monoid/Commutative/Set m 16 | , multiplicative : ../Monoid/Type object cat m 17 | } 18 | -------------------------------------------------------------------------------- /dhall/Rig/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | This is what is often called a “semiring”, but here we follow the convention 3 | described in https://ncatlab.org/nlab/show/rig, reserving “semiring” for a rig 4 | without multiplicative unit. 5 | -} 6 | let kCat = ../Category/Cat/semigroupal 7 | 8 | let vObject = Type 9 | 10 | in λ(object : Kind) → 11 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 12 | λ(m : object) → 13 | { additive : ../Monoid/Commutative/Type object cat m 14 | , multiplicative : ../Monoid/Type object cat m 15 | } 16 | -------------------------------------------------------------------------------- /dhall/Rig/extractSemiring: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(rig : ./Type object cat m) → 9 | { additive = 10 | ../Monoid/Commutative/extractSemigroup object cat m rig.additive 11 | , multiplicative = rig.multiplicative 12 | } 13 | : ../Semiring/Type object cat m 14 | -------------------------------------------------------------------------------- /dhall/Rig/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Monus = ./Monus/package.dhall 3 | , Near = ./Near/package.dhall 4 | , Set = ./Set 5 | , Type = ./Type 6 | , extractSemiring = ./extractSemiring 7 | , terms = ./terms.dhall 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Rig/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(rig : ./Type object cat m) → 9 | { zero = rig.additive.unit } 10 | ∧ ../Semiring/terms.dhall 11 | object 12 | cat 13 | m 14 | (./extractSemiring object cat m rig) 15 | -------------------------------------------------------------------------------- /dhall/Ring/Commutative/Set: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | { additive : ../../Group/Commutative/Set m 5 | , multiplicative : ../../Monoid/Commutative/Set m 6 | } 7 | -------------------------------------------------------------------------------- /dhall/Ring/Commutative/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../../Group/Commutative/Type object cat m 9 | , multiplicative : ../../Monoid/Commutative/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Ring/Commutative/extractRing: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../../Category/Monoidal/Cartesian/extractMonoidal 9 | kCat 10 | vObject 11 | object 12 | ../../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(ring : ./Set m) → 16 | { additive = ring.additive.{ unit, inverse, product } 17 | , multiplicative = 18 | ../../Monoid/Commutative/extractMonoid m ring.multiplicative 19 | } 20 | : ../Type object cat m 21 | -------------------------------------------------------------------------------- /dhall/Ring/Commutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Set = ./Set, Type = ./Type, extractRing = ./extractRing } 2 | -------------------------------------------------------------------------------- /dhall/Ring/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../Group/Commutative/Kind cat m 4 | , multiplicative : ../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Ring/Near/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../../Group/Kind cat m 4 | , multiplicative : ../../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Ring/Near/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../../Group/Type object cat m 9 | , multiplicative : ../../Monoid/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Ring/Near/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Ring/Ordered/Type: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(m : Type) → 13 | { additive : ../../Group/OrderedCommutative/Type m 14 | , multiplicative : ../../Monoid/Type Type Set m 15 | } 16 | -------------------------------------------------------------------------------- /dhall/Ring/Ordered/extractPartiallyOrderedRing: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(ring : ./Type m) → 5 | { additive = 6 | ../../Group/OrderedCommutative/extractPartiallyOrderedCommutativeGroup 7 | m 8 | ring.additive 9 | , multiplicative = ring.multiplicative 10 | } 11 | : ../PartiallyOrdered/Type m 12 | -------------------------------------------------------------------------------- /dhall/Ring/Ordered/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, extractPartiallyOrderedRing = ./extractPartiallyOrderedRing } 2 | -------------------------------------------------------------------------------- /dhall/Ring/PartiallyOrdered/Type: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(m : Type) → 13 | { additive : ../../Group/PartiallyOrderedCommutative/Type m 14 | , multiplicative : ../../Monoid/Type Type Set m 15 | } 16 | -------------------------------------------------------------------------------- /dhall/Ring/PartiallyOrdered/extractRing: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | in λ(m : Type) → 13 | λ(ring : ./Type m) → 14 | { additive = 15 | ../../Group/PartiallyOrderedCommutative/extractCommutativeGroup 16 | m 17 | ring.additive 18 | , multiplicative = ring.multiplicative 19 | } 20 | : ../Type Type Set m 21 | -------------------------------------------------------------------------------- /dhall/Ring/PartiallyOrdered/extractSetRing: -------------------------------------------------------------------------------- 1 | let object = Type 2 | 3 | in λ(m : object) → 4 | λ(ring : ./Type m) → 5 | { additive = 6 | ../../Group/PartiallyOrderedCommutative/extractSetCommutativeGroup 7 | m 8 | ring.additive 9 | , multiplicative = ring.multiplicative 10 | } 11 | : ../Set m 12 | -------------------------------------------------------------------------------- /dhall/Ring/PartiallyOrdered/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , extractRing = ./extractRing 3 | , extractSetRing = ./extractSetRing 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Ring/Set: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(m : Type) → 13 | { additive : ../Group/Commutative/Set m 14 | , multiplicative : ../Monoid/Type Type Set m 15 | } 16 | -------------------------------------------------------------------------------- /dhall/Ring/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../Group/Commutative/Type object cat m 9 | , multiplicative : ../Monoid/Type object cat m 10 | } 11 | -------------------------------------------------------------------------------- /dhall/Ring/extractRig: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(ring : ./Type object cat m) → 9 | { additive = 10 | ../Group/Commutative/extractCommutativeMonoid 11 | object 12 | cat 13 | m 14 | ring.additive 15 | , multiplicative = ring.multiplicative 16 | } 17 | : ../Rig/Type object cat m 18 | -------------------------------------------------------------------------------- /dhall/Ring/package.dhall: -------------------------------------------------------------------------------- 1 | { Commutative = ./Commutative/package.dhall 2 | , Kind = ./Kind 3 | , Near = ./Near/package.dhall 4 | , Ordered = ./Ordered/package.dhall 5 | , PartiallyOrdered = ./PartiallyOrdered/package.dhall 6 | , Set = ./Set 7 | , Type = ./Type 8 | , extractRig = ./extractRig 9 | , subtract = ./subtract 10 | , terms = ./terms.dhall 11 | } 12 | -------------------------------------------------------------------------------- /dhall/Ring/subtract: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(ring : ./Type object cat m) → 17 | ../Group/Commutative/quotient object cat category m ring.additive 18 | -------------------------------------------------------------------------------- /dhall/Ring/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | kCat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in λ(object : Kind) → 13 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 14 | λ(category : ../Category/Monoidal/Type object v cat) → 15 | λ(m : object) → 16 | λ(ring : ./Type object cat m) → 17 | { negate = ring.additive.inverse 18 | , subtract = ./subtract object cat category m ring 19 | } 20 | ∧ ../Rig/terms.dhall object cat m (./extractRig object cat m ring) 21 | -------------------------------------------------------------------------------- /dhall/Rng/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../Group/Commutative/Kind cat m 4 | , multiplicative : ../Semigroup/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Rng/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : ../Group/Commutative/Type object cat m 9 | , multiplicative : 10 | ../Semigroup/Type 11 | object 12 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 13 | m 14 | } 15 | -------------------------------------------------------------------------------- /dhall/Rng/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Commutative/Kind: -------------------------------------------------------------------------------- 1 | ../Kind 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Commutative/Type: -------------------------------------------------------------------------------- 1 | ../Type 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Commutative/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Inverse/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Semigroupal/Sort) → 2 | λ(m : Kind) → 3 | { inverse : cat.arrow m m } ⩓ ../../Semigroup/Kind cat m 4 | -------------------------------------------------------------------------------- /dhall/Semigroup/Inverse/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { inverse : cat.arrow { _1 = m, _2 = m } } ⩓ ../Type object cat m 9 | -------------------------------------------------------------------------------- /dhall/Semigroup/Inverse/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Kind: -------------------------------------------------------------------------------- 1 | ../Magma/Kind 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Sort: -------------------------------------------------------------------------------- 1 | ../Magma/Sort 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/Type: -------------------------------------------------------------------------------- 1 | ../Magma/Type 2 | -------------------------------------------------------------------------------- /dhall/Semigroup/laws: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let object = Type 6 | 7 | let cat = 8 | ../Category/Monoidal/Cartesian/extractSemigroupal 9 | kCat 10 | vObject 11 | object 12 | ../Category/Set/monoidal/cartesian 13 | 14 | in λ(m : object) → 15 | λ(eq : ../Eq/Type m) → 16 | λ(semigroup : ./Type object cat m) → 17 | { associativity = 18 | λ(a : m) → 19 | λ(b : m) → 20 | λ(c : m) → 21 | eq.eq 22 | ( semigroup.product 23 | { _1 = semigroup.product { _1 = a, _2 = b }, _2 = c } 24 | ) 25 | ( semigroup.product 26 | { _1 = a, _2 = semigroup.product { _1 = b, _2 = c } } 27 | ) 28 | } 29 | -------------------------------------------------------------------------------- /dhall/Semigroup/package.dhall: -------------------------------------------------------------------------------- 1 | { Commutative = ./Commutative/package.dhall 2 | , Inverse = ./Inverse/package.dhall 3 | , Kind = ./Kind 4 | , Type = ./Type 5 | , functor = ./functor 6 | , laws = ./laws 7 | , terms = ./terms.dhall 8 | } 9 | -------------------------------------------------------------------------------- /dhall/Semigroup/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Semigroupal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(semigroup : ./Type object cat m) → 9 | semigroup.{ product } 10 | -------------------------------------------------------------------------------- /dhall/Semigroupoid/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | 3 | **FIXME**: The `hom` profunctor should be implementable generically, however I 4 | can‘t currently get it to compile with Dhall, so it’s a member here, and every 5 | implementation is basically a copy/paste of `compose (compose f g) h`. Embedding 6 | the definition here also basically forces every category to be enriched over 7 | 𝐒𝐞𝐭. 8 | -} 9 | let kCat = ../Category/Cat/semigroupal 10 | 11 | let vObject = Type 12 | 13 | in λ(object : Kind) → 14 | λ(v : ../Category/Monoidal/Kind kCat Type vObject) → 15 | λ(cat : ../Category/Kind kCat vObject object) → 16 | λ(m : kCat.arrow (kCat.product object object) vObject) → 17 | let profunctor = kCat.arrow (kCat.product object object) vObject 18 | 19 | in { hom : ../Functor/Profunctor/Type object object v cat cat m } 20 | ⩓ ../Semigroup/Type 21 | profunctor 22 | (../Category/Profunctor/semigroupal object v cat) 23 | m 24 | -------------------------------------------------------------------------------- /dhall/Semigroupoid/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/Bounded/Kind: -------------------------------------------------------------------------------- 1 | ../../Monoid/Commutative/Kind 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/Bounded/Set: -------------------------------------------------------------------------------- 1 | ../../Monoid/Commutative/Set 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/Bounded/Type: -------------------------------------------------------------------------------- 1 | ../../Monoid/Commutative/Type 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/Bounded/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Set = ./Set, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/Type: -------------------------------------------------------------------------------- 1 | ../Semigroup/Commutative/Type 2 | -------------------------------------------------------------------------------- /dhall/Semilattice/package.dhall: -------------------------------------------------------------------------------- 1 | { Bounded = ./Bounded/package.dhall, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semiring/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../Semigroup/Commutative/Kind cat m 4 | , multiplicative : ../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Semiring/Near/Kind: -------------------------------------------------------------------------------- 1 | λ(cat : ../../Category/Monoidal/Sort) → 2 | λ(m : Kind) → 3 | { additive : ../../Semigroup/Kind cat m 4 | , multiplicative : ../../Monoid/Kind cat m 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Semiring/Near/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | { additive : 9 | ../../Semigroup/Type 10 | object 11 | (../../Category/Monoidal/extractSemigroupal kCat vObject object cat) 12 | m 13 | , multiplicative : ../../Monoid/Type object cat m 14 | } 15 | -------------------------------------------------------------------------------- /dhall/Semiring/Near/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind, Type = ./Type } 2 | -------------------------------------------------------------------------------- /dhall/Semiring/Type: -------------------------------------------------------------------------------- 1 | {-| 2 | This is different from what is often called a “semiring” as it lacks additive 3 | unit, but here we follow the convention described in 4 | https://ncatlab.org/nlab/show/rig, using the name “rig” for what would 5 | traditionally be a semiring. 6 | -} 7 | let kCat = ../Category/Cat/semigroupal 8 | 9 | let vObject = Type 10 | 11 | in λ(object : Kind) → 12 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 13 | λ(m : object) → 14 | { additive : 15 | ../Semigroup/Commutative/Type 16 | object 17 | (../Category/Monoidal/extractSemigroupal kCat vObject object cat) 18 | m 19 | , multiplicative : ../Monoid/Type object cat m 20 | } 21 | -------------------------------------------------------------------------------- /dhall/Semiring/package.dhall: -------------------------------------------------------------------------------- 1 | { Kind = ./Kind 2 | , Near = ./Near/package.dhall 3 | , Type = ./Type 4 | , terms = ./terms.dhall 5 | } 6 | -------------------------------------------------------------------------------- /dhall/Semiring/terms.dhall: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Monoidal/Kind kCat vObject object) → 7 | λ(m : object) → 8 | λ(semiring : ./Type object cat m) → 9 | { add = semiring.additive.product 10 | , multiply = semiring.multiplicative.product 11 | , one = semiring.multiplicative.unit 12 | } 13 | -------------------------------------------------------------------------------- /dhall/Star/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | in λ(vObject : Kind) → 4 | λ(object : Kind) → 5 | λ(cat : ../Category/Kind kCat vObject object) → 6 | λ(m : kCat.arrow object object) → 7 | ( λ(a : { _1 : object, _2 : object }) → 8 | cat.arrow { _1 = a._1, _2 = m a._2 } 9 | ) 10 | : kCat.arrow (kCat.product object object) vObject 11 | -------------------------------------------------------------------------------- /dhall/Star/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type, category = ./category, semigroupoid = ./semigroupoid } 2 | -------------------------------------------------------------------------------- /dhall/Star/semigroupoid: -------------------------------------------------------------------------------- 1 | -- λ(object : Kind) 2 | -- → λ(arrow : object → object → Type) 3 | -- → λ(semigroupoid : ./../Semigroupoid/Type object arrow) 4 | -- → λ(m : object → object) 5 | -- → λ(monad : ./../Monad/Type object arrow m) 6 | -- → ./../Category/extractSemigroupoid 7 | -- object 8 | -- (./type object arrow m) 9 | -- (./category object arrow semigroupoid m monad) 10 | <> 11 | -------------------------------------------------------------------------------- /dhall/Text/monoid: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in { unit = λ(_ : {}) → "" 13 | , product = λ(a : { _1 : Text, _2 : Text }) → a._1 ++ a._2 14 | } 15 | : ../Monoid/Type Type Set Text 16 | -------------------------------------------------------------------------------- /dhall/Text/package.dhall: -------------------------------------------------------------------------------- 1 | { monoid = ./monoid } 2 | -------------------------------------------------------------------------------- /dhall/Tuple/adjunction: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Set = ../Category/Set/monoidal/cartesian 4 | 5 | let base = ../Category/Monoidal/Cartesian/extractCategory cat 6 | 7 | let vObject = Type 8 | 9 | let v = base Type vObject ../Category/Set/monoidal/cartesian 10 | 11 | in λ(s : Type) → 12 | { unit = λ(a : Type) → λ(x : a) → λ(y : s) → { _1 = y, _2 = x } 13 | , counit = λ(a : Type) → λ(x : { _1 : s, _2 : s → a }) → x._2 x._1 14 | , leftAdjunct = 15 | λ(a : Type) → 16 | λ(b : Type) → 17 | λ(f : { _1 : s, _2 : a } → b) → 18 | λ(x : a) → 19 | λ(y : s) → 20 | f { _1 = y, _2 = x } 21 | , rightAdjunct = 22 | λ(a : Type) → 23 | λ(b : Type) → 24 | λ(f : a → s → b) → 25 | λ(t : { _1 : s, _2 : a }) → 26 | f t._2 t._1 27 | } 28 | : ../Adjunction/Type 29 | Type 30 | Type 31 | v 32 | (base vObject Type Set) 33 | (base vObject Type Set) 34 | (λ(a : Type) → Set.product { _1 = s, _2 = a }) 35 | (λ(a : Type) → Set.arrow { _1 = s, _2 = a }) 36 | -------------------------------------------------------------------------------- /dhall/Tuple/comonad: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let Set = ../Category/Set/monoidal/cartesian 4 | 5 | let vObject = Type 6 | 7 | let base = ../Category/Monoidal/Cartesian/extractCategory cat vObject Type Set 8 | 9 | in λ(a : Type) → 10 | { unit = λ(b : Type) → λ(tup : Set.product { _1 = a, _2 = b }) → tup._2 11 | , product = 12 | λ(b : Type) → 13 | λ(tup : Set.product { _1 = a, _2 = b }) → 14 | { _1 = tup._1, _2 = tup } 15 | } 16 | : ../Comonad/Type Type base (λ(b : Type) → Set.product { _1 = a, _2 = b }) 17 | -------------------------------------------------------------------------------- /dhall/Tuple/functor/endo/package.dhall: -------------------------------------------------------------------------------- 1 | { star = ./star } 2 | -------------------------------------------------------------------------------- /dhall/Tuple/functor/endo/star: -------------------------------------------------------------------------------- 1 | let kCat = ../../../Category/Cat/semigroupal 2 | 3 | let Set = ../../../Category/Set/monoidal/cartesian 4 | 5 | let base = ../../../Category/Monoidal/Cartesian/extractCategory kCat 6 | 7 | let vObject = Type 8 | 9 | let v = base Type vObject ../../../Category/Set/monoidal/cartesian 10 | 11 | let cat = base vObject Type Set 12 | 13 | in λ(m : kCat.arrow Type Type) → 14 | λ(functor : ../../../Functor/Endo/Type vObject Type v cat m) → 15 | λ(a : Type) → 16 | { map = 17 | λ(b : Type) → 18 | λ(c : Type) → 19 | λ(f : b → m c) → 20 | λ(t : Set.product { _1 = a, _2 = b }) → 21 | functor.map 22 | c 23 | (Set.product { _1 = a, _2 = c }) 24 | (λ(x : c) → t ⫽ { _2 = x }) 25 | (f t._2) 26 | } 27 | : ../../../Functor/Endo/Star/Type 28 | vObject 29 | Type 30 | v 31 | cat 32 | m 33 | (λ(b : Type) → Set.product { _1 = a, _2 = b }) 34 | -------------------------------------------------------------------------------- /dhall/Tuple/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { endo = ./endo/package.dhall } 2 | -------------------------------------------------------------------------------- /dhall/Tuple/package.dhall: -------------------------------------------------------------------------------- 1 | { adjunction = ./adjunction 2 | , comonad = ./comonad 3 | , functor = ./functor/package.dhall 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Unit/eq: -------------------------------------------------------------------------------- 1 | ../Group/PartiallyOrdered/extractEq {} ./partiallyOrderedGroup 2 | -------------------------------------------------------------------------------- /dhall/Unit/orderedGroup: -------------------------------------------------------------------------------- 1 | let Order = ../Group/Ordered/Order 2 | 3 | in { eq = λ(_ : {}) → λ(_ : {}) → True 4 | , unit = λ(_ : {}) → {=} 5 | , inverse = λ(_ : {}) → {=} 6 | , le = λ(_ : {}) → λ(_ : {}) → True 7 | , product = λ(_ : { _1 : {}, _2 : {} }) → {=} 8 | , compare = λ(_ : {}) → λ(_ : {}) → Order.EQ 9 | } 10 | : ../Group/Ordered/Type {} 11 | -------------------------------------------------------------------------------- /dhall/Unit/package.dhall: -------------------------------------------------------------------------------- 1 | { eq = ./eq 2 | , orderedGroup = ./orderedGroup 3 | , partiallyOrderedGroup = ./partiallyOrderedGroup 4 | } 5 | -------------------------------------------------------------------------------- /dhall/Unit/partiallyOrderedGroup: -------------------------------------------------------------------------------- 1 | ../Group/Ordered/extractPartiallyOrderedGroup {} ./orderedGroup 2 | -------------------------------------------------------------------------------- /dhall/Void/eq: -------------------------------------------------------------------------------- 1 | { eq = λ(_ : <>) → λ(_ : <>) → False } : ../Eq/Type <> 2 | -------------------------------------------------------------------------------- /dhall/Void/package.dhall: -------------------------------------------------------------------------------- 1 | { eq = ./eq, semigroup = ./semigroup } 2 | -------------------------------------------------------------------------------- /dhall/Void/semigroup: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let Set = 6 | ../Category/Monoidal/Cartesian/extractSemigroupal 7 | cat 8 | vObject 9 | Type 10 | ../Category/Set/monoidal/cartesian 11 | 12 | in { product = λ(p : { _1 : <>, _2 : <> }) → merge {=} p._1 : <> } 13 | : ../Semigroup/Type Type Set <> 14 | -------------------------------------------------------------------------------- /dhall/Yoneda/Type: -------------------------------------------------------------------------------- 1 | let kCat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | in λ(object : Kind) → 6 | λ(cat : ../Category/Kind kCat vObject object) → 7 | ../Ran/Type object object cat (../Identity/Type object) 8 | -------------------------------------------------------------------------------- /dhall/Yoneda/functor/instance: -------------------------------------------------------------------------------- 1 | let cat = ../../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ../../Category/Set/monoidal/cartesian 11 | 12 | let vBase = ../../Category/Monoidal/extractCategory cat Type vObject v 13 | 14 | in λ(cObject : Kind) → 15 | λ(c : ../../Category/Kind cat vObject cObject) → 16 | λ(cSemigroupoid : ../../Semigroupoid/Type cObject v c c.arrow) → 17 | let dObject = Type 18 | 19 | let d = 20 | ../../Category/Monoidal/Cartesian/extractCategory 21 | cat 22 | vObject 23 | dObject 24 | ../../Category/Set/monoidal/cartesian 25 | 26 | in λ(f : cat.arrow cObject dObject) → 27 | ../../Ran/functor 28 | cObject 29 | cObject 30 | c 31 | cSemigroupoid 32 | (../../Identity/Type cObject) 33 | f 34 | : ../../Functor/Type 35 | vObject 36 | cObject 37 | dObject 38 | vBase 39 | c 40 | d 41 | (../Type cObject c f) 42 | -------------------------------------------------------------------------------- /dhall/Yoneda/functor/monoidal: -------------------------------------------------------------------------------- 1 | -- let Applicative = ./../Applicative/Type Type ./../Function/Type 2 | 3 | -- in λ(f : Type → Type) 4 | -- → λ(applicative : Applicative f) 5 | -- → { unit = 6 | -- λ(a : Type) 7 | -- → λ(x : a) 8 | -- → λ(b : Type) 9 | -- → λ(f : a → b) 10 | -- → applicative.unit b (f x) 11 | -- , ap = 12 | -- λ(a : Type) 13 | -- → λ(b : Type) 14 | -- → λ(m : ./Type f (a → b)) 15 | -- → λ(n : ./Type f a) 16 | -- → λ(c : Type) 17 | -- → λ(k : b → c) 18 | -- → applicative.ap 19 | -- a 20 | -- c 21 | -- (m (a → c) (λ(l : a → b) → λ(y : a) → k (l y))) 22 | -- (./lower f a n) 23 | -- } 24 | -- : Applicative (./Type f) 25 | <> 26 | -------------------------------------------------------------------------------- /dhall/Yoneda/functor/package.dhall: -------------------------------------------------------------------------------- 1 | { instance = ./instance, monoidal = ./monoidal } 2 | -------------------------------------------------------------------------------- /dhall/Yoneda/lift: -------------------------------------------------------------------------------- 1 | let cat = ../Category/Cat/semigroupal 2 | 3 | let vObject = Type 4 | 5 | let v = 6 | ../Category/Monoidal/Cartesian/extractMonoidal 7 | cat 8 | Type 9 | vObject 10 | ../Category/Set/monoidal/cartesian 11 | 12 | let vBase = ../Category/Monoidal/extractCategory cat Type vObject v 13 | 14 | let Category = ../Category/Kind cat vObject 15 | 16 | in λ(cObject : Kind) → 17 | λ(c : Category cObject) → 18 | λ(dObject : Kind) → 19 | λ(d : Category dObject) → 20 | λ(dCategory : ../Category/Type dObject v d) → 21 | λ(f : cat.arrow cObject dObject) → 22 | λ(functor : ../Functor/Type vObject cObject dObject vBase c d f) → 23 | ../Ran/lift 24 | cObject 25 | cObject 26 | dObject 27 | c 28 | d 29 | (../Category/extractSemigroupoid dObject v d dCategory) 30 | f 31 | functor 32 | (../Identity/Type cObject) 33 | f 34 | (λ(a : cObject) → dCategory.unit (f a)) 35 | -------------------------------------------------------------------------------- /dhall/Yoneda/lower: -------------------------------------------------------------------------------- 1 | ../Ran/lower (../Identity/Type Type) ../Identity/functor/monoidal 2 | -------------------------------------------------------------------------------- /dhall/Yoneda/monad: -------------------------------------------------------------------------------- 1 | -- let Monad = ./../Monad/Type Type ./../Function/Type 2 | 3 | -- in λ(f : Type → Type) 4 | -- → λ(monad : Monad f) 5 | -- → { unit = 6 | -- λ(a : Type) 7 | -- → λ(x : a) 8 | -- → λ(b : Type) 9 | -- → λ(f : a → b) 10 | -- → monad.unit b (f x) 11 | -- , bind = 12 | -- λ(a : Type) 13 | -- → λ(b : Type) 14 | -- → λ(k : a → ./Type f b) 15 | -- → λ(yoneda : ./Type f a) 16 | -- → λ(c : Type) 17 | -- → λ(l : b → c) 18 | -- → monad.bind a c (λ(x : a) → k x c l) (./lower f a yoneda) 19 | -- } 20 | -- : Monad (./Type f) 21 | <> 22 | -------------------------------------------------------------------------------- /dhall/Yoneda/package.dhall: -------------------------------------------------------------------------------- 1 | { Type = ./Type 2 | , functor = ./functor/package.dhall 3 | , lift = ./lift 4 | , lower = ./lower 5 | , monad = ./monad 6 | } 7 | -------------------------------------------------------------------------------- /garnix.yaml: -------------------------------------------------------------------------------- 1 | builds: 2 | exclude: 3 | # TODO: Remove once garnix-io/garnix#285 is fixed. 4 | - "homeConfigurations.x86_64-darwin-caterwaul-example" 5 | include: 6 | - "*.*" 7 | - "*.*.*" 8 | -------------------------------------------------------------------------------- /renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json", 3 | "extends": ["config:base"], 4 | "nix": { 5 | "enabled": true 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /scripts/generate-packages: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -euo pipefail 4 | 5 | function generate_package () { 6 | package_dir="${1}" 7 | package_file="${package_dir}/package.dhall" 8 | 9 | echo "{ " > "${package_file}" 10 | 11 | for file in $(ls "${package_dir}"); do 12 | if [[ $file != "package.dhall" ]]; then 13 | if [[ -d "${package_dir}/${file}" ]]; then 14 | (generate_package "${package_dir}/${file}") 15 | echo "${file} = ./${file}/package.dhall, " >> "${package_file}" 16 | else 17 | ## Can’t inclued `Sort`s in a record. 18 | type=$(dhall resolve <<< "${package_dir}/${file}" | dhall type) 19 | if [[ "${type}" =~ Sort$ ]]; then 20 | echo "skipping Sort ${package_dir}/${file}" 21 | else 22 | echo "${file/%.dhall} = ./${file}, " >> "${package_file}" 23 | fi 24 | fi 25 | fi 26 | done 27 | 28 | echo "}" >> "${package_file}" 29 | 30 | dhall lint "${package_file}" 31 | } 32 | 33 | generate_package ./dhall 34 | --------------------------------------------------------------------------------