Bowtie

Some useful fixpoints of Functors and Bifunctors.

Documentation

type family Base1 (f :: Type -> Type) :: Type -> Type -> Type

Base for Bifunctors

Instances

type Base1 (Knot g)

Defined in Bowtie

type Base1 (Knot g) = g

type Base1 (Jot g k)

Defined in Bowtie

type Base1 (Jot g k) = JotF g k

class (Bifunctor (Base1 f), Functor f) => Recursive1 f where

Recursive for Bifunctors

Methods

project1 :: f a -> Base1 f a (f a)

Instances

Bifunctor g => Recursive1 (Knot g)

Defined in Bowtie

Methods

project1 :: Knot g a -> Base1 (Knot g) a (Knot g a)

Bifunctor g => Recursive1 (Jot g k)

Defined in Bowtie

Methods

project1 :: Jot g k a -> Base1 (Jot g k) a (Jot g k a)

class (Bifunctor (Base1 f), Functor f) => Corecursive1 f where

Corecursive for Bifunctors

Methods

embed1 :: Base1 f a (f a) -> f a

Instances

Bifunctor g => Corecursive1 (Knot g)

Defined in Bowtie

Methods

embed1 :: Base1 (Knot g) a (Knot g a) -> Knot g a

Bifunctor g => Corecursive1 (Jot g k)

Defined in Bowtie

Methods

embed1 :: Base1 (Jot g k) a (Jot g k a) -> Jot g k a

cata1 :: (Recursive1 f, Base1 f ~ g) => (g a b -> b) -> f a -> b

cata for Bifunctors

cata1M :: (Monad m, Recursive1 f, Base1 f ~ g, Bitraversable g) => (g a b -> m b) -> f a -> m b

cataM for Bifunctors

fmapViaBi :: (Recursive1 f, Corecursive1 f, Base1 f ~ g) => (a -> b) -> f a -> f b

A useful default fmap

foldrViaBi :: (Recursive1 f, Base1 f ~ g, Bifoldable g) => (a -> b -> b) -> b -> f a -> b

A useful default foldr

traverseViaBi :: (Recursive1 f, Corecursive1 f, Base1 f ~ g, Bitraversable g, Applicative m) => (a -> m b) -> f a -> m (f b)

A useful default traverse

newtype Fix f

A basic Functor fixpoint like you'd see anywhere.

Constructors

Fix

Fields

• unFix :: f (Fix f)

Instances

IsString (f (Fix f)) => IsString (Fix f)

Defined in Bowtie

Methods

fromString :: String -> Fix f

Show (f (Fix f)) => Show (Fix f)

Defined in Bowtie

Methods

showsPrec :: Int -> Fix f -> ShowS

show :: Fix f -> String

showList :: [Fix f] -> ShowS

Eq (f (Fix f)) => Eq (Fix f)

Defined in Bowtie

Methods

(==) :: Fix f -> Fix f -> Bool

(/=) :: Fix f -> Fix f -> Bool

Ord (f (Fix f)) => Ord (Fix f)

Defined in Bowtie

Methods

compare :: Fix f -> Fix f -> Ordering

(<) :: Fix f -> Fix f -> Bool

(<=) :: Fix f -> Fix f -> Bool

(>) :: Fix f -> Fix f -> Bool

(>=) :: Fix f -> Fix f -> Bool

max :: Fix f -> Fix f -> Fix f

min :: Fix f -> Fix f -> Fix f

Pretty (f (Fix f)) => Pretty (Fix f)

Defined in Bowtie

Methods

pretty :: Fix f -> Doc ann

prettyList :: [Fix f] -> Doc ann

Functor f => Corecursive (Fix f)

Defined in Bowtie

Methods

embed :: Base (Fix f) (Fix f) -> Fix f

ana :: (a -> Base (Fix f) a) -> a -> Fix f

apo :: (a -> Base (Fix f) (Either (Fix f) a)) -> a -> Fix f

postpro :: Recursive (Fix f) => (forall b. Base (Fix f) b -> Base (Fix f) b) -> (a -> Base (Fix f) a) -> a -> Fix f

gpostpro :: (Recursive (Fix f), Monad m) => (forall b. m (Base (Fix f) b) -> Base (Fix f) (m b)) -> (forall c. Base (Fix f) c -> Base (Fix f) c) -> (a -> Base (Fix f) (m a)) -> a -> Fix f

Functor f => Recursive (Fix f)

Defined in Bowtie

Methods

project :: Fix f -> Base (Fix f) (Fix f)

cata :: (Base (Fix f) a -> a) -> Fix f -> a

para :: (Base (Fix f) (Fix f, a) -> a) -> Fix f -> a

gpara :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) -> w (Base (Fix f) b)) -> (Base (Fix f) (EnvT (Fix f) w a) -> a) -> Fix f -> a

prepro :: Corecursive (Fix f) => (forall b. Base (Fix f) b -> Base (Fix f) b) -> (Base (Fix f) a -> a) -> Fix f -> a

gprepro :: (Corecursive (Fix f), Comonad w) => (forall b. Base (Fix f) (w b) -> w (Base (Fix f) b)) -> (forall c. Base (Fix f) c -> Base (Fix f) c) -> (Base (Fix f) (w a) -> a) -> Fix f -> a

type Base (Fix f)

Defined in Bowtie

type Base (Fix f) = f

mkFix :: (Recursive t, Base t ~ f) => t -> Fix f

Pull a recursive structure apart and retie as a Fix.

unMkFix :: (Corecursive t, Base t ~ f) => Fix f -> t

Go the other way.

transFix :: Functor f => (forall x. f x -> g x) -> Fix f -> Fix g

Transform the base Functor.

newtype Knot g a

A fixpoint for a Bifunctor where the second type variable contains the recursive structure.

Constructors

Knot

Fields

• unKnot :: g a (Knot g a)

Instances

(Bifunctor g, Bifoldable g) => Foldable (Knot g)

Defined in Bowtie

Methods

fold :: Monoid m => Knot g m -> m

foldMap :: Monoid m => (a -> m) -> Knot g a -> m

foldMap' :: Monoid m => (a -> m) -> Knot g a -> m

foldr :: (a -> b -> b) -> b -> Knot g a -> b

foldr' :: (a -> b -> b) -> b -> Knot g a -> b

foldl :: (b -> a -> b) -> b -> Knot g a -> b

foldl' :: (b -> a -> b) -> b -> Knot g a -> b

foldr1 :: (a -> a -> a) -> Knot g a -> a

foldl1 :: (a -> a -> a) -> Knot g a -> a

toList :: Knot g a -> [a]

null :: Knot g a -> Bool

length :: Knot g a -> Int

elem :: Eq a => a -> Knot g a -> Bool

maximum :: Ord a => Knot g a -> a

minimum :: Ord a => Knot g a -> a

sum :: Num a => Knot g a -> a

product :: Num a => Knot g a -> a

Bitraversable g => Traversable (Knot g)

Defined in Bowtie

Methods

traverse :: Applicative f => (a -> f b) -> Knot g a -> f (Knot g b)

sequenceA :: Applicative f => Knot g (f a) -> f (Knot g a)

mapM :: Monad m => (a -> m b) -> Knot g a -> m (Knot g b)

sequence :: Monad m => Knot g (m a) -> m (Knot g a)

Bifunctor g => Functor (Knot g)

Defined in Bowtie

Methods

fmap :: (a -> b) -> Knot g a -> Knot g b

(<$) :: a -> Knot g b -> Knot g a

Bifunctor g => Corecursive1 (Knot g)

Defined in Bowtie

Methods

embed1 :: Base1 (Knot g) a (Knot g a) -> Knot g a

Bifunctor g => Recursive1 (Knot g)

Defined in Bowtie

Methods

project1 :: Knot g a -> Base1 (Knot g) a (Knot g a)

IsString (g a (Knot g a)) => IsString (Knot g a)

Defined in Bowtie

Methods

fromString :: String -> Knot g a

Show (g a (Knot g a)) => Show (Knot g a)

Defined in Bowtie

Methods

showsPrec :: Int -> Knot g a -> ShowS

show :: Knot g a -> String

showList :: [Knot g a] -> ShowS

Eq (g a (Knot g a)) => Eq (Knot g a)

Defined in Bowtie

Methods

(==) :: Knot g a -> Knot g a -> Bool

(/=) :: Knot g a -> Knot g a -> Bool

Ord (g a (Knot g a)) => Ord (Knot g a)

Defined in Bowtie

Methods

compare :: Knot g a -> Knot g a -> Ordering

(<) :: Knot g a -> Knot g a -> Bool

(<=) :: Knot g a -> Knot g a -> Bool

(>) :: Knot g a -> Knot g a -> Bool

(>=) :: Knot g a -> Knot g a -> Bool

max :: Knot g a -> Knot g a -> Knot g a

min :: Knot g a -> Knot g a -> Knot g a

Pretty (g a (Knot g a)) => Pretty (Knot g a)

Defined in Bowtie

Methods

pretty :: Knot g a -> Doc ann

prettyList :: [Knot g a] -> Doc ann

type Base1 (Knot g)

Defined in Bowtie

type Base1 (Knot g) = g

mkKnot :: (Recursive1 f, Base1 f ~ g) => f a -> Knot g a

Pull a recursive structure apart and retie as a Knot.

unMkKnot :: (Corecursive1 f, Base1 f ~ g) => Knot g a -> f a

Go the other way.

transKnot :: Bifunctor g => (forall x y. g x y -> h x y) -> Knot g a -> Knot h a

Transform the base Bifunctor.

data Anno k v

An "annotation" with associated value.

Constructors

Anno

Fields

• annoKey :: !k
• annoVal :: !v

Instances

Bifoldable Anno

Defined in Bowtie

Methods

bifold :: Monoid m => Anno m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Anno a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Anno a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Anno a b -> c

Bifunctor Anno

Defined in Bowtie

Methods

bimap :: (a -> b) -> (c -> d) -> Anno a c -> Anno b d

first :: (a -> b) -> Anno a c -> Anno b c

second :: (b -> c) -> Anno a b -> Anno a c

Bitraversable Anno

Defined in Bowtie

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Anno a b -> f (Anno c d)

Foldable (Anno k)

Defined in Bowtie

Methods

fold :: Monoid m => Anno k m -> m

foldMap :: Monoid m => (a -> m) -> Anno k a -> m

foldMap' :: Monoid m => (a -> m) -> Anno k a -> m

foldr :: (a -> b -> b) -> b -> Anno k a -> b

foldr' :: (a -> b -> b) -> b -> Anno k a -> b

foldl :: (b -> a -> b) -> b -> Anno k a -> b

foldl' :: (b -> a -> b) -> b -> Anno k a -> b

foldr1 :: (a -> a -> a) -> Anno k a -> a

foldl1 :: (a -> a -> a) -> Anno k a -> a

toList :: Anno k a -> [a]

null :: Anno k a -> Bool

length :: Anno k a -> Int

elem :: Eq a => a -> Anno k a -> Bool

maximum :: Ord a => Anno k a -> a

minimum :: Ord a => Anno k a -> a

sum :: Num a => Anno k a -> a

product :: Num a => Anno k a -> a

Traversable (Anno k)

Defined in Bowtie

Methods

traverse :: Applicative f => (a -> f b) -> Anno k a -> f (Anno k b)

sequenceA :: Applicative f => Anno k (f a) -> f (Anno k a)

mapM :: Monad m => (a -> m b) -> Anno k a -> m (Anno k b)

sequence :: Monad m => Anno k (m a) -> m (Anno k a)

Monoid k => Applicative (Anno k)

Defined in Bowtie

Methods

pure :: a -> Anno k a

(<*>) :: Anno k (a -> b) -> Anno k a -> Anno k b

liftA2 :: (a -> b -> c) -> Anno k a -> Anno k b -> Anno k c

(*>) :: Anno k a -> Anno k b -> Anno k b

(<*) :: Anno k a -> Anno k b -> Anno k a

Functor (Anno k)

Defined in Bowtie

Methods

fmap :: (a -> b) -> Anno k a -> Anno k b

(<$) :: a -> Anno k b -> Anno k a

Comonad (Anno k)

Defined in Bowtie

Methods

extract :: Anno k a -> a

duplicate :: Anno k a -> Anno k (Anno k a)

extend :: (Anno k a -> b) -> Anno k a -> Anno k b

Semigroup k => Apply (Anno k)

Defined in Bowtie

Methods

(<.>) :: Anno k (a -> b) -> Anno k a -> Anno k b

(.>) :: Anno k a -> Anno k b -> Anno k b

(<.) :: Anno k a -> Anno k b -> Anno k a

liftF2 :: (a -> b -> c) -> Anno k a -> Anno k b -> Anno k c

(Monoid k, IsString v) => IsString (Anno k v)

Defined in Bowtie

Methods

fromString :: String -> Anno k v

(Show k, Typeable k, Exception v) => Exception (Anno k v)

Defined in Bowtie

Methods

toException :: Anno k v -> SomeException

fromException :: SomeException -> Maybe (Anno k v)

displayException :: Anno k v -> String

(Show k, Show v) => Show (Anno k v)

Defined in Bowtie

Methods

showsPrec :: Int -> Anno k v -> ShowS

show :: Anno k v -> String

showList :: [Anno k v] -> ShowS

(Eq k, Eq v) => Eq (Anno k v)

Defined in Bowtie

Methods

(==) :: Anno k v -> Anno k v -> Bool

(/=) :: Anno k v -> Anno k v -> Bool

(Ord k, Ord v) => Ord (Anno k v)

Defined in Bowtie

Methods

compare :: Anno k v -> Anno k v -> Ordering

(<) :: Anno k v -> Anno k v -> Bool

(<=) :: Anno k v -> Anno k v -> Bool

(>) :: Anno k v -> Anno k v -> Bool

(>=) :: Anno k v -> Anno k v -> Bool

max :: Anno k v -> Anno k v -> Anno k v

min :: Anno k v -> Anno k v -> Anno k v

Pretty v => Pretty (Anno k v)

Defined in Bowtie

Methods

pretty :: Anno k v -> Doc ann

prettyList :: [Anno k v] -> Doc ann

annoUnit :: v -> Reader k (Anno k v)

unit from Adjunction

annoUnitM :: Applicative m => v -> ReaderT k m (Anno k v)

annoCounit :: Anno k (Reader k v) -> v

counit from Adjunction

annoCounitM :: Anno k (ReaderT k m v) -> m v

annoLeft :: (Anno k v -> x) -> v -> Reader k x

leftAdjunct from Adjunction

annoLeftM :: (Anno k v -> m x) -> v -> ReaderT k m x

annoRight :: (v -> Reader k x) -> Anno k v -> x

rightAdjunct from Adjunction

annoRightM :: (v -> ReaderT k m x) -> Anno k v -> m x

newtype MemoF f k r

The base functor for a Memo

Constructors

MemoF

Fields

• unMemoF :: Anno k (f r)

Instances

(Applicative f, Monoid k) => Applicative (MemoF f k)

Defined in Bowtie

Methods

pure :: a -> MemoF f k a

(<*>) :: MemoF f k (a -> b) -> MemoF f k a -> MemoF f k b

liftA2 :: (a -> b -> c) -> MemoF f k a -> MemoF f k b -> MemoF f k c

(*>) :: MemoF f k a -> MemoF f k b -> MemoF f k b

(<*) :: MemoF f k a -> MemoF f k b -> MemoF f k a

Functor f => Functor (MemoF f k)

Defined in Bowtie

Methods

fmap :: (a -> b) -> MemoF f k a -> MemoF f k b

(<$) :: a -> MemoF f k b -> MemoF f k a

(Apply f, Semigroup k) => Apply (MemoF f k)

Defined in Bowtie

Methods

(<.>) :: MemoF f k (a -> b) -> MemoF f k a -> MemoF f k b

(.>) :: MemoF f k a -> MemoF f k b -> MemoF f k b

(<.) :: MemoF f k a -> MemoF f k b -> MemoF f k a

liftF2 :: (a -> b -> c) -> MemoF f k a -> MemoF f k b -> MemoF f k c

(Monoid k2, IsString (f r)) => IsString (MemoF f k2 r)

Defined in Bowtie

Methods

fromString :: String -> MemoF f k2 r

(Show k2, Show (f r)) => Show (MemoF f k2 r)

Defined in Bowtie

Methods

showsPrec :: Int -> MemoF f k2 r -> ShowS

show :: MemoF f k2 r -> String

showList :: [MemoF f k2 r] -> ShowS

(Eq k2, Eq (f r)) => Eq (MemoF f k2 r)

Defined in Bowtie

Methods

(==) :: MemoF f k2 r -> MemoF f k2 r -> Bool

(/=) :: MemoF f k2 r -> MemoF f k2 r -> Bool

(Ord k2, Ord (f r)) => Ord (MemoF f k2 r)

Defined in Bowtie

Methods

compare :: MemoF f k2 r -> MemoF f k2 r -> Ordering

(<) :: MemoF f k2 r -> MemoF f k2 r -> Bool

(<=) :: MemoF f k2 r -> MemoF f k2 r -> Bool

(>) :: MemoF f k2 r -> MemoF f k2 r -> Bool

(>=) :: MemoF f k2 r -> MemoF f k2 r -> Bool

max :: MemoF f k2 r -> MemoF f k2 r -> MemoF f k2 r

min :: MemoF f k2 r -> MemoF f k2 r -> MemoF f k2 r

Pretty (f r) => Pretty (MemoF f k2 r)

Defined in Bowtie

Methods

pretty :: MemoF f k2 r -> Doc ann

prettyList :: [MemoF f k2 r] -> Doc ann

pattern MemoFP :: k -> f r -> MemoF f k r

memoFKey :: MemoF f k r -> k

memoFVal :: MemoF f k r -> f r

newtype Memo f k

An annotated Fix

Constructors

Memo

Fields

• unMemo :: MemoF f k (Memo f k)

Instances

Foldable f => Foldable (Memo f)

Defined in Bowtie

Methods

fold :: Monoid m => Memo f m -> m

foldMap :: Monoid m => (a -> m) -> Memo f a -> m

foldMap' :: Monoid m => (a -> m) -> Memo f a -> m

foldr :: (a -> b -> b) -> b -> Memo f a -> b

foldr' :: (a -> b -> b) -> b -> Memo f a -> b

foldl :: (b -> a -> b) -> b -> Memo f a -> b

foldl' :: (b -> a -> b) -> b -> Memo f a -> b

foldr1 :: (a -> a -> a) -> Memo f a -> a

foldl1 :: (a -> a -> a) -> Memo f a -> a

toList :: Memo f a -> [a]

null :: Memo f a -> Bool

length :: Memo f a -> Int

elem :: Eq a => a -> Memo f a -> Bool

maximum :: Ord a => Memo f a -> a

minimum :: Ord a => Memo f a -> a

sum :: Num a => Memo f a -> a

product :: Num a => Memo f a -> a

Traversable f => Traversable (Memo f)

Defined in Bowtie

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Memo f a -> f0 (Memo f b)

sequenceA :: Applicative f0 => Memo f (f0 a) -> f0 (Memo f a)

mapM :: Monad m => (a -> m b) -> Memo f a -> m (Memo f b)

sequence :: Monad m => Memo f (m a) -> m (Memo f a)

Functor f => Functor (Memo f)

Defined in Bowtie

Methods

fmap :: (a -> b) -> Memo f a -> Memo f b

(<$) :: a -> Memo f b -> Memo f a

(Monoid k, IsString (f (Memo f k))) => IsString (Memo f k)

Defined in Bowtie

Methods

fromString :: String -> Memo f k

(Show k, Show (f (Memo f k))) => Show (Memo f k)

Defined in Bowtie

Methods

showsPrec :: Int -> Memo f k -> ShowS

show :: Memo f k -> String

showList :: [Memo f k] -> ShowS

(Eq k, Eq (f (Memo f k))) => Eq (Memo f k)

Defined in Bowtie

Methods

(==) :: Memo f k -> Memo f k -> Bool

(/=) :: Memo f k -> Memo f k -> Bool

(Ord k, Ord (f (Memo f k))) => Ord (Memo f k)

Defined in Bowtie

Methods

compare :: Memo f k -> Memo f k -> Ordering

(<) :: Memo f k -> Memo f k -> Bool

(<=) :: Memo f k -> Memo f k -> Bool

(>) :: Memo f k -> Memo f k -> Bool

(>=) :: Memo f k -> Memo f k -> Bool

max :: Memo f k -> Memo f k -> Memo f k

min :: Memo f k -> Memo f k -> Memo f k

Pretty (f (Memo f k)) => Pretty (Memo f k)

Defined in Bowtie

Methods

pretty :: Memo f k -> Doc ann

prettyList :: [Memo f k] -> Doc ann

Functor f => Corecursive (Memo f k)

Defined in Bowtie

Methods

embed :: Base (Memo f k) (Memo f k) -> Memo f k

ana :: (a -> Base (Memo f k) a) -> a -> Memo f k

apo :: (a -> Base (Memo f k) (Either (Memo f k) a)) -> a -> Memo f k

postpro :: Recursive (Memo f k) => (forall b. Base (Memo f k) b -> Base (Memo f k) b) -> (a -> Base (Memo f k) a) -> a -> Memo f k

gpostpro :: (Recursive (Memo f k), Monad m) => (forall b. m (Base (Memo f k) b) -> Base (Memo f k) (m b)) -> (forall c. Base (Memo f k) c -> Base (Memo f k) c) -> (a -> Base (Memo f k) (m a)) -> a -> Memo f k

Functor f => Recursive (Memo f k)

Defined in Bowtie

Methods

project :: Memo f k -> Base (Memo f k) (Memo f k)

cata :: (Base (Memo f k) a -> a) -> Memo f k -> a

para :: (Base (Memo f k) (Memo f k, a) -> a) -> Memo f k -> a

gpara :: (Corecursive (Memo f k), Comonad w) => (forall b. Base (Memo f k) (w b) -> w (Base (Memo f k) b)) -> (Base (Memo f k) (EnvT (Memo f k) w a) -> a) -> Memo f k -> a

prepro :: Corecursive (Memo f k) => (forall b. Base (Memo f k) b -> Base (Memo f k) b) -> (Base (Memo f k) a -> a) -> Memo f k -> a

gprepro :: (Corecursive (Memo f k), Comonad w) => (forall b. Base (Memo f k) (w b) -> w (Base (Memo f k) b)) -> (forall c. Base (Memo f k) c -> Base (Memo f k) c) -> (Base (Memo f k) (w a) -> a) -> Memo f k -> a

type Base (Memo f k)

Defined in Bowtie

type Base (Memo f k) = MemoF f k

pattern MemoP :: k -> f (Memo f k) -> Memo f k

mkMemo :: (Recursive t, Base t ~ f) => (f k -> k) -> t -> Memo f k

Pull a recursive structure apart and retie as a Memo, using the given function to calculate a key for every level.

unMkMemo :: (Corecursive t, Base t ~ f) => Memo f k -> t

Forget keys at every level and convert back to a plain structure.

transMemo :: Functor f => (forall x. f x -> g x) -> Memo f k -> Memo g k

Transform the base functor.

memoKey :: Memo f k -> k

memoVal :: Memo f k -> f (Memo f k)

memoCata :: Functor f => (f x -> Reader k x) -> Memo f k -> x

cata but nicer

memoCataM :: (Monad m, Traversable f) => (f x -> ReaderT k m x) -> Memo f k -> m x

cataM but nicer

memoRight :: (f (Memo f k) -> Reader k x) -> Memo f k -> x

Peek at the top value like annoRight

memoRightM :: (f (Memo f k) -> ReaderT k m x) -> Memo f k -> m x

Peek at the top value like annoRightM

memoExtend :: Functor f => (Memo f k -> x) -> Memo f k -> Memo f x

Re-annotate top-down

newtype JotF g k a r

The base functor for a Jot

Constructors

JotF

Fields

• unJotF :: Anno k (g a r)

Instances

Bifoldable g => Bifoldable (JotF g k)

Defined in Bowtie

Methods

bifold :: Monoid m => JotF g k m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> JotF g k a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> JotF g k a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> JotF g k a b -> c

Bifunctor g => Bifunctor (JotF g k)

Defined in Bowtie

Methods

bimap :: (a -> b) -> (c -> d) -> JotF g k a c -> JotF g k b d

first :: (a -> b) -> JotF g k a c -> JotF g k b c

second :: (b -> c) -> JotF g k a b -> JotF g k a c

Bitraversable g => Bitraversable (JotF g k)

Defined in Bowtie

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> JotF g k a b -> f (JotF g k c d)

Functor (g a) => Functor (JotF g k2 a)

Defined in Bowtie

Methods

fmap :: (a0 -> b) -> JotF g k2 a a0 -> JotF g k2 a b

(<$) :: a0 -> JotF g k2 a b -> JotF g k2 a a0

(Monoid k3, IsString (g a r)) => IsString (JotF g k3 a r)

Defined in Bowtie

Methods

fromString :: String -> JotF g k3 a r

(Show k3, Show (g a r)) => Show (JotF g k3 a r)

Defined in Bowtie

Methods

showsPrec :: Int -> JotF g k3 a r -> ShowS

show :: JotF g k3 a r -> String

showList :: [JotF g k3 a r] -> ShowS

(Eq k3, Eq (g a r)) => Eq (JotF g k3 a r)

Defined in Bowtie

Methods

(==) :: JotF g k3 a r -> JotF g k3 a r -> Bool

(/=) :: JotF g k3 a r -> JotF g k3 a r -> Bool

(Ord k3, Ord (g a r)) => Ord (JotF g k3 a r)

Defined in Bowtie

Methods

compare :: JotF g k3 a r -> JotF g k3 a r -> Ordering

(<) :: JotF g k3 a r -> JotF g k3 a r -> Bool

(<=) :: JotF g k3 a r -> JotF g k3 a r -> Bool

(>) :: JotF g k3 a r -> JotF g k3 a r -> Bool

(>=) :: JotF g k3 a r -> JotF g k3 a r -> Bool

max :: JotF g k3 a r -> JotF g k3 a r -> JotF g k3 a r

min :: JotF g k3 a r -> JotF g k3 a r -> JotF g k3 a r

Pretty (g a r) => Pretty (JotF g k3 a r)

Defined in Bowtie

Methods

pretty :: JotF g k3 a r -> Doc ann

prettyList :: [JotF g k3 a r] -> Doc ann

pattern JotFP :: k -> g a r -> JotF g k a r

jotFKey :: JotF g k a r -> k

jotFVal :: JotF g k a r -> g a r

newtype Jot g k a

An annotated Knot

Constructors

Jot

Fields

• unJot :: JotF g k a (Jot g k a)

Instances

Bifoldable g => Bifoldable (Jot g)

Defined in Bowtie

Methods

bifold :: Monoid m => Jot g m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Jot g a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Jot g a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Jot g a b -> c

Bifunctor g => Bifunctor (Jot g)

Defined in Bowtie

Methods

bimap :: (a -> b) -> (c -> d) -> Jot g a c -> Jot g b d

first :: (a -> b) -> Jot g a c -> Jot g b c

second :: (b -> c) -> Jot g a b -> Jot g a c

Bitraversable g => Bitraversable (Jot g)

Defined in Bowtie

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Jot g a b -> f (Jot g c d)

(Bifunctor g, Bifoldable g) => Foldable (Jot g k)

Defined in Bowtie

Methods

fold :: Monoid m => Jot g k m -> m

foldMap :: Monoid m => (a -> m) -> Jot g k a -> m

foldMap' :: Monoid m => (a -> m) -> Jot g k a -> m

foldr :: (a -> b -> b) -> b -> Jot g k a -> b

foldr' :: (a -> b -> b) -> b -> Jot g k a -> b

foldl :: (b -> a -> b) -> b -> Jot g k a -> b

foldl' :: (b -> a -> b) -> b -> Jot g k a -> b

foldr1 :: (a -> a -> a) -> Jot g k a -> a

foldl1 :: (a -> a -> a) -> Jot g k a -> a

toList :: Jot g k a -> [a]

null :: Jot g k a -> Bool

length :: Jot g k a -> Int

elem :: Eq a => a -> Jot g k a -> Bool

maximum :: Ord a => Jot g k a -> a

minimum :: Ord a => Jot g k a -> a

sum :: Num a => Jot g k a -> a

product :: Num a => Jot g k a -> a

Bitraversable g => Traversable (Jot g k)

Defined in Bowtie

Methods

traverse :: Applicative f => (a -> f b) -> Jot g k a -> f (Jot g k b)

sequenceA :: Applicative f => Jot g k (f a) -> f (Jot g k a)

mapM :: Monad m => (a -> m b) -> Jot g k a -> m (Jot g k b)

sequence :: Monad m => Jot g k (m a) -> m (Jot g k a)

Bifunctor g => Functor (Jot g k)

Defined in Bowtie

Methods

fmap :: (a -> b) -> Jot g k a -> Jot g k b

(<$) :: a -> Jot g k b -> Jot g k a

Bifunctor g => Corecursive1 (Jot g k)

Defined in Bowtie

Methods

embed1 :: Base1 (Jot g k) a (Jot g k a) -> Jot g k a

Bifunctor g => Recursive1 (Jot g k)

Defined in Bowtie

Methods

project1 :: Jot g k a -> Base1 (Jot g k) a (Jot g k a)

(Monoid k, IsString (g a (Jot g k a))) => IsString (Jot g k a)

Defined in Bowtie

Methods

fromString :: String -> Jot g k a

(Show k, Show (g a (Jot g k a))) => Show (Jot g k a)

Defined in Bowtie

Methods

showsPrec :: Int -> Jot g k a -> ShowS

show :: Jot g k a -> String

showList :: [Jot g k a] -> ShowS

(Eq k, Eq (g a (Jot g k a))) => Eq (Jot g k a)

Defined in Bowtie

Methods

(==) :: Jot g k a -> Jot g k a -> Bool

(/=) :: Jot g k a -> Jot g k a -> Bool

(Ord k, Ord (g a (Jot g k a))) => Ord (Jot g k a)

Defined in Bowtie

Methods

compare :: Jot g k a -> Jot g k a -> Ordering

(<) :: Jot g k a -> Jot g k a -> Bool

(<=) :: Jot g k a -> Jot g k a -> Bool

(>) :: Jot g k a -> Jot g k a -> Bool

(>=) :: Jot g k a -> Jot g k a -> Bool

max :: Jot g k a -> Jot g k a -> Jot g k a

min :: Jot g k a -> Jot g k a -> Jot g k a

Pretty (g a (Jot g k a)) => Pretty (Jot g k a)

Defined in Bowtie

Methods

pretty :: Jot g k a -> Doc ann

prettyList :: [Jot g k a] -> Doc ann

type Base1 (Jot g k)

Defined in Bowtie

type Base1 (Jot g k) = JotF g k

pattern JotP :: k -> g a (Jot g k a) -> Jot g k a

mkJot :: (Recursive1 t, Base1 t ~ g) => (g a k -> k) -> t a -> Jot g k a

Pull a recursive structure apart and retie as a Jot, using the given function to calculate a key for every level.

unMkJot :: (Corecursive1 t, Base1 t ~ g) => Jot g k a -> t a

Forget keys at every level and convert back to a plain structure.

annoJot :: Anno b (g a (Jot g b a)) -> Jot g b a

Quick conversion from annotated functor.

transJot :: Bifunctor g => (forall x. g a x -> h a x) -> Jot g k a -> Jot h k a

Transform the base functor.

jotKey :: Jot g k a -> k

jotVal :: Jot g k a -> g a (Jot g k a)

jotCata :: Bifunctor g => (g a x -> Reader k x) -> Jot g k a -> x

cata but nicer

jotCataM :: Bifunctor g => (g a (m x) -> ReaderT k m x) -> Jot g k a -> m x

cataM but nicer

jotRight :: (g a (Jot g k a) -> Reader k x) -> Jot g k a -> x

Peek at the top value like annoRight

jotRightM :: (g a (Jot g k a) -> ReaderT k m x) -> Jot g k a -> m x

Peek at the top value like annoRightM

jotExtend :: Bifunctor g => (Jot g k a -> x) -> Jot g k a -> Jot g x a

Re-annotate top-down