Paper is a Java library typically used in Plugin, Minecraft applications. Paper has no bugs, it has no vulnerabilities and it has medium support. However Paper build file is not available and it has a Non-SPDX License. You can download it from GitHub.

Paper [![Paper Build Status](https://img.shields.io/github/workflow/status/PaperMC/Paper/Build%20Paper/master)](https://github.com/PaperMC/Paper/actions) [![Discord](https://img.shields.io/discord/289587909051416579.svg?label=&logo=discord&logoColor=ffffff&color=7389D8&labelColor=6A7EC2)](https://discord.gg/papermc) [![GitHub Sponsors](https://img.shields.io/github/sponsors/papermc?label=GitHub%20Sponsors)](https://github.com/sponsors/PaperMC) [![Open Collective](https://img.shields.io/opencollective/all/papermc?label=OpenCollective%20Sponsors)](https://opencollective.com/papermc).

Support

Support

Quality

Quality

Security

Security

License

License

Reuse

Reuse

Support

- Paper has a medium active ecosystem.
- It has 5799 star(s) with 1530 fork(s). There are 168 watchers for this library.
- It had no major release in the last 12 months.
- There are 281 open issues and 4527 have been closed. On average issues are closed in 27 days. There are 240 open pull requests and 0 closed requests.
- It has a neutral sentiment in the developer community.
- The latest version of Paper is downloads

Paper Support

Best in #Plugin

Average in #Plugin

Paper Support

Best in #Plugin

Average in #Plugin

Quality

- Paper has 0 bugs and 0 code smells.

Paper Quality

Best in #Plugin

Average in #Plugin

Paper Quality

Best in #Plugin

Average in #Plugin

Security

- Paper has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
- Paper code analysis shows 0 unresolved vulnerabilities.
- There are 0 security hotspots that need review.

Paper Security

Best in #Plugin

Average in #Plugin

Paper Security

Best in #Plugin

Average in #Plugin

License

- Paper has a Non-SPDX License.
- Non-SPDX licenses can be open source with a non SPDX compliant license, or non open source licenses, and you need to review them closely before use.

Paper License

Best in #Plugin

Average in #Plugin

Paper License

Best in #Plugin

Average in #Plugin

Reuse

- Paper releases are available to install and integrate.
- Paper has no build file. You will be need to create the build yourself to build the component from source.
- Installation instructions are not available. Examples and code snippets are available.

Paper Reuse

Best in #Plugin

Average in #Plugin

Paper Reuse

Best in #Plugin

Average in #Plugin

Top functions reviewed by kandi - BETA

Coming Soon for all Libraries!

Currently covering the most popular Java, JavaScript and Python libraries. See a SAMPLE HERE.

kandi's functional review helps you automatically verify the functionalities of the libraries and avoid rework.

See our API patches [here](patches/api)

See upcoming, pending, and recently added API [here](https://github.com/PaperMC/Paper/projects/6)

Paper API javadocs here: [papermc.io/javadocs](https://papermc.io/javadocs/)

Maven Repo (for paper-api):

Artifact Information:

default

CopyDownload

```
Paperclip is a jar file that you can download and run just like a normal jar file.
Download Paper from our [downloads page](https://papermc.io/downloads).
Run the Paperclip jar directly from your server. Just like old times
* Documentation on using Paper: [paper.readthedocs.io](https://paper.readthedocs.io/)
* For a sneak peek on upcoming features, [see here](https://github.com/PaperMC/Paper/projects)
How To (Plugin Developers)
```

Indexed Initial algebras for GADTs

CopyDownload

```
data RepF rep :: * -> * where
Int :: RepF rep Int
Pair :: forall a b. rep a -> rep b -> RepF rep (a, b)
```

```
newtype Rep t = Rep { fold :: forall rep. Algebra rep -> rep t }
type Algebra rep = RepF rep ~> rep
type f ~> g = forall t. f t -> g t
```

-----------------------
```
data RepF rep :: * -> * where
Int :: RepF rep Int
Pair :: forall a b. rep a -> rep b -> RepF rep (a, b)
```

```
newtype Rep t = Rep { fold :: forall rep. Algebra rep -> rep t }
type Algebra rep = RepF rep ~> rep
type f ~> g = forall t. f t -> g t
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

-----------------------
```
data U where
UPair :: U -> U -> U
UInt :: U
```

```
data Pair α β = Pair {outl :: α, outr :: β}
data Unit = Unit
type family Star (u :: U) :: * where
Star (UPair a b) = Pair (Star a) (Star b)
Star UInt = Int
```

```
data DRep :: U -> * where
DPair :: DRep a -> DRep b -> DRep (UPair a b)
DInt :: DRep UInt
```

```
toStar :: DRep a -> Star a
toStar DInt = 0
toStar (DPair a b) = Pair (toStar a) (toStar b)
```

```
-- Object mapping of the endofunctor RepF :: (U->Hask) -> (U->Hask)
-- object of the source category (U->Hask) are transported to
-- object of the target category (U->Hask)
data RepF (m :: U -> *) :: U -> * where
FPair :: m a -> m b -> RepF m (UPair a b)
FInt :: RepF m UInt
-- Morphism mapping of endofunctors :: (U->Hask) -> (U->Hask)
-- morphisms of the source category (U->Hask) are transported to
-- morphisms in the target category (U->Hask)
-- between the transported objects
class UFunctor (h :: ((U -> *) -> U -> *)) where
umap :: (forall (i :: U). m i -> n i) -> h m i -> h n i
-- Morphism mapping (implicit form) of the endofunctor RepF :: (U->Hask) -> (U->Hask)
instance UFunctor RepF where
umap n = \case
FPair ma mb -> FPair (n ma) (n mb)
FInt -> FInt
-- We call repF the explicit action on morphism of RepF
repF :: (forall i. m i -> n i) -> RepF m i -> RepF n i
repF = umap
```

```
h m ~> m
```

```
α_a :: h (m a) ~> m a
```

```
type UAlg h m = forall (i :: U). h m i -> m i
-- rep is an RepF-algebra of carrier DRep
rep :: forall (x :: U). RepF DRep x -> DRep x
rep (FPair ra rb) = DPair ra rb
rep FInt = DInt
```

```
-- This algebra rep is initial
-- This is a witness of initiality -- using the functor instance repF
foldRep :: (forall a. RepF m a -> m a) -> DRep x -> m x
foldRep halg = halg . repF (foldRep halg) . repinv
where
repinv :: DRep x -> RepF DRep x
repinv (DPair ma mb) = FPair ma mb
repinv DInt = FInt
```

```
type UChurch t x = forall (m :: U -> *). (forall (i :: U). t m i -> m i) -> m x
```

```
-- Church Encoding de Hinze
newtype Rep x = Rep {eval :: forall rep. ChurchAlg rep -> rep x}
data ChurchAlg (rep :: * -> *) = ChurchAlg
{ pair_ :: forall a b. rep a -> rep b -> rep (Pair a b),
int_ :: rep Int
}
```

```
type URep x = UChurch RepF x
-- = forall m. (forall (a :: U). RepF m a -> m a) -> m x
-- = forall m. (
-- pair_ :: RepF m (UPair a b) -> m (UPair a b)
-- int_ :: RepF m UInt -> n UInt ) -> m x
-- = forall m. (
-- pair_ :: m a -> m b -> m (UPair a b)
-- int_ :: m UInt ) -> m x
```

```
-- rep is an RepF-algebra of carrier Rep
rep :: forall x. RepF Rep x -> Rep x
rep FInt = Int
rep (FPair ra rb) = Pair ra rb
```

```
repChar (v :: RepF Rep Char) = rep @Char v
```

```
repChar (v :: RepF Rep Char) = error "impossible"
```

expo-barcode-scanner only works once with react-native version 0.64.2 and expo 43.0.0

CopyDownload

```
import React, { useState, useEffect } from 'react';
import { StyleSheet, Text, View, TouchableOpacity } from 'react-native';
import { Camera } from 'expo-camera';
const QrcodeReader = ({navigation}) => {
const [hasPermission, setHasPermission] = useState(null);
const [type, setType] = useState(Camera.Constants.Type.back);
useEffect(() => {
(async () => {
const { status } = await Camera.requestCameraPermissionsAsync();
setHasPermission(status === 'granted');
})();
}, []);
if (hasPermission === null) {
return <View />;
}
if (hasPermission === false) {
return <Text>No access to camera</Text>;
}
return(
<View style={styles.container}>
<Camera
onBarCodeScanned={(...args) => {
const data = args[0].data;
result = JSON.stringify(result);
console.log(result);
navigation.navigate('your_next_screen',{result});
);
}}
barCodeScannerSettings={{
barCodeTypes: ['qr'],
}}
style={{ flex: 1 }}
/>
</View>
);
}
const styles = StyleSheet.create({
container: {
flex: 1,
},
camera: {
flex: 1,
},
buttonContainer: {
flex: 1,
backgroundColor: 'transparent',
flexDirection: 'row',
margin: 20,
},
button: {
flex: 0.1,
alignSelf: 'flex-end',
alignItems: 'center',
},
text: {
fontSize: 18,
color: 'white',
},
});
export default QrcodeReader;
```

What is the significance of 'strongly happens before' compared to '(simply) happens before'?

CopyDownload

```
atomic_int x = 0, y = 0;
int a = 0, b = 0, c = 0;
// Thread 1
x.store(1, seq_cst);
y.store(1, release);
// Thread 2
b = y.fetch_add(1, seq_cst); // b = 1 (the value of y before increment)
c = y.load(relaxed); // c = 3
// Thread 3
y.store(3, seq_cst);
a = x.load(seq_cst); // a = 0
```

```
.-- T3 y.store(3, seq_cst); --. (2)
| | | strongly
| | sequenced before | happens
| V | before
| T3 a = x.load(seq_cst); // a = 0 --. <-' (3)
| : coherence-
| : ordered
| : before
| T1 x.store(1, seq_cst); <-' --. --. (4)
| | |st |
| | sequenced before |h |
| V |b |
| . T1 y.store(1, release); <-' |
| | : | strongly
| | : synchronizes with | happens
| | V | before
| > T2 b = y.fetch_add(1, seq_cst); // b = 1 --. | (1)
| | |st |
| | sequenced before |h |
| V |b |
'-> T2 c = y.load(relaxed); // c = 3 <-' <-'
```

-----------------------
```
atomic_int x = 0, y = 0;
int a = 0, b = 0, c = 0;
// Thread 1
x.store(1, seq_cst);
y.store(1, release);
// Thread 2
b = y.fetch_add(1, seq_cst); // b = 1 (the value of y before increment)
c = y.load(relaxed); // c = 3
// Thread 3
y.store(3, seq_cst);
a = x.load(seq_cst); // a = 0
```

```
.-- T3 y.store(3, seq_cst); --. (2)
| | | strongly
| | sequenced before | happens
| V | before
| T3 a = x.load(seq_cst); // a = 0 --. <-' (3)
| : coherence-
| : ordered
| : before
| T1 x.store(1, seq_cst); <-' --. --. (4)
| | |st |
| | sequenced before |h |
| V |b |
| . T1 y.store(1, release); <-' |
| | : | strongly
| | : synchronizes with | happens
| | V | before
| > T2 b = y.fetch_add(1, seq_cst); // b = 1 --. | (1)
| | |st |
| | sequenced before |h |
| V |b |
'-> T2 c = y.load(relaxed); // c = 3 <-' <-'
```

Detecting compile-time constantness of range size

CopyDownload

```
#include <ranges>
#include <array>
#include <span>
template<class>
inline constexpr bool is_std_array = false;
template<class T, std::size_t N>
inline constexpr bool is_std_array<std::array<T, N>> = true;
template<class>
inline constexpr bool is_std_span = false;
template<class T, std::size_t N>
inline constexpr bool is_std_span<std::span<T, N>> = true;
template<auto>
struct require_constant;
template<class R>
constexpr auto get_constexpr_size() {
if constexpr (std::is_bounded_array_v<R>)
return std::extent_v<R>;
else if constexpr (is_std_array<R>)
return std::tuple_size_v<R>;
else if constexpr (is_std_span<R>)
return R::extent;
else if constexpr (std::ranges::sized_range<R> &&
requires { typename require_constant<R::size()>; })
return R::size();
else
return std::dynamic_extent;
}
```

```
template<std::ranges::input_range R, std::copy_constructible F>
constexpr auto transform(R&& r, F f) {
using value_type = std::remove_cvref_t<
std::indirect_result_t<F&, std::ranges::iterator_t<R>>>;
using DR = std::remove_cvref_t<R>;
constexpr auto size = get_constexpr_size<DR>();
if constexpr (size != std::dynamic_extent) {
std::array<value_type, size> arr;
std::ranges::transform(r, arr.begin(), std::move(f));
return arr;
} else {
std::vector<value_type> v;
if constexpr (requires { std::ranges::size(r); })
v.reserve(std::ranges::size(r));
std::ranges::transform(r, std::back_inserter(v), std::move(f));
return v;
}
}
```

-----------------------
```
#include <ranges>
#include <array>
#include <span>
template<class>
inline constexpr bool is_std_array = false;
template<class T, std::size_t N>
inline constexpr bool is_std_array<std::array<T, N>> = true;
template<class>
inline constexpr bool is_std_span = false;
template<class T, std::size_t N>
inline constexpr bool is_std_span<std::span<T, N>> = true;
template<auto>
struct require_constant;
template<class R>
constexpr auto get_constexpr_size() {
if constexpr (std::is_bounded_array_v<R>)
return std::extent_v<R>;
else if constexpr (is_std_array<R>)
return std::tuple_size_v<R>;
else if constexpr (is_std_span<R>)
return R::extent;
else if constexpr (std::ranges::sized_range<R> &&
requires { typename require_constant<R::size()>; })
return R::size();
else
return std::dynamic_extent;
}
```

```
template<std::ranges::input_range R, std::copy_constructible F>
constexpr auto transform(R&& r, F f) {
using value_type = std::remove_cvref_t<
std::indirect_result_t<F&, std::ranges::iterator_t<R>>>;
using DR = std::remove_cvref_t<R>;
constexpr auto size = get_constexpr_size<DR>();
if constexpr (size != std::dynamic_extent) {
std::array<value_type, size> arr;
std::ranges::transform(r, arr.begin(), std::move(f));
return arr;
} else {
std::vector<value_type> v;
if constexpr (requires { std::ranges::size(r); })
v.reserve(std::ranges::size(r));
std::ranges::transform(r, std::back_inserter(v), std::move(f));
return v;
}
}
```

Is std::decay_t<T> decay_copy(T&&) equivalent to auto decay_copy(auto&&)?

CopyDownload

```
struct X {
X();
X(X&);
};
```

How to calculate correlation coefficients using sklearn CCA module?

CopyDownload

```
import numpy as np
from matplotlib import pyplot as plt
from sklearn.cross_decomposition import CCA
# rows contain the number of samples for CCA and the number of rvs goes in columns
X = np.random.randn(2000, 100)
Y = np.random.randn(2000, 50)
# num of components
n_comps = min(X.shape[1], Y.shape[1])
cca = CCA(n_components=n_comps)
cca.fit(X, Y)
X_c, Y_c = cca.transform(X, Y)
# calculate and plot the correlations of all components
corrs = [np.corrcoef(X_c[:, i], Y_c[:, i])[0, 1] for i in range(n_comps)]
plt.plot(corrs)
plt.xlabel('cca_idx')
plt.ylabel('cca_corr')
plt.show()
```

```
Y = np.dot(X, np.random.randn(100, 100))
```

-----------------------
```
import numpy as np
from matplotlib import pyplot as plt
from sklearn.cross_decomposition import CCA
# rows contain the number of samples for CCA and the number of rvs goes in columns
X = np.random.randn(2000, 100)
Y = np.random.randn(2000, 50)
# num of components
n_comps = min(X.shape[1], Y.shape[1])
cca = CCA(n_components=n_comps)
cca.fit(X, Y)
X_c, Y_c = cca.transform(X, Y)
# calculate and plot the correlations of all components
corrs = [np.corrcoef(X_c[:, i], Y_c[:, i])[0, 1] for i in range(n_comps)]
plt.plot(corrs)
plt.xlabel('cca_idx')
plt.ylabel('cca_corr')
plt.show()
```

```
Y = np.dot(X, np.random.randn(100, 100))
```

I worked on a private repo in GitHub then made it public. Can I make my activity visible?

CopyDownload

```
git config user.name
git config user.email
```

```
git push --force # at least for the main/master branch
```

-----------------------
```
git config user.name
git config user.email
```

```
git push --force # at least for the main/master branch
```

Module not found: Can't resolve '@emotion/react' in 'E:\frontend\node_modules\@mui\styled-engine'

CopyDownload

```
npm i @emotion/react @emotion/styled
```

What is this odd sorting algorithm?

CopyDownload

```
for i from 0 to n-1:
for j from 0 to n-1:
if A[j] > A[i]:
swap A[i] and A[j]
print(A) <- add here
```

```
A = [5, 5, 0, 9, 2]
0. [9, 5, 0, 5, 2]
1. [5, 9, 0, 5, 2]
2. [0, 5, 9, 5, 2]
3. [0, 5, 5, 9, 2]
4. [0, 2, 5, 5, 9]
```

```
for i from 0 to n-1:
for j from 0 to i: <- claim this line can be changed
if A[j] > A[i]:
swap A[i] and A[j]
```

-----------------------
```
for i from 0 to n-1:
for j from 0 to n-1:
if A[j] > A[i]:
swap A[i] and A[j]
print(A) <- add here
```

```
A = [5, 5, 0, 9, 2]
0. [9, 5, 0, 5, 2]
1. [5, 9, 0, 5, 2]
2. [0, 5, 9, 5, 2]
3. [0, 5, 5, 9, 2]
4. [0, 2, 5, 5, 9]
```

```
for i from 0 to n-1:
for j from 0 to i: <- claim this line can be changed
if A[j] > A[i]:
swap A[i] and A[j]
```

-----------------------
```
for i from 0 to n-1:
for j from 0 to n-1:
if A[j] > A[i]:
swap A[i] and A[j]
print(A) <- add here
```

```
A = [5, 5, 0, 9, 2]
0. [9, 5, 0, 5, 2]
1. [5, 9, 0, 5, 2]
2. [0, 5, 9, 5, 2]
3. [0, 5, 5, 9, 2]
4. [0, 2, 5, 5, 9]
```

```
for i from 0 to n-1:
for j from 0 to i: <- claim this line can be changed
if A[j] > A[i]:
swap A[i] and A[j]
```

-----------------------
```
from random import shuffle
def assert_partial_sort_order(A, i):
"""
Assert A[j] <= A[j+1] for j < i
"""
for j in range(i):
assert A[j] <= A[j+1]
def sort(A):
n = len(A)
print('sort before:', A)
n_swaps = 0
for i in range(n):
print('i =', i)
for j in range(n):
if A[j] > A[i]:
A[i], A[j] = A[j], A[i]
print(' swapping for j =', j)
print(' A =', A)
assert_partial_sort_order(A, i)
print('sort after:', A, '\n')
n = 10
A = list(range(n))
shuffle(A)
sort(A)
```

```
sort before: [7, 0, 4, 2, 8, 9, 5, 1, 3, 6]
i = 0
swapping for j = 4
A = [8, 0, 4, 2, 7, 9, 5, 1, 3, 6]
swapping for j = 5
A = [9, 0, 4, 2, 7, 8, 5, 1, 3, 6]
i = 1
swapping for j = 0
A = [0, 9, 4, 2, 7, 8, 5, 1, 3, 6]
i = 2
swapping for j = 1
A = [0, 4, 9, 2, 7, 8, 5, 1, 3, 6]
i = 3
swapping for j = 1
A = [0, 2, 9, 4, 7, 8, 5, 1, 3, 6]
swapping for j = 2
A = [0, 2, 4, 9, 7, 8, 5, 1, 3, 6]
i = 4
swapping for j = 3
A = [0, 2, 4, 7, 9, 8, 5, 1, 3, 6]
i = 5
swapping for j = 4
A = [0, 2, 4, 7, 8, 9, 5, 1, 3, 6]
i = 6
swapping for j = 3
A = [0, 2, 4, 5, 8, 9, 7, 1, 3, 6]
swapping for j = 4
A = [0, 2, 4, 5, 7, 9, 8, 1, 3, 6]
swapping for j = 5
A = [0, 2, 4, 5, 7, 8, 9, 1, 3, 6]
i = 7
swapping for j = 1
A = [0, 1, 4, 5, 7, 8, 9, 2, 3, 6]
swapping for j = 2
A = [0, 1, 2, 5, 7, 8, 9, 4, 3, 6]
swapping for j = 3
A = [0, 1, 2, 4, 7, 8, 9, 5, 3, 6]
swapping for j = 4
A = [0, 1, 2, 4, 5, 8, 9, 7, 3, 6]
swapping for j = 5
A = [0, 1, 2, 4, 5, 7, 9, 8, 3, 6]
swapping for j = 6
A = [0, 1, 2, 4, 5, 7, 8, 9, 3, 6]
i = 8
swapping for j = 3
A = [0, 1, 2, 3, 5, 7, 8, 9, 4, 6]
swapping for j = 4
A = [0, 1, 2, 3, 4, 7, 8, 9, 5, 6]
swapping for j = 5
A = [0, 1, 2, 3, 4, 5, 8, 9, 7, 6]
swapping for j = 6
A = [0, 1, 2, 3, 4, 5, 7, 9, 8, 6]
swapping for j = 7
A = [0, 1, 2, 3, 4, 5, 7, 8, 9, 6]
i = 9
swapping for j = 6
A = [0, 1, 2, 3, 4, 5, 6, 8, 9, 7]
swapping for j = 7
A = [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
swapping for j = 8
A = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sort after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

-----------------------
```
from random import shuffle
def assert_partial_sort_order(A, i):
"""
Assert A[j] <= A[j+1] for j < i
"""
for j in range(i):
assert A[j] <= A[j+1]
def sort(A):
n = len(A)
print('sort before:', A)
n_swaps = 0
for i in range(n):
print('i =', i)
for j in range(n):
if A[j] > A[i]:
A[i], A[j] = A[j], A[i]
print(' swapping for j =', j)
print(' A =', A)
assert_partial_sort_order(A, i)
print('sort after:', A, '\n')
n = 10
A = list(range(n))
shuffle(A)
sort(A)
```

```
sort before: [7, 0, 4, 2, 8, 9, 5, 1, 3, 6]
i = 0
swapping for j = 4
A = [8, 0, 4, 2, 7, 9, 5, 1, 3, 6]
swapping for j = 5
A = [9, 0, 4, 2, 7, 8, 5, 1, 3, 6]
i = 1
swapping for j = 0
A = [0, 9, 4, 2, 7, 8, 5, 1, 3, 6]
i = 2
swapping for j = 1
A = [0, 4, 9, 2, 7, 8, 5, 1, 3, 6]
i = 3
swapping for j = 1
A = [0, 2, 9, 4, 7, 8, 5, 1, 3, 6]
swapping for j = 2
A = [0, 2, 4, 9, 7, 8, 5, 1, 3, 6]
i = 4
swapping for j = 3
A = [0, 2, 4, 7, 9, 8, 5, 1, 3, 6]
i = 5
swapping for j = 4
A = [0, 2, 4, 7, 8, 9, 5, 1, 3, 6]
i = 6
swapping for j = 3
A = [0, 2, 4, 5, 8, 9, 7, 1, 3, 6]
swapping for j = 4
A = [0, 2, 4, 5, 7, 9, 8, 1, 3, 6]
swapping for j = 5
A = [0, 2, 4, 5, 7, 8, 9, 1, 3, 6]
i = 7
swapping for j = 1
A = [0, 1, 4, 5, 7, 8, 9, 2, 3, 6]
swapping for j = 2
A = [0, 1, 2, 5, 7, 8, 9, 4, 3, 6]
swapping for j = 3
A = [0, 1, 2, 4, 7, 8, 9, 5, 3, 6]
swapping for j = 4
A = [0, 1, 2, 4, 5, 8, 9, 7, 3, 6]
swapping for j = 5
A = [0, 1, 2, 4, 5, 7, 9, 8, 3, 6]
swapping for j = 6
A = [0, 1, 2, 4, 5, 7, 8, 9, 3, 6]
i = 8
swapping for j = 3
A = [0, 1, 2, 3, 5, 7, 8, 9, 4, 6]
swapping for j = 4
A = [0, 1, 2, 3, 4, 7, 8, 9, 5, 6]
swapping for j = 5
A = [0, 1, 2, 3, 4, 5, 8, 9, 7, 6]
swapping for j = 6
A = [0, 1, 2, 3, 4, 5, 7, 9, 8, 6]
swapping for j = 7
A = [0, 1, 2, 3, 4, 5, 7, 8, 9, 6]
i = 9
swapping for j = 6
A = [0, 1, 2, 3, 4, 5, 6, 8, 9, 7]
swapping for j = 7
A = [0, 1, 2, 3, 4, 5, 6, 7, 9, 8]
swapping for j = 8
A = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
sort after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

-----------------------
```
before: [1, 12, 13, 8, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[19, 1, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 19, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 12, 19, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 19, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 19, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 19, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 16, 18, 19, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 15, 16, 18, 19, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 2, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 5, 4, 0, 10, 17]
[1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 4, 0, 10, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 0, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
```

```
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 13, 15, 16, 18, 19, 12, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 15, 16, 18, 19, 13, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 13, 16, 18, 19, 15, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 18, 19, 16, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 19, 18, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

-----------------------
```
before: [1, 12, 13, 8, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[19, 1, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 19, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 12, 19, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 19, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 19, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 19, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 16, 18, 19, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 15, 16, 18, 19, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 2, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 5, 4, 0, 10, 17]
[1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 4, 0, 10, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 0, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
```

```
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 13, 15, 16, 18, 19, 12, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 15, 16, 18, 19, 13, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 13, 16, 18, 19, 15, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 18, 19, 16, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 19, 18, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

-----------------------
```
before: [1, 12, 13, 8, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[19, 1, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 19, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 12, 19, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 19, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 19, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 19, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 16, 18, 19, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 15, 16, 18, 19, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 2, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 5, 4, 0, 10, 17]
[1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 4, 0, 10, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 0, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
```

```
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 13, 15, 16, 18, 19, 12, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 15, 16, 18, 19, 13, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 13, 16, 18, 19, 15, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 18, 19, 16, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 19, 18, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

-----------------------
```
before: [1, 12, 13, 8, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[19, 1, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 19, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 12, 19, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 19, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 19, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 19, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 16, 18, 19, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 15, 16, 18, 19, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 2, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 5, 4, 0, 10, 17]
[1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 4, 0, 10, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 0, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
```

```
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 13, 15, 16, 18, 19, 12, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 15, 16, 18, 19, 13, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 13, 16, 18, 19, 15, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 18, 19, 16, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 19, 18, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

-----------------------
```
before: [1, 12, 13, 8, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[19, 1, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 19, 12, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 12, 19, 8, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 19, 13, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 19, 15, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 19, 18, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 18, 19, 16, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 8, 12, 13, 15, 16, 18, 19, 7, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 15, 16, 18, 19, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 2, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 11, 12, 13, 14, 15, 16, 18, 19, 9, 5, 4, 0, 10, 17]
[1, 2, 3, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 5, 4, 0, 10, 17]
[1, 2, 3, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 4, 0, 10, 17]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 0, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 18, 19, 10, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 19, 17]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
after: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
```

```
[1, 7, 8, 12, 13, 15, 16, 18, 19, 11, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 13, 15, 16, 18, 19, 12, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 15, 16, 18, 19, 13, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

```
[1, 7, 8, 11, 12, 13, 16, 18, 19, 15, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 18, 19, 16, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 19, 18, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
[1, 7, 8, 11, 12, 13, 15, 16, 18, 19, 6, 14, 3, 2, 9, 5, 4, 0, 10, 17]
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

-----------------------
```
Find the largest element. Move it to the location A[0].
For i from 1 upto n:
For j from 0 upto i:
swap A[i] and A[j] if A[j] is greater than A[i]
Invariant: A[0...j] is sorted
Invariant: A[j+1...i-1] is sorted
Invariant: A[i] is larger than anything in A[0...j]
Invariant: A[0...i] contains the same elements sorted, but now sorted
```

```
i
10 20 30 40 99 25
```

```
[10] 20 30 40 99 25
10 [20] 30 40 99 25
10 20 [30] 40 99 25
```

```
10 20 25 [40] 99 30
10 20 25 30 [99] 40
10 20 25 30 40 [99]
```

```
1 2 3 4 5 6 7
Y | | | | |
| Y | | | |
| | Y | | |
| | | Y | |
| | | | Y |
| | | | | Y
| | | | | | *
```

```
1 2 3 * 5 6 7 8
```

```
5 1 2 3 * 6 7 8
X | |
| X |
| | X
```

```
1 2 3 4 5 6 7 8
```

```
5 1 2 3 4 6 7 8
X | | |
| X | |
| | X |
| | | X
```

```
6 5 1 2 3 4 6 7 8
X | | | |
| X | | |
| | X | |
| | | X |
| | | | X
```

```
1 2 3 4 5 6 7
X | | | | |
| X | | | |
X X | | |
| X X | |
X X X |
| X X X
X X X |
| X X | |
X X | | |
| X | | | |
X | | | | |
```

vertically align tables when html page is printed

CopyDownload

```
@media print {
body {margin-top:0 !important;}
@page { size: A4 portrait; }
}
```

```
<body>
<!-- 1st table: -->
<div class="page">
<table>
<tr> <td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
<!-- 2nd table: -->
<div class="page">
<table>
<tr> <td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
</body>
```

```
@media print {
body {margin-top:0 !important;}
.page{
height: 100vh;
width: 100vw;
display: flex;
align-items: center;
justify-content: center;
}
@page {
size: A4 portrait;
}
}
```

-----------------------
```
@media print {
body {margin-top:0 !important;}
@page { size: A4 portrait; }
}
```

```
<body>
<!-- 1st table: -->
<div class="page">
<table>
<tr> <td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
<!-- 2nd table: -->
<div class="page">
<table>
<tr> <td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
</body>
```

```
@media print {
body {margin-top:0 !important;}
.page{
height: 100vh;
width: 100vw;
display: flex;
align-items: center;
justify-content: center;
}
@page {
size: A4 portrait;
}
}
```

-----------------------
```
@media print {
body {margin-top:0 !important;}
@page { size: A4 portrait; }
}
```

```
<body>
<!-- 1st table: -->
<div class="page">
<table>
<tr> <td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
<!-- 2nd table: -->
<div class="page">
<table>
<tr> <td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</div>
</body>
```

```
@media print {
body {margin-top:0 !important;}
.page{
height: 100vh;
width: 100vw;
display: flex;
align-items: center;
justify-content: center;
}
@page {
size: A4 portrait;
}
}
```

-----------------------
```
table {width:7cm; height:15cm; border: 1px solid;
page-break-after: always;
margin: 6cm auto;
}
@media print {
@page { size: A4 portrait; }
}
```

```
<body>
<!-- 1st table: -->
<table>
<tr> <td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</table>
<!-- 2nd table: -->
<table>
<tr> <td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</body>
```

-----------------------
```
table {width:7cm; height:15cm; border: 1px solid;
page-break-after: always;
margin: 6cm auto;
}
@media print {
@page { size: A4 portrait; }
}
```

```
<body>
<!-- 1st table: -->
<table>
<tr> <td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</table>
<!-- 2nd table: -->
<table>
<tr> <td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</table>
</body>
```

-----------------------
```
<html><head>
<title>Two Centered Tables</title>
<style>
table {
width: 7cm;
height: 15cm;
border: 1px solid;
page-break-after: always;
margin: 50%;
transform: translate(-50%, -50%);
text-align: center;
}
@media print {
@page {
size: A4 portrait;
}
}
</style>
</head>
<body>
<!-- 1st table: -->
<table>
<tbody>
<tr>
<td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
<!-- 2nd table: -->
<table>
<tbody>
<tr>
<td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
</body></html>
```

```
<!DOCTYPE html>
<html>
<head>
<title>Two Centered Tables</title>
<style>
table {
width: 7cm;
height: 15cm;
border: 1px solid;
page-break-after: always;
margin: 50% 50% 50% 50%;
transform: translate(-50%, -50%);
text-align: center;
}
@media print {
@page {
size: A4 portrait;
}
}
</style>
</head>
<body>
<div style="display: grid;">
<!-- 1st table: -->
<table>
<tbody>
<tr>
<td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
<!-- 2nd table: -->
<table>
<tbody>
<tr>
<td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
</div>
</body>
</html>
```

-----------------------
```
<html><head>
<title>Two Centered Tables</title>
<style>
table {
width: 7cm;
height: 15cm;
border: 1px solid;
page-break-after: always;
margin: 50%;
transform: translate(-50%, -50%);
text-align: center;
}
@media print {
@page {
size: A4 portrait;
}
}
</style>
</head>
<body>
<!-- 1st table: -->
<table>
<tbody>
<tr>
<td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
<!-- 2nd table: -->
<table>
<tbody>
<tr>
<td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
</body></html>
```

```
<!DOCTYPE html>
<html>
<head>
<title>Two Centered Tables</title>
<style>
table {
width: 7cm;
height: 15cm;
border: 1px solid;
page-break-after: always;
margin: 50% 50% 50% 50%;
transform: translate(-50%, -50%);
text-align: center;
}
@media print {
@page {
size: A4 portrait;
}
}
</style>
</head>
<body>
<div style="display: grid;">
<!-- 1st table: -->
<table>
<tbody>
<tr>
<td>content of the first table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
<!-- 2nd table: -->
<table>
<tbody>
<tr>
<td>content of the second table</td>
<!-- some other tr's and td's -->
</tr>
</tbody>
</table>
</div>
</body>
</html>
```

QUESTION

Indexed Initial algebras for GADTs

Asked 2022-Mar-31 at 09:23In his paper Generics for the Masses Hinze reviews encoding of data type.

Starting from `Nat`

```
data Nat :: ⋆ where
Zero :: Nat
Succ :: Nat → Nat
```

It can be viewed as an initial algebra `NatF Nat -> Nat`

for `NatF a = 1 + a`

Its Church representation `∀ x. ( NatF x → x ) → x`

is a witness of the universal property conferred by being an initial algebra

He thus redefines an equivalent `Nat`

```
newtype Nat = Nat{fold :: ∀ nat . Algebra nat → nat }
data Algebra nat = With{
foldZero :: nat,
foldSucc :: nat → nat }
```

This yields a function `∀ nat . Algebra x → (Nat → x)`

which gives the unique algebra morphism from the initial algebra. (One can also view `Nat`

as a limit cone for the forgetful functor, and this function yields the components of that cone at each object in the category of algebras). This is classic.

But he then mentions a Church encoding of the following datatype, which is a GADT, intended to be a typed type representation

```
data Rep :: ⋆ → ⋆ where
Int :: Rep Int
Pair :: ∀α β . Rep α → Rep β → Rep (α, β)
```

Which is encoded as

```
data Rep τ = Rep{fold :: ∀rep . Algebra rep → rep τ }
data Algebra rep = With{
foldInt :: rep Int,
foldPair :: ∀α β . rep α → rep β → rep (α, β) }
int:: Rep Int
int = Rep (λc → foldInt c)
pair :: ∀α β . Rep α → Rep β → Rep (α, β)
pair a b = Rep (λc → foldPair c (fold a c) (fold b c))
```

What kind of algebra is this encoding ? It's not a plain algebra, due to the indices. Does some Kan extension-fu allow to express this an ordinary algebra ?

ANSWER

Answered 2022-Mar-14 at 18:05The difference is the category. `Nat`

is an initial algebra in the category of types. `Rep`

is an initial algebra in the category of indexed types. The category of indexed types has as objects type constructors of kind `* -> *`

, and as morphisms from `f ~> g`

, functions of type `forall t. f t -> g t`

.

Then `Rep`

is the initial algebra for the functor `RepF`

defined as follows:

```
data RepF rep :: * -> * where
Int :: RepF rep Int
Pair :: forall a b. rep a -> rep b -> RepF rep (a, b)
```

And similarly the Church encoding

```
newtype Rep t = Rep { fold :: forall rep. Algebra rep -> rep t }
type Algebra rep = RepF rep ~> rep
type f ~> g = forall t. f t -> g t
```

yields, for every `Algebra rep`

, a mapping `forall t. Rep t -> rep t`

.

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

No vulnerabilities reported

You can download it from GitHub.

You can use Paper like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the Paper component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

You can use Paper like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the Paper component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

For any new features, suggestions and bugs create an issue on GitHub.
If you have any questions check and ask questions on community page Stack Overflow .

over 430 million Knowledge Items

Save this library and start creating your kit

over 430 million Knowledge Items

Save this library and start creating your kit