Modulesop-extras-0.4.1.1Haskell2010

Data.SOP.Telescope

Intended for qualified import

import           Data.SOP.Telescope (Telescope(..))
import qualified Data.SOP.Telescope as Telescope

Contents

Telescope
Utilities
Bifunctor analogues of SOP functions
Extension, retraction, alignment
Simplified API
Additional API

Synopsis

data Telescope
value sequence
value fromTZ
value fromTip
value tip
value toAtMost
value bihap
value bihczipWith
value bihmap
value bihzipWith
newtype Extend
newtype Retract
value align
value extend
value retract
value alignExtend
value alignExtendNS
value extendIf
value retractIf
newtype ScanNext
newtype SimpleTelescope
value scanl

Packagesop-extras-0.4.1.1
Exports22
LanguageHaskell2010
LicenceApache-2.0
SourceTelescope.hs

Telescope

datadata Telescope (g :: k -> Type) (f :: k -> Type) (xs :: [k]) where

Source#

Telescope

A telescope is an extension of an NS, where every time we "go right" in the sum we have an additional value.

The Telescope API mostly follows sop-core conventions, supporting functor (hmap, hcmap), applicative (hap, hpure), foldable (hcollapse) and traversable (hsequence'). However, since Telescope is a bi-functor, it cannot reuse the sop-core classes. The naming scheme of the functions is adopted from sop-core though; for example:

bi h (c) zipWith
|  |  |    |
|  |  |    \ zipWith: the name from base
|  |  |
|  |  \ constrained: version of the function with a constraint parameter
|  |
|  \ higher order: 'Telescope' (like 'NS'/'NP') is a /higher order/ functor
|
\ bifunctor: 'Telescope' (unlike 'NS'/'NP') is a higher order /bifunctor/

In addition to the standard SOP operators, the new operators that make a Telescope a telescope are extend, retract and align; see their documentation for details.

Constructors

TZ :: !f x -> Telescope g f (x ': xs1)
TS :: !g x -> !Telescope g f xs1 -> Telescope g f (x ': xs1)

Instances12HTrans, HAp, HSequence, HTraverse_, Eq, Ord, …

(forall (x :: k2) (y :: k2). LiftedCoercible g g x y) => HTrans (Telescope g) (Telescope g)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HAp (Telescope g)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HSequence (Telescope g)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HTraverse_ (Telescope g)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
(All (Compose Eq g) xs, All (Compose Eq f) xs) => Eq (Telescope g f xs)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
(All (Compose Eq g) xs, All (Compose Ord g) xs, All (Compose Eq f) xs, All (Compose Ord f) xs) => Ord (Telescope g f xs)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
(All (Compose Show g) xs, All (Compose Show f) xs) => Show (Telescope g f xs)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
(All (Compose NoThunks g) xs, All (Compose NoThunks f) xs) => NoThunks (Telescope g f xs)Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type Prod (Telescope g) = NPDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type AllN (Telescope g) c = All cDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type Same (Telescope g) = Telescope gDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type SListIN (Telescope g) = SListIDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope

valuesequence :: Functor m => Telescope g (m :.: f) xs -> m (Telescope g f xs)

Source#

Specialization of hsequence' with weaker constraints (Functor rather than Applicative)

Utilities

valuefromTZ :: Telescope g f '[x] -> f x

valuefromTip :: NS f xs -> Telescope (K ()) f xs

valuetip :: Telescope g f xs -> NS f xs

valuetoAtMost :: Telescope (K a) (K (Maybe a)) xs -> AtMost xs a

Bifunctor analogues of SOP functions

valuebihap

:: NP (g -.-> g') xs
-> NP (f -.-> f') xs
-> Telescope g f xs
-> Telescope g' f' xs

Source#

Bifunctor analogue of hap

valuebihczipWith

:: All c xs
=> proxy c
-> forall (x :: k). c x => h x -> g x -> g' x
-> forall (x :: k). c x => h x -> f x -> f' x
-> NP h xs
-> Telescope g f xs
-> Telescope g' f' xs

Source#

Bifunctor equivalent of hczipWith

valuebihmap

:: SListI xs
=> forall (x :: k). g x -> g' x
-> forall (x :: k). f x -> f' x
-> Telescope g f xs
-> Telescope g' f' xs

Source#

Bifunctor analogue of hmap

valuebihzipWith

:: SListI xs
=> forall (x :: k). h x -> g x -> g' x
-> forall (x :: k). h x -> f x -> f' x
-> NP h xs
-> Telescope g f xs
-> Telescope g' f' xs

Source#

Bifunctor equivalent of hzipWith

Extension, retraction, alignment

newtypenewtype Extend (m :: Type -> Type) (g :: k -> Type) (f :: k -> Type) (x :: k) (y :: k)

Constructors

Extend
- extendWith :: f x -> m (g x, f y)

newtypenewtype Retract (m :: Type -> Type) (g :: k -> Type) (f :: k -> Type) (x :: k) (y :: k)

Constructors

Retract
- retractWith :: g x -> f y -> m (f x)

valuealign

:: Monad m
=> InPairs (Requiring g' (Extend m g f)) xs
How to extend
-> Tails (Requiring f' (Retract m g f)) xs
How to retract
-> NP (f' -.-> (f -.-> f'')) xs
Function to apply at the tip
-> Telescope g' f' xs
Telescope we are aligning with
-> Telescope g f xs
-> m (Telescope g f'' xs)

Source#

Align a telescope with another, then apply a function to the tips

Aligning is a combination of extension and retraction, extending or retracting the telescope as required to match up with the other telescope.

valueextend

:: Monad m
=> InPairs (Requiring h (Extend m g f)) xs
How to extend
-> NP (f -.-> (Maybe :.: h)) xs
Where to extend from
-> Telescope g f xs
-> m (Telescope g f xs)

Source#

Extend the telescope

We will not attempt to extend the telescope past its final segment.

valueretract

:: Monad m
=> Tails (Requiring h (Retract m g f)) xs
How to retract
-> NP (g -.-> (Maybe :.: h)) xs
Where to retract to
-> Telescope g f xs
-> m (Telescope g f xs)

Source#

Retract a telescope

Simplified API

valuealignExtend

:: (Monad m, HasCallStack)
=> InPairs (Requiring g' (Extend m g f)) xs
How to extend
-> NP (f' -.-> (f -.-> f'')) xs
Function to apply at the tip
-> Telescope g' f' xs
Telescope we are aligning with
-> Telescope g f xs
-> m (Telescope g f'' xs)

Source#

Version of align that never retracts, only extends

PRE: The telescope we are aligning with cannot be behind us.

valuealignExtendNS

:: (Monad m, HasCallStack)
=> InPairs (Extend m g f) xs
How to extend
-> NP (f' -.-> (f -.-> f'')) xs
Function to apply at the tip
-> NS f' xs
NS we are aligning with
-> Telescope g f xs
-> m (Telescope g f'' xs)

Source#

Version of alignExtend that extends with an NS instead

valueextendIf

:: Monad m
=> InPairs (Extend m g f) xs
How to extend
-> NP (f -.-> K Bool) xs
Where to extend from
-> Telescope g f xs
-> m (Telescope g f xs)

Source#

Version of extend where the evidence is a simple Bool

valueretractIf

:: Monad m
=> Tails (Retract m g f) xs
How to retract
-> NP (g -.-> K Bool) xs
Where to retract to
-> Telescope g f xs
-> m (Telescope g f xs)

Source#

Version of retract where the evidence is a simple Bool

Additional API

newtypenewtype ScanNext (h :: k -> Type) (g :: k -> Type) (x :: k) (y :: k)

Constructors

ScanNext
- getNext :: h x -> g x -> h y

newtypenewtype SimpleTelescope (f :: k -> Type) (xs :: [k])

Source#

Telescope with both functors set to the same f

Constructors

SimpleTelescope
- getSimpleTelescope :: Telescope f f xs

Instances8HAp, HCollapse, HSequence, HTraverse_, CollapseTo, Prod, …

HAp SimpleTelescopeDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HCollapse SimpleTelescopeDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HSequence SimpleTelescopeDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
HTraverse_ SimpleTelescopeDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type CollapseTo SimpleTelescope a = [a]Defined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type Prod SimpleTelescope = NPDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type AllN SimpleTelescope c = All cDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope
type SListIN SimpleTelescope = SListIDefined in sop-extras-0.4.1.1 · Data.SOP.Telescope

valuescanl

:: InPairs (ScanNext h g) (x ': xs)
-> h x
-> Telescope g f (x ': xs)
-> Telescope (Product h g) (Product h f) (x ': xs)

Source#

Telescope analogue of scanl on lists

This function is modelled on

scanl :: (b -> a -> b) -> b -> [a] -> [b]

but there are a few differences:

Since every seed has a different type, we must be given a function for each transition.
Unlike scanl, we preserve the length of the telescope (scanl prepends the initial seed)
Instead of generating a telescope containing only the seeds, we instead pair the seeds with the elements.