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

5 types
17 values

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

Telescope

2 declarations

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

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)

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

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

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

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

Bifunctor equivalent of hzipWith

Extension, retraction, alignment

5 declarations

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)

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)

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)

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)

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)

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)

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)

Version of retract where the evidence is a simple Bool

Additional API

3 declarations

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])

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)

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.