packages feed

knit-haskell 0.2.0.0 → 0.3.0.0

raw patch · 13 files changed

+346/−56 lines, 13 filesdep +diagrams-libdep +diagrams-svgdep +plotsdep ~basedep ~blaze-htmldep ~containersnew-component:exe:ErrorExamplePVP ok

version bump matches the API change (PVP)

Dependencies added: diagrams-lib, diagrams-svg, plots, svg-builder

Dependency ranges changed: base, blaze-html, containers, here, hvega, network, polysemy, text

API changes (from Hackage documentation)

- Knit.Report: addColonnadeCellTable :: (PandocEffects effs, Member ToPandoc effs, Foldable f) => Attribute -> Colonnade Headed a Cell -> f a -> Sem effs ()
- Knit.Report: addColonnadeHtmlTable :: (PandocEffects effs, Member ToPandoc effs, Foldable f) => Attribute -> Colonnade Headed a Html -> f a -> Sem effs ()
- Knit.Report: addColonnadeTextTable :: (PandocEffects effs, Member ToPandoc effs, Foldable f) => Colonnade Headed a Text -> f a -> Sem effs ()
+ Knit.Effect.UnusedId: getNextUnusedId :: Member UnusedId r => Text -> Sem r Text
+ Knit.Effect.UnusedId: runUnusedId :: Sem (UnusedId : r) a -> Sem r a
+ Knit.Effect.UnusedId: type UnusedId = State IdMap
+ Knit.Report: getNextUnusedId :: Member UnusedId r => Text -> Sem r Text
+ Knit.Report: knitError :: Member (Error PandocError) r => Text -> Sem r ()
+ Knit.Report: type KnitEffects r = (PandocEffects r, Member UnusedId r)
+ Knit.Report: type KnitMany r = (KnitEffects r, Member (Docs PandocWithRequirements) r)
+ Knit.Report: type KnitOne r = (KnitEffects r, Member ToPandoc r)
+ Knit.Report.Input.Visualization.Diagrams: (##) :: () => AReview t b -> b -> t
+ Knit.Report.Input.Visualization.Diagrams: (#%%=) :: MonadState s m => ALens s s a b -> (a -> (r, b)) -> m r
+ Knit.Report.Input.Visualization.Diagrams: (#%%~) :: Functor f => ALens s t a b -> (a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: (#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (#%~) :: () => ALens s t a b -> (a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (#) :: () => a -> (a -> b) -> b
+ Knit.Report.Input.Visualization.Diagrams: (#.) :: Coercible c b => (b -> c) -> (a -> b) -> a -> c
+ Knit.Report.Input.Visualization.Diagrams: (#=) :: MonadState s m => ALens s s a b -> b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (#~) :: () => ALens s t a b -> b -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (%%=) :: MonadState s m => Over p ((,) r) s s a b -> p a (r, b) -> m r
+ Knit.Report.Input.Visualization.Diagrams: (%%@=) :: MonadState s m => Over (Indexed i) ((,) r) s s a b -> (i -> a -> (r, b)) -> m r
+ Knit.Report.Input.Visualization.Diagrams: (%%@~) :: () => Over (Indexed i) f s t a b -> (i -> a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: (%%~) :: () => LensLike f s t a b -> (a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: (%=) :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (%@~) :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (%~) :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (&&=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (&&~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (&) :: () => a -> (a -> b) -> b
+ Knit.Report.Input.Visualization.Diagrams: (&~) :: () => s -> State s a -> s
+ Knit.Report.Input.Visualization.Diagrams: (**=) :: (MonadState s m, Floating a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (**~) :: Floating a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (*.) :: (Functor v, Num n) => n -> Point v n -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: (*=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (*>) :: Applicative f => f a -> f b -> f b
+ Knit.Report.Input.Visualization.Diagrams: (*^) :: (Functor f, Num a) => a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: (*~) :: Num a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (+=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (+~) :: Num a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (-=) :: (MonadState s m, Num a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (->>) :: Semigroup a => Active a -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: (-~) :: Num a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (.#) :: Coercible b a => (b -> c) -> (a -> b) -> a -> c
+ Knit.Report.Input.Visualization.Diagrams: (.+^) :: (Affine p, Num a) => p a -> Diff p a -> p a
+ Knit.Report.Input.Visualization.Diagrams: (.-.) :: (Affine p, Num a) => p a -> p a -> Diff p a
+ Knit.Report.Input.Visualization.Diagrams: (.-^) :: (Affine p, Num a) => p a -> Diff p a -> p a
+ Knit.Report.Input.Visualization.Diagrams: (.=) :: MonadState s m => ASetter s s a b -> b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (.>) :: (IsName a1, IsName a2) => a1 -> a2 -> Name
+ Knit.Report.Input.Visualization.Diagrams: (.>>) :: (Qualifiable q, IsName a) => a -> q -> q
+ Knit.Report.Input.Visualization.Diagrams: (.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (.@~) :: () => AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (.~) :: () => ASetter s t a b -> b -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (//=) :: (MonadState s m, Fractional a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (//~) :: Fractional a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (:&) :: a -> b -> (:&) a b
+ Knit.Report.Input.Visualization.Diagrams: (<#%=) :: MonadState s m => ALens s s a b -> (a -> b) -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<#%~) :: () => ALens s t a b -> (a -> b) -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<#=) :: MonadState s m => ALens s s a b -> b -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<#~) :: () => ALens s t a b -> b -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<$) :: Functor f => a -> f b -> f a
+ Knit.Report.Input.Visualization.Diagrams: (<$>) :: Functor f => (a -> b) -> f a -> f b
+ Knit.Report.Input.Visualization.Diagrams: (<%=) :: MonadState s m => LensLike ((,) b) s s a b -> (a -> b) -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<%@=) :: MonadState s m => Over (Indexed i) ((,) b) s s a b -> (i -> a -> b) -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<%@~) :: () => Over (Indexed i) ((,) b) s t a b -> (i -> a -> b) -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<%~) :: () => LensLike ((,) b) s t a b -> (a -> b) -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Knit.Report.Input.Visualization.Diagrams: (<&&~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Knit.Report.Input.Visualization.Diagrams: (<&>) :: Functor f => f a -> (a -> b) -> f b
+ Knit.Report.Input.Visualization.Diagrams: (<*) :: Applicative f => f a -> f b -> f a
+ Knit.Report.Input.Visualization.Diagrams: (<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<**~) :: Floating a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
+ Knit.Report.Input.Visualization.Diagrams: (<*~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<+~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<->) :: () => (u -> v) -> (v -> u) -> u :-: v
+ Knit.Report.Input.Visualization.Diagrams: (<-~) :: Num a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r
+ Knit.Report.Input.Visualization.Diagrams: (<.=) :: MonadState s m => ASetter s s a b -> b -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<.~) :: () => ASetter s t a b -> b -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<//~) :: Fractional a => LensLike ((,) a) s t a a -> a -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<%=) :: (Strong p, MonadState s m) => Over p ((,) a) s s a b -> p a b -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<%@=) :: MonadState s m => Over (Indexed i) ((,) a) s s a b -> (i -> a -> b) -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<%@~) :: () => Over (Indexed i) ((,) a) s t a b -> (i -> a -> b) -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<%~) :: () => LensLike ((,) a) s t a b -> (a -> b) -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<&&=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Knit.Report.Input.Visualization.Diagrams: (<<&&~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<**=) :: (MonadState s m, Floating a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<**~) :: Floating a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<*=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<*~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<+=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<+~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<-=) :: (MonadState s m, Num a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<-~) :: Num a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<.=) :: MonadState s m => LensLike ((,) a) s s a b -> b -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<.~) :: () => LensLike ((,) a) s t a b -> b -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<//=) :: (MonadState s m, Fractional a) => LensLike' ((,) a) s a -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<//~) :: Fractional a => LensLike' ((,) a) s a -> a -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Knit.Report.Input.Visualization.Diagrams: (<<<>~) :: Monoid r => LensLike' ((,) r) s r -> r -> s -> (r, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<>=) :: (MonadState s m, Monoid r) => LensLike' ((,) r) s r -> r -> m r
+ Knit.Report.Input.Visualization.Diagrams: (<<>~) :: Monoid m => LensLike ((,) m) s t m m -> m -> s -> (m, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<?=) :: MonadState s m => LensLike ((,) a) s s a (Maybe b) -> b -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<?~) :: () => LensLike ((,) a) s t a (Maybe b) -> b -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<<^^~) :: (Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<^~) :: (Num a, Integral e) => LensLike' ((,) a) s a -> e -> s -> (a, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Knit.Report.Input.Visualization.Diagrams: (<<||~) :: () => LensLike' ((,) Bool) s Bool -> Bool -> s -> (Bool, s)
+ Knit.Report.Input.Visualization.Diagrams: (<<~) :: MonadState s m => ALens s s a b -> m b -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<>) :: Semigroup a => a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: (<>=) :: (MonadState s m, Monoid a) => ASetter' s a -> a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (<>~) :: Monoid a => ASetter s t a a -> a -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (<?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m b
+ Knit.Report.Input.Visualization.Diagrams: (<?~) :: () => ASetter s t a (Maybe b) -> b -> s -> (b, t)
+ Knit.Report.Input.Visualization.Diagrams: (<^=) :: (MonadState s m, Num a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<^^=) :: (MonadState s m, Fractional a, Integral e) => LensLike' ((,) a) s a -> e -> m a
+ Knit.Report.Input.Visualization.Diagrams: (<^^~) :: (Fractional a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<^~) :: (Num a, Integral e) => LensLike ((,) a) s t a a -> e -> s -> (a, t)
+ Knit.Report.Input.Visualization.Diagrams: (<|) :: Cons s s a a => a -> s -> s
+ Knit.Report.Input.Visualization.Diagrams: (<||=) :: MonadState s m => LensLike' ((,) Bool) s Bool -> Bool -> m Bool
+ Knit.Report.Input.Visualization.Diagrams: (<||~) :: () => LensLike ((,) Bool) s t Bool Bool -> Bool -> s -> (Bool, t)
+ Knit.Report.Input.Visualization.Diagrams: (<~) :: MonadState s m => ASetter s s a b -> m b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (===) :: (InSpace V2 n a, Juxtaposable a, Semigroup a) => a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: (>$) :: Contravariant f => b -> f b -> f a
+ Knit.Report.Input.Visualization.Diagrams: (?=) :: MonadState s m => ASetter s s a (Maybe b) -> b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (??) :: Functor f => f (a -> b) -> a -> f b
+ Knit.Report.Input.Visualization.Diagrams: (?~) :: () => ASetter s t a (Maybe b) -> b -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (@@) :: () => b -> AReview a b -> a
+ Knit.Report.Input.Visualization.Diagrams: (^#) :: () => s -> ALens s t a b -> a
+ Knit.Report.Input.Visualization.Diagrams: (^&) :: Coordinates c => PrevDim c -> FinalCoord c -> c
+ Knit.Report.Input.Visualization.Diagrams: (^*) :: (Functor f, Num a) => f a -> a -> f a
+ Knit.Report.Input.Visualization.Diagrams: (^+^) :: (Additive f, Num a) => f a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: (^-^) :: (Additive f, Num a) => f a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: (^.) :: () => s -> Getting a s a -> a
+ Knit.Report.Input.Visualization.Diagrams: (^..) :: () => s -> Getting (Endo [a]) s a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: (^/) :: (Functor f, Fractional a) => f a -> a -> f a
+ Knit.Report.Input.Visualization.Diagrams: (^=) :: (MonadState s m, Num a, Integral e) => ASetter' s a -> e -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
+ Knit.Report.Input.Visualization.Diagrams: (^?) :: () => s -> Getting (First a) s a -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: (^@.) :: () => s -> IndexedGetting i (i, a) s a -> (i, a)
+ Knit.Report.Input.Visualization.Diagrams: (^@..) :: () => s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
+ Knit.Report.Input.Visualization.Diagrams: (^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
+ Knit.Report.Input.Visualization.Diagrams: (^@?) :: () => s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
+ Knit.Report.Input.Visualization.Diagrams: (^^=) :: (MonadState s m, Fractional a, Integral e) => ASetter' s a -> e -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (^^~) :: (Fractional a, Integral e) => ASetter s t a a -> e -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (^~) :: (Num a, Integral e) => ASetter s t a a -> e -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (|>) :: Snoc s s a a => s -> a -> s
+ Knit.Report.Input.Visualization.Diagrams: (|>>) :: () => Active a -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: (||=) :: MonadState s m => ASetter' s Bool -> Bool -> m ()
+ Knit.Report.Input.Visualization.Diagrams: (|||) :: (InSpace V2 n a, Juxtaposable a, Semigroup a) => a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: (||~) :: () => ASetter s t Bool Bool -> Bool -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: (~~) :: (V t ~ v, N t ~ n, TrailLike t) => Point v n -> Point v n -> t
+ Knit.Report.Input.Visualization.Diagrams: -- (Typically, this will be some sort of monad, but it need not be.) The
+ Knit.Report.Input.Visualization.Diagrams: -- <a>Renderable</a> class guarantees that a backend will be able to
+ Knit.Report.Input.Visualization.Diagrams: -- backend.
+ Knit.Report.Input.Visualization.Diagrams: -- combined into an ultimate <a>Result</a> is completely up to the
+ Knit.Report.Input.Visualization.Diagrams: -- convert primitives into this type; how these rendered primitives are
+ Knit.Report.Input.Visualization.Diagrams: -- | Decomposition of <tt>c</tt> into applications of <a>:&amp;</a>.
+ Knit.Report.Input.Visualization.Diagrams: All :: Bool -> All
+ Knit.Report.Input.Visualization.Diagrams: Ambient :: Last Double -> Ambient
+ Knit.Report.Input.Visualization.Diagrams: Any :: Bool -> Any
+ Knit.Report.Input.Visualization.Diagrams: ArcLength :: (Sum (Interval n), n -> Sum (Interval n)) -> ArcLength n
+ Knit.Report.Input.Visualization.Diagrams: Arg :: a -> b -> Arg a b
+ Knit.Report.Input.Visualization.Diagrams: ArrowOpts :: ArrowHT n -> ArrowHT n -> Trail V2 n -> Measure n -> Measure n -> Style V2 n -> Measure n -> Style V2 n -> Measure n -> Style V2 n -> ArrowOpts n
+ Knit.Report.Input.Visualization.Diagrams: Bazaar :: (forall (f :: Type -> Type). Applicative f => p a (f b) -> f t) -> Bazaar a b t
+ Knit.Report.Input.Visualization.Diagrams: Bazaar1 :: (forall (f :: Type -> Type). Apply f => p a (f b) -> f t) -> Bazaar1 a b t
+ Knit.Report.Input.Visualization.Diagrams: Both :: AdjustSide
+ Knit.Report.Input.Visualization.Diagrams: Box :: Transformation V3 n -> Box n
+ Knit.Report.Input.Visualization.Diagrams: ByAbsolute :: n -> AdjustMethod n
+ Knit.Report.Input.Visualization.Diagrams: ByParam :: n -> AdjustMethod n
+ Knit.Report.Input.Visualization.Diagrams: Cat :: CatMethod
+ Knit.Report.Input.Visualization.Diagrams: Const :: a -> Const a
+ Knit.Report.Input.Visualization.Diagrams: Context :: (b -> t) -> a -> Context a b t
+ Knit.Report.Input.Visualization.Diagrams: CsgBox :: Box n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: CsgDifference :: CSG n -> CSG n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: CsgEllipsoid :: Ellipsoid n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: CsgFrustum :: Frustum n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: CsgIntersection :: [CSG n] -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: CsgUnion :: [CSG n] -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: Cubic :: !v n -> !v n -> !Offset c v n -> Segment c n
+ Knit.Report.Input.Visualization.Diagrams: DImage :: ImageData b -> Int -> Int -> Transformation V2 a -> DImage a b
+ Knit.Report.Input.Visualization.Diagrams: Dashing :: [n] -> n -> Dashing n
+ Knit.Report.Input.Visualization.Diagrams: Deformation :: (Point v n -> Point u n) -> Deformation n
+ Knit.Report.Input.Visualization.Diagrams: Diffuse :: Last Double -> Diffuse
+ Knit.Report.Input.Visualization.Diagrams: Distrib :: CatMethod
+ Knit.Report.Input.Visualization.Diagrams: Dual :: a -> Dual a
+ Knit.Report.Input.Visualization.Diagrams: Dynamic :: Era Rational -> (Time Rational -> a) -> Dynamic a
+ Knit.Report.Input.Visualization.Diagrams: E :: (forall x. () => Lens' (t x) x) -> E
+ Knit.Report.Input.Visualization.Diagrams: Ellipsoid :: Transformation V3 n -> Ellipsoid n
+ Knit.Report.Input.Visualization.Diagrams: End :: AdjustSide
+ Knit.Report.Input.Visualization.Diagrams: Endo :: (a -> a) -> Endo a
+ Knit.Report.Input.Visualization.Diagrams: Envelope :: Option (v n -> Max n) -> Envelope n
+ Knit.Report.Input.Visualization.Diagrams: EnvelopeOpts :: Colour Double -> Measure n -> Int -> EnvelopeOpts n
+ Knit.Report.Input.Visualization.Diagrams: EvenOdd :: FillRule
+ Knit.Report.Input.Visualization.Diagrams: FCubic :: Point v n -> Point v n -> Point v n -> Point v n -> FixedSegment n
+ Knit.Report.Input.Visualization.Diagrams: FLinear :: Point v n -> Point v n -> FixedSegment n
+ Knit.Report.Input.Visualization.Diagrams: First :: a -> First a
+ Knit.Report.Input.Visualization.Diagrams: Fold :: Fold s a -> ReifiedFold s a
+ Knit.Report.Input.Visualization.Diagrams: Frustum :: n -> n -> Transformation V3 n -> Frustum n
+ Knit.Report.Input.Visualization.Diagrams: GetSegment :: t -> GetSegment t
+ Knit.Report.Input.Visualization.Diagrams: GetSegmentCodomain :: Maybe (v n, Segment Closed v n, AnIso' n n) -> GetSegmentCodomain n
+ Knit.Report.Input.Visualization.Diagrams: Getter :: Getter s a -> ReifiedGetter s a
+ Knit.Report.Input.Visualization.Diagrams: GradPad :: SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: GradReflect :: SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: GradRepeat :: SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: GradientStop :: SomeColor -> d -> GradientStop d
+ Knit.Report.Input.Visualization.Diagrams: Highlight :: Last Specular -> Highlight
+ Knit.Report.Input.Visualization.Diagrams: Identity :: a -> Identity a
+ Knit.Report.Input.Visualization.Diagrams: Indexed :: (i -> a -> b) -> Indexed i a b
+ Knit.Report.Input.Visualization.Diagrams: IndexedFold :: IndexedFold i s a -> ReifiedIndexedFold i s a
+ Knit.Report.Input.Visualization.Diagrams: IndexedGetter :: IndexedGetter i s a -> ReifiedIndexedGetter i s a
+ Knit.Report.Input.Visualization.Diagrams: IndexedLens :: IndexedLens i s t a b -> ReifiedIndexedLens i s t a b
+ Knit.Report.Input.Visualization.Diagrams: IndexedSetter :: IndexedSetter i s t a b -> ReifiedIndexedSetter i s t a b
+ Knit.Report.Input.Visualization.Diagrams: IndexedTraversal :: IndexedTraversal i s t a b -> ReifiedIndexedTraversal i s t a b
+ Knit.Report.Input.Visualization.Diagrams: Iso :: Iso s t a b -> ReifiedIso s t a b
+ Knit.Report.Input.Visualization.Diagrams: LG :: LGradient n -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: LGradient :: [GradientStop n] -> Point V2 n -> Point V2 n -> Transformation V2 n -> SpreadMethod -> LGradient n
+ Knit.Report.Input.Visualization.Diagrams: Last :: a -> Last a
+ Knit.Report.Input.Visualization.Diagrams: Lens :: Lens s t a b -> ReifiedLens s t a b
+ Knit.Report.Input.Visualization.Diagrams: LineCapButt :: LineCap
+ Knit.Report.Input.Visualization.Diagrams: LineCapRound :: LineCap
+ Knit.Report.Input.Visualization.Diagrams: LineCapSquare :: LineCap
+ Knit.Report.Input.Visualization.Diagrams: LineJoinBevel :: LineJoin
+ Knit.Report.Input.Visualization.Diagrams: LineJoinMiter :: LineJoin
+ Knit.Report.Input.Visualization.Diagrams: LineJoinRound :: LineJoin
+ Knit.Report.Input.Visualization.Diagrams: LineMiterLimit :: Last Double -> LineMiterLimit
+ Knit.Report.Input.Visualization.Diagrams: Linear :: !Offset c v n -> Segment c n
+ Knit.Report.Input.Visualization.Diagrams: Loc :: Point (V a) (N a) -> a -> Located a
+ Knit.Report.Input.Visualization.Diagrams: Max :: a -> Max a
+ Knit.Report.Input.Visualization.Diagrams: MethodName :: Name -> Name -> DefName
+ Knit.Report.Input.Visualization.Diagrams: Min :: a -> Min a
+ Knit.Report.Input.Visualization.Diagrams: NoOrient :: PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: OffsetEnvelope :: !TotalOffset v n -> Envelope v n -> OffsetEnvelope n
+ Knit.Report.Input.Visualization.Diagrams: Option :: Maybe a -> Option a
+ Knit.Report.Input.Visualization.Diagrams: OrientH :: PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: OrientTo :: V2 n -> PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: OrientV :: PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: OriginOpts :: Colour Double -> n -> n -> OriginOpts n
+ Knit.Report.Input.Visualization.Diagrams: OrthoLens :: n -> n -> OrthoLens n
+ Knit.Report.Input.Visualization.Diagrams: P :: f a -> Point a
+ Knit.Report.Input.Visualization.Diagrams: ParallelLight :: V3 n -> Colour Double -> ParallelLight n
+ Knit.Report.Input.Visualization.Diagrams: Path :: [Located (Trail v n)] -> Path n
+ Knit.Report.Input.Visualization.Diagrams: PerspectiveLens :: Angle n -> Angle n -> PerspectiveLens n
+ Knit.Report.Input.Visualization.Diagrams: PointLight :: Point V3 n -> Colour Double -> PointLight n
+ Knit.Report.Input.Visualization.Diagrams: PolyPolar :: [Angle n] -> [n] -> PolyType n
+ Knit.Report.Input.Visualization.Diagrams: PolyRegular :: Int -> n -> PolyType n
+ Knit.Report.Input.Visualization.Diagrams: PolySides :: [Angle n] -> [n] -> PolyType n
+ Knit.Report.Input.Visualization.Diagrams: PolygonOpts :: PolyType n -> PolyOrientation n -> Point V2 n -> PolygonOpts n
+ Knit.Report.Input.Visualization.Diagrams: Prism :: Prism s t a b -> ReifiedPrism s t a b
+ Knit.Report.Input.Visualization.Diagrams: Product :: a -> Product a
+ Knit.Report.Input.Visualization.Diagrams: Query :: (Point v n -> m) -> Query n m
+ Knit.Report.Input.Visualization.Diagrams: RG :: RGradient n -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: RGB :: !a -> !a -> !a -> RGB a
+ Knit.Report.Input.Visualization.Diagrams: RGradient :: [GradientStop n] -> Point V2 n -> n -> Point V2 n -> n -> Transformation V2 n -> SpreadMethod -> RGradient n
+ Knit.Report.Input.Visualization.Diagrams: RoundedRectOpts :: d -> d -> d -> d -> RoundedRectOpts d
+ Knit.Report.Input.Visualization.Diagrams: SC :: SomeColor -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: SegCount :: Sum Int -> SegCount
+ Knit.Report.Input.Visualization.Diagrams: SegTree :: FingerTree (SegMeasure v n) (Segment Closed v n) -> SegTree n
+ Knit.Report.Input.Visualization.Diagrams: Setter :: Setter s t a b -> ReifiedSetter s t a b
+ Knit.Report.Input.Visualization.Diagrams: Specular :: Double -> Double -> Specular
+ Knit.Report.Input.Visualization.Diagrams: StarFun :: (Int -> Int) -> StarOpts
+ Knit.Report.Input.Visualization.Diagrams: StarSkip :: Int -> StarOpts
+ Knit.Report.Input.Visualization.Diagrams: Start :: AdjustSide
+ Knit.Report.Input.Visualization.Diagrams: StrokeOpts :: [[a]] -> FillRule -> StrokeOpts a
+ Knit.Report.Input.Visualization.Diagrams: SubMap :: Map Name [Subdiagram b v n m] -> SubMap b n m
+ Knit.Report.Input.Visualization.Diagrams: Subdiagram :: QDiagram b v n m -> DownAnnots v n -> Subdiagram b n m
+ Knit.Report.Input.Visualization.Diagrams: Sum :: a -> Sum a
+ Knit.Report.Input.Visualization.Diagrams: SurfaceColor :: Last (Colour Double) -> SurfaceColor
+ Knit.Report.Input.Visualization.Diagrams: Tangent :: t -> Tangent t
+ Knit.Report.Input.Visualization.Diagrams: ToAbsolute :: n -> AdjustMethod n
+ Knit.Report.Input.Visualization.Diagrams: TopName :: Name -> DefName
+ Knit.Report.Input.Visualization.Diagrams: TotalOffset :: v n -> TotalOffset n
+ Knit.Report.Input.Visualization.Diagrams: Trace :: (Point v n -> v n -> SortedList n) -> Trace n
+ Knit.Report.Input.Visualization.Diagrams: TraceOpts :: Colour Double -> n -> n -> Int -> TraceOpts n
+ Knit.Report.Input.Visualization.Diagrams: TransInv :: t -> TransInv t
+ Knit.Report.Input.Visualization.Diagrams: Traversal :: Traversal s t a b -> ReifiedTraversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: V2 :: !a -> !a -> V2 a
+ Knit.Report.Input.Visualization.Diagrams: V3 :: !a -> !a -> !a -> V3 a
+ Knit.Report.Input.Visualization.Diagrams: Winding :: FillRule
+ Knit.Report.Input.Visualization.Diagrams: WrapMonoid :: m -> WrappedMonoid m
+ Knit.Report.Input.Visualization.Diagrams: [Attribute] :: forall (v :: Type -> Type) n a. AttributeClass a => a -> Attribute v n
+ Knit.Report.Input.Visualization.Diagrams: [Identical] :: forall k k1 (a :: k) (b :: k1) (s :: k) (t :: k1). () => Identical a b a b
+ Knit.Report.Input.Visualization.Diagrams: [ImageNative] :: forall a t. () => t -> ImageData (Native t)
+ Knit.Report.Input.Visualization.Diagrams: [ImageRaster] :: forall a. () => DynamicImage -> ImageData Embedded
+ Knit.Report.Input.Visualization.Diagrams: [ImageRef] :: forall a. () => FilePath -> ImageData External
+ Knit.Report.Input.Visualization.Diagrams: [Line] :: forall l (v :: Type -> Type) n. () => SegTree v n -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: [Loop] :: forall l (v :: Type -> Type) n. () => SegTree v n -> Segment Open v n -> Trail' Loop v n
+ Knit.Report.Input.Visualization.Diagrams: [MAttribute] :: forall (v :: Type -> Type) n a. AttributeClass a => Measured n a -> Attribute v n
+ Knit.Report.Input.Visualization.Diagrams: [OffsetClosed] :: forall c (v :: Type -> Type) n. () => v n -> Offset Closed v n
+ Knit.Report.Input.Visualization.Diagrams: [OffsetOpen] :: forall c (v :: Type -> Type) n. () => Offset Open v n
+ Knit.Report.Input.Visualization.Diagrams: [Prim] :: forall b (v :: Type -> Type) n p. (Transformable p, Typeable p, Renderable p b) => p -> Prim b (V p) (N p)
+ Knit.Report.Input.Visualization.Diagrams: [SomeColor] :: forall c. Color c => c -> SomeColor
+ Knit.Report.Input.Visualization.Diagrams: [TAttribute] :: forall (v :: Type -> Type) n a. (AttributeClass a, Transformable a, V a ~ v, N a ~ n) => a -> Attribute v n
+ Knit.Report.Input.Visualization.Diagrams: [Trail] :: forall (v :: Type -> Type) n l. () => Trail' l v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: [_arrowHead] :: ArrowOpts n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: [_arrowShaft] :: ArrowOpts n -> Trail V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_arrowTail] :: ArrowOpts n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: [_eColor] :: EnvelopeOpts n -> Colour Double
+ Knit.Report.Input.Visualization.Diagrams: [_eLineWidth] :: EnvelopeOpts n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: [_ePoints] :: EnvelopeOpts n -> Int
+ Knit.Report.Input.Visualization.Diagrams: [_headGap] :: ArrowOpts n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: [_headLength] :: ArrowOpts n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: [_headStyle] :: ArrowOpts n -> Style V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_horizontalFieldOfView] :: PerspectiveLens n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: [_lGradEnd] :: LGradient n -> Point V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_lGradSpreadMethod] :: LGradient n -> SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: [_lGradStart] :: LGradient n -> Point V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_lGradStops] :: LGradient n -> [GradientStop n]
+ Knit.Report.Input.Visualization.Diagrams: [_lGradTrans] :: LGradient n -> Transformation V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_oColor] :: OriginOpts n -> Colour Double
+ Knit.Report.Input.Visualization.Diagrams: [_oMinSize] :: OriginOpts n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_oScale] :: OriginOpts n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_oeEnvelope] :: OffsetEnvelope n -> Envelope v n
+ Knit.Report.Input.Visualization.Diagrams: [_oeOffset] :: OffsetEnvelope n -> !TotalOffset v n
+ Knit.Report.Input.Visualization.Diagrams: [_orthoHeight] :: OrthoLens n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_orthoWidth] :: OrthoLens n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_polyCenter] :: PolygonOpts n -> Point V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_polyOrient] :: PolygonOpts n -> PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: [_polyType] :: PolygonOpts n -> PolyType n
+ Knit.Report.Input.Visualization.Diagrams: [_queryFillRule] :: StrokeOpts a -> FillRule
+ Knit.Report.Input.Visualization.Diagrams: [_rGradCenter0] :: RGradient n -> Point V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_rGradCenter1] :: RGradient n -> Point V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_rGradRadius0] :: RGradient n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_rGradRadius1] :: RGradient n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_rGradSpreadMethod] :: RGradient n -> SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: [_rGradStops] :: RGradient n -> [GradientStop n]
+ Knit.Report.Input.Visualization.Diagrams: [_rGradTrans] :: RGradient n -> Transformation V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_radiusBL] :: RoundedRectOpts d -> d
+ Knit.Report.Input.Visualization.Diagrams: [_radiusBR] :: RoundedRectOpts d -> d
+ Knit.Report.Input.Visualization.Diagrams: [_radiusTL] :: RoundedRectOpts d -> d
+ Knit.Report.Input.Visualization.Diagrams: [_radiusTR] :: RoundedRectOpts d -> d
+ Knit.Report.Input.Visualization.Diagrams: [_shaftStyle] :: ArrowOpts n -> Style V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_specularIntensity] :: Specular -> Double
+ Knit.Report.Input.Visualization.Diagrams: [_specularSize] :: Specular -> Double
+ Knit.Report.Input.Visualization.Diagrams: [_stopColor] :: GradientStop d -> SomeColor
+ Knit.Report.Input.Visualization.Diagrams: [_stopFraction] :: GradientStop d -> d
+ Knit.Report.Input.Visualization.Diagrams: [_tColor] :: TraceOpts n -> Colour Double
+ Knit.Report.Input.Visualization.Diagrams: [_tMinSize] :: TraceOpts n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_tPoints] :: TraceOpts n -> Int
+ Knit.Report.Input.Visualization.Diagrams: [_tScale] :: TraceOpts n -> n
+ Knit.Report.Input.Visualization.Diagrams: [_tailGap] :: ArrowOpts n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: [_tailLength] :: ArrowOpts n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: [_tailStyle] :: ArrowOpts n -> Style V2 n
+ Knit.Report.Input.Visualization.Diagrams: [_vertexNames] :: StrokeOpts a -> [[a]]
+ Knit.Report.Input.Visualization.Diagrams: [_verticalFieldOfView] :: PerspectiveLens n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: [appEndo] :: Endo a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: [appTrace] :: Trace n -> Point v n -> v n -> SortedList n
+ Knit.Report.Input.Visualization.Diagrams: [channelBlue] :: RGB a -> !a
+ Knit.Report.Input.Visualization.Diagrams: [channelGreen] :: RGB a -> !a
+ Knit.Report.Input.Visualization.Diagrams: [channelRed] :: RGB a -> !a
+ Knit.Report.Input.Visualization.Diagrams: [el] :: E -> forall x. () => Lens' (t x) x
+ Knit.Report.Input.Visualization.Diagrams: [era] :: Dynamic a -> Era Rational
+ Knit.Report.Input.Visualization.Diagrams: [getAll] :: All -> Bool
+ Knit.Report.Input.Visualization.Diagrams: [getAny] :: Any -> Bool
+ Knit.Report.Input.Visualization.Diagrams: [getConst] :: Const a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getDual] :: Dual a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getFirst] :: First a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getLast] :: Last a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getMax] :: Max a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getMin] :: Min a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getOption] :: Option a -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: [getProduct] :: Product a -> a
+ Knit.Report.Input.Visualization.Diagrams: [getSum] :: Sum a -> a
+ Knit.Report.Input.Visualization.Diagrams: [loc] :: Located a -> Point (V a) (N a)
+ Knit.Report.Input.Visualization.Diagrams: [runBazaar1] :: Bazaar1 a b t -> forall (f :: Type -> Type). Apply f => p a (f b) -> f t
+ Knit.Report.Input.Visualization.Diagrams: [runBazaar] :: Bazaar a b t -> forall (f :: Type -> Type). Applicative f => p a (f b) -> f t
+ Knit.Report.Input.Visualization.Diagrams: [runDynamic] :: Dynamic a -> Time Rational -> a
+ Knit.Report.Input.Visualization.Diagrams: [runFold] :: ReifiedFold s a -> Fold s a
+ Knit.Report.Input.Visualization.Diagrams: [runGetter] :: ReifiedGetter s a -> Getter s a
+ Knit.Report.Input.Visualization.Diagrams: [runIdentity] :: Identity a -> a
+ Knit.Report.Input.Visualization.Diagrams: [runIndexedFold] :: ReifiedIndexedFold i s a -> IndexedFold i s a
+ Knit.Report.Input.Visualization.Diagrams: [runIndexedGetter] :: ReifiedIndexedGetter i s a -> IndexedGetter i s a
+ Knit.Report.Input.Visualization.Diagrams: [runIndexedLens] :: ReifiedIndexedLens i s t a b -> IndexedLens i s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runIndexedSetter] :: ReifiedIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runIndexedTraversal] :: ReifiedIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runIndexed] :: Indexed i a b -> i -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: [runIso] :: ReifiedIso s t a b -> Iso s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runLens] :: ReifiedLens s t a b -> Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runPrism] :: ReifiedPrism s t a b -> Prism s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runQuery] :: Query n m -> Point v n -> m
+ Knit.Report.Input.Visualization.Diagrams: [runSetter] :: ReifiedSetter s t a b -> Setter s t a b
+ Knit.Report.Input.Visualization.Diagrams: [runTraversal] :: ReifiedTraversal s t a b -> Traversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: [unLoc] :: Located a -> a
+ Knit.Report.Input.Visualization.Diagrams: [unwrapMonoid] :: WrappedMonoid m -> m
+ Knit.Report.Input.Visualization.Diagrams: _1 :: Field1 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _1' :: Field1 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _10 :: Field10 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _10' :: Field10 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _11 :: Field11 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _11' :: Field11 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _12 :: Field12 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _12' :: Field12 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _13 :: Field13 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _13' :: Field13 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _14 :: Field14 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _14' :: Field14 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _15 :: Field15 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _15' :: Field15 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _16 :: Field16 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _16' :: Field16 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _17 :: Field17 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _17' :: Field17 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _18 :: Field18 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _18' :: Field18 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _19 :: Field19 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _19' :: Field19 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _2 :: Field2 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _2' :: Field2 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _3 :: Field3 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _3' :: Field3 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _4 :: Field4 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _4' :: Field4 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _5 :: Field5 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _5' :: Field5 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _6 :: Field6 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _6' :: Field6 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _7 :: Field7 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _7' :: Field7 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _8 :: Field8 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _8' :: Field8 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _9 :: Field9 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _9' :: Field9 s t a b => Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: _AC :: () => Prism' (Texture n) (AlphaColour Double)
+ Knit.Report.Input.Visualization.Diagrams: _Ambient :: Iso' Ambient Double
+ Knit.Report.Input.Visualization.Diagrams: _Clip :: () => Iso (Clip n) (Clip n') [Path V2 n] [Path V2 n']
+ Knit.Report.Input.Visualization.Diagrams: _Commit :: () => Prism' (Recommend a) a
+ Knit.Report.Input.Visualization.Diagrams: _Cons :: Cons s t a b => Prism s t (a, s) (b, t)
+ Knit.Report.Input.Visualization.Diagrams: _Diffuse :: Iso' Diffuse Double
+ Knit.Report.Input.Visualization.Diagrams: _Dir :: () => Iso' (Direction v n) (v n)
+ Knit.Report.Input.Visualization.Diagrams: _Empty :: AsEmpty a => Prism' a ()
+ Knit.Report.Input.Visualization.Diagrams: _FillOpacity :: Iso' FillOpacity Double
+ Knit.Report.Input.Visualization.Diagrams: _FillTexture :: () => Iso' (FillTexture n) (Recommend (Texture n))
+ Knit.Report.Input.Visualization.Diagrams: _GWrapped' :: (Generic s, D1 d (C1 c (S1 s' (Rec0 a))) ~ Rep s, Unwrapped s ~ GUnwrapped (Rep s)) => Iso' s (Unwrapped s)
+ Knit.Report.Input.Visualization.Diagrams: _Highlight :: Iso' Highlight Specular
+ Knit.Report.Input.Visualization.Diagrams: _Just :: () => Prism (Maybe a) (Maybe b) a b
+ Knit.Report.Input.Visualization.Diagrams: _LG :: () => Prism' (Texture n) (LGradient n)
+ Knit.Report.Input.Visualization.Diagrams: _Left :: () => Prism (Either a c) (Either b c) a b
+ Knit.Report.Input.Visualization.Diagrams: _Line :: () => Prism' (Trail v n) (Trail' Line v n)
+ Knit.Report.Input.Visualization.Diagrams: _LineMiterLimit :: Iso' LineMiterLimit Double
+ Knit.Report.Input.Visualization.Diagrams: _LineTexture :: () => Iso (LineTexture n) (LineTexture n') (Texture n) (Texture n')
+ Knit.Report.Input.Visualization.Diagrams: _LineWidth :: () => Iso' (LineWidth n) n
+ Knit.Report.Input.Visualization.Diagrams: _LineWidthM :: () => Iso' (LineWidthM n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: _LocLine :: () => Prism' (Located (Trail v n)) (Located (Trail' Line v n))
+ Knit.Report.Input.Visualization.Diagrams: _LocLoop :: () => Prism' (Located (Trail v n)) (Located (Trail' Loop v n))
+ Knit.Report.Input.Visualization.Diagrams: _Loop :: () => Prism' (Trail v n) (Trail' Loop v n)
+ Knit.Report.Input.Visualization.Diagrams: _Nothing :: () => Prism' (Maybe a) ()
+ Knit.Report.Input.Visualization.Diagrams: _Opacity :: Iso' Opacity Double
+ Knit.Report.Input.Visualization.Diagrams: _Point :: () => Iso' (Point f a) (f a)
+ Knit.Report.Input.Visualization.Diagrams: _RG :: () => Prism' (Texture n) (RGradient n)
+ Knit.Report.Input.Visualization.Diagrams: _Recommend :: () => Prism' (Recommend a) a
+ Knit.Report.Input.Visualization.Diagrams: _Right :: () => Prism (Either c a) (Either c b) a b
+ Knit.Report.Input.Visualization.Diagrams: _SC :: () => Prism' (Texture n) SomeColor
+ Knit.Report.Input.Visualization.Diagrams: _Show :: (Read a, Show a) => Prism' String a
+ Knit.Report.Input.Visualization.Diagrams: _Snoc :: Snoc s t a b => Prism s t (s, a) (t, b)
+ Knit.Report.Input.Visualization.Diagrams: _SomeColor :: Iso' SomeColor (AlphaColour Double)
+ Knit.Report.Input.Visualization.Diagrams: _StrokeOpacity :: Iso' StrokeOpacity Double
+ Knit.Report.Input.Visualization.Diagrams: _SurfaceColor :: Iso' SurfaceColor (Colour Double)
+ Knit.Report.Input.Visualization.Diagrams: _Unwrapped :: Rewrapping s t => Iso (Unwrapped t) (Unwrapped s) t s
+ Knit.Report.Input.Visualization.Diagrams: _Unwrapped' :: Wrapped s => Iso' (Unwrapped s) s
+ Knit.Report.Input.Visualization.Diagrams: _Unwrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso (Unwrapped t) (Unwrapped s) t s
+ Knit.Report.Input.Visualization.Diagrams: _Unwrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' (Unwrapped s) s
+ Knit.Report.Input.Visualization.Diagrams: _Void :: () => Prism s s a Void
+ Knit.Report.Input.Visualization.Diagrams: _Wrapped :: Rewrapping s t => Iso s t (Unwrapped s) (Unwrapped t)
+ Knit.Report.Input.Visualization.Diagrams: _Wrapped' :: Wrapped s => Iso' s (Unwrapped s)
+ Knit.Report.Input.Visualization.Diagrams: _Wrapping :: Rewrapping s t => (Unwrapped s -> s) -> Iso s t (Unwrapped s) (Unwrapped t)
+ Knit.Report.Input.Visualization.Diagrams: _Wrapping' :: Wrapped s => (Unwrapped s -> s) -> Iso' s (Unwrapped s)
+ Knit.Report.Input.Visualization.Diagrams: _ambient :: () => Lens' (Style v n) (Maybe Double)
+ Knit.Report.Input.Visualization.Diagrams: _clip :: (Typeable n, OrderedField n) => Lens' (Style V2 n) [Path V2 n]
+ Knit.Report.Input.Visualization.Diagrams: _dashing :: Typeable n => Lens' (Style v n) (Maybe (Measured n (Dashing n)))
+ Knit.Report.Input.Visualization.Diagrams: _dashingU :: Typeable n => Lens' (Style v n) (Maybe (Dashing n))
+ Knit.Report.Input.Visualization.Diagrams: _diffuse :: () => Lens' (Style v n) (Maybe Double)
+ Knit.Report.Input.Visualization.Diagrams: _fillOpacity :: () => Lens' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: _fillRule :: () => Lens' (Style V2 n) FillRule
+ Knit.Report.Input.Visualization.Diagrams: _fillTexture :: (Typeable n, Floating n) => Lens' (Style V2 n) (Texture n)
+ Knit.Report.Input.Visualization.Diagrams: _font :: () => Lens' (Style v n) (Maybe String)
+ Knit.Report.Input.Visualization.Diagrams: _fontSize :: (Typeable n, OrderedField n) => Lens' (Style v n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: _fontSizeR :: (Typeable n, OrderedField n) => Lens' (Style v n) (Measured n (Recommend n))
+ Knit.Report.Input.Visualization.Diagrams: _head :: Cons s s a a => Traversal' s a
+ Knit.Report.Input.Visualization.Diagrams: _highlight :: () => Lens' (Style v n) (Maybe Specular)
+ Knit.Report.Input.Visualization.Diagrams: _init :: Snoc s s a a => Traversal' s s
+ Knit.Report.Input.Visualization.Diagrams: _last :: Snoc s s a a => Traversal' s a
+ Knit.Report.Input.Visualization.Diagrams: _lineCap :: () => Lens' (Style v n) LineCap
+ Knit.Report.Input.Visualization.Diagrams: _lineJoin :: () => Lens' (Style v n) LineJoin
+ Knit.Report.Input.Visualization.Diagrams: _lineMiterLimit :: () => Lens' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: _lineTexture :: (Floating n, Typeable n) => Lens' (Style V2 n) (Texture n)
+ Knit.Report.Input.Visualization.Diagrams: _lineWidth :: (Typeable n, OrderedField n) => Lens' (Style v n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: _lineWidthU :: Typeable n => Lens' (Style v n) (Maybe n)
+ Knit.Report.Input.Visualization.Diagrams: _loc :: () => Lens' (Located a) (Point (V a) (N a))
+ Knit.Report.Input.Visualization.Diagrams: _lw :: (Typeable n, OrderedField n) => Lens' (Style v n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: _opacity :: () => Lens' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: _phi :: (HasPhi t, RealFloat n) => Lens' (t n) (Angle n)
+ Knit.Report.Input.Visualization.Diagrams: _r :: (HasR t, RealFloat n) => Lens' (t n) n
+ Knit.Report.Input.Visualization.Diagrams: _recommend :: () => Lens (Recommend a) (Recommend b) a b
+ Knit.Report.Input.Visualization.Diagrams: _sc :: () => Lens' (Style v n) (Maybe (Colour Double))
+ Knit.Report.Input.Visualization.Diagrams: _strokeOpacity :: () => Lens' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: _tail :: Cons s s a a => Traversal' s s
+ Knit.Report.Input.Visualization.Diagrams: _theta :: (HasTheta t, RealFloat n) => Lens' (t n) (Angle n)
+ Knit.Report.Input.Visualization.Diagrams: _x :: R1 t => Lens' (t a) a
+ Knit.Report.Input.Visualization.Diagrams: _xy :: R2 t => Lens' (t a) (V2 a)
+ Knit.Report.Input.Visualization.Diagrams: _xyz :: R3 t => Lens' (t a) (V3 a)
+ Knit.Report.Input.Visualization.Diagrams: _y :: R2 t => Lens' (t a) a
+ Knit.Report.Input.Visualization.Diagrams: _z :: R3 t => Lens' (t a) a
+ Knit.Report.Input.Visualization.Diagrams: abbreviatedFields :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: abbreviatedNamer :: FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: aboutX :: Floating n => Angle n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: aboutY :: Floating n => Angle n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: aboutZ :: Floating n => Angle n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: absolute :: (Additive v, Num n) => SizeSpec v n
+ Knit.Report.Input.Visualization.Diagrams: acosA :: Floating n => n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: activeEnd :: () => Active a -> a
+ Knit.Report.Input.Visualization.Diagrams: activeEra :: () => Active a -> Maybe (Era Rational)
+ Knit.Report.Input.Visualization.Diagrams: activeStart :: () => Active a -> a
+ Knit.Report.Input.Visualization.Diagrams: addDiagramAsSVG :: (PandocEffects effs, Member ToPandoc effs, Member UnusedId effs) => Maybe Text -> Maybe Text -> Double -> Double -> QDiagram SVG V2 Double Any -> Sem effs Text
+ Knit.Report.Input.Visualization.Diagrams: adjEps :: () => Lens' (AdjustOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: adjMethod :: () => Lens' (AdjustOpts n) (AdjustMethod n)
+ Knit.Report.Input.Visualization.Diagrams: adjSide :: () => Lens' (AdjustOpts n) AdjustSide
+ Knit.Report.Input.Visualization.Diagrams: adjust :: (N t ~ n, Sectionable t, HasArcLength t, Fractional n) => t -> AdjustOpts n -> t
+ Knit.Report.Input.Visualization.Diagrams: adjustDia :: (Backend b v n, Additive v, Monoid' m, Num n) => b -> Options b v n -> QDiagram b v n m -> (Options b v n, Transformation v n, QDiagram b v n m)
+ Knit.Report.Input.Visualization.Diagrams: after :: () => Active a -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: ala :: (Functor f, Rewrapping s t) => (Unwrapped s -> s) -> ((Unwrapped t -> t) -> f s) -> f (Unwrapped s)
+ Knit.Report.Input.Visualization.Diagrams: alaf :: (Functor f, Functor g, Rewrapping s t) => (Unwrapped s -> s) -> (f t -> g s) -> f (Unwrapped t) -> g (Unwrapped s)
+ Knit.Report.Input.Visualization.Diagrams: aliceblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: align :: (InSpace v n a, Fractional n, Alignable a, HasOrigin a) => v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignB :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignBL :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignBR :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignBy :: (Alignable a, InSpace v n a, Fractional n, HasOrigin a) => v n -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignBy' :: (Alignable a, InSpace v n a, Fractional n, HasOrigin a) => (v n -> a -> Point v n) -> v n -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignBy'Default :: (InSpace v n a, Fractional n, HasOrigin a) => (v n -> a -> Point v n) -> v n -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignL :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignR :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignT :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignTL :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignTR :: (InSpace V2 n a, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignX :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignXMax :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignXMin :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignY :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignYMax :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignYMin :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignZMax :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignZMin :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: alignedText :: (TypeableFloat n, Renderable (Text n) b) => n -> n -> String -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: allOf :: () => Getting All s a -> (a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: alongside :: () => LensLike (AlongsideLeft f b') s t a b -> LensLike (AlongsideRight f t) s' t' a' b' -> LensLike f (s, s') (t, t') (a, a') (b, b')
+ Knit.Report.Input.Visualization.Diagrams: alphaChannel :: () => AlphaColour a -> a
+ Knit.Report.Input.Visualization.Diagrams: alphaColourConvert :: (Fractional b, Real a) => AlphaColour a -> AlphaColour b
+ Knit.Report.Input.Visualization.Diagrams: ambient :: HasStyle d => Double -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: andOf :: () => Getting All s Bool -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: angleBetween :: (Metric v, Floating n, Ord n) => v n -> v n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: angleBetweenDirs :: (Metric v, Floating n, Ord n) => Direction v n -> Direction v n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: angleDir :: Floating n => Angle n -> Direction V2 n
+ Knit.Report.Input.Visualization.Diagrams: angleRatio :: Floating n => Angle n -> Angle n -> n
+ Knit.Report.Input.Visualization.Diagrams: angleV :: Floating n => Angle n -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: animEnvelope :: (OrderedField n, Metric v, Monoid' m) => QAnimation b v n m -> QAnimation b v n m
+ Knit.Report.Input.Visualization.Diagrams: animEnvelope' :: (OrderedField n, Metric v, Monoid' m) => Rational -> QAnimation b v n m -> QAnimation b v n m
+ Knit.Report.Input.Visualization.Diagrams: animRect :: (InSpace V2 n t, Monoid' m, TrailLike t, Enveloped t, Transformable t, Monoid t) => QAnimation b V2 n m -> t
+ Knit.Report.Input.Visualization.Diagrams: animRect' :: (InSpace V2 n t, Monoid' m, TrailLike t, Enveloped t, Transformable t, Monoid t) => Rational -> QAnimation b V2 n m -> t
+ Knit.Report.Input.Visualization.Diagrams: annularWedge :: (TrailLike t, V t ~ V2, N t ~ n, RealFloat n) => n -> n -> Direction V2 n -> Angle n -> t
+ Knit.Report.Input.Visualization.Diagrams: anon :: () => a -> (a -> Bool) -> Iso' (Maybe a) a
+ Knit.Report.Input.Visualization.Diagrams: antiquewhite :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: anyOf :: () => Getting Any s a -> (a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: appEnvelope :: () => Envelope v n -> Maybe (v n -> n)
+ Knit.Report.Input.Visualization.Diagrams: appends :: (Juxtaposable a, Monoid' a) => a -> [(Vn a, a)] -> a
+ Knit.Report.Input.Visualization.Diagrams: apply :: () => Transformation v n -> v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: applyAll :: () => [a -> a] -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: applyAttr :: (AttributeClass a, HasStyle d) => a -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: applyMAttr :: (AttributeClass a, N d ~ n, HasStyle d) => Measured n a -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: applyStyle :: HasStyle a => Style (V a) (N a) -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: applyTAttr :: (AttributeClass a, Transformable a, V a ~ V d, N a ~ N d, HasStyle d) => a -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: aqua :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: aquamarine :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: arc :: (InSpace V2 n t, OrderedField n, TrailLike t) => Direction V2 n -> Angle n -> t
+ Knit.Report.Input.Visualization.Diagrams: arc' :: (InSpace V2 n t, OrderedField n, TrailLike t) => n -> Direction V2 n -> Angle n -> t
+ Knit.Report.Input.Visualization.Diagrams: arcBetween :: (TrailLike t, V t ~ V2, N t ~ n, RealFloat n) => Point V2 n -> Point V2 n -> n -> t
+ Knit.Report.Input.Visualization.Diagrams: arcCCW :: (InSpace V2 n t, RealFloat n, TrailLike t) => Direction V2 n -> Direction V2 n -> t
+ Knit.Report.Input.Visualization.Diagrams: arcCW :: (InSpace V2 n t, RealFloat n, TrailLike t) => Direction V2 n -> Direction V2 n -> t
+ Knit.Report.Input.Visualization.Diagrams: arcLength :: HasArcLength p => N p -> p -> N p
+ Knit.Report.Input.Visualization.Diagrams: arcLengthBounded :: HasArcLength p => N p -> p -> Interval (N p)
+ Knit.Report.Input.Visualization.Diagrams: arcLengthToParam :: HasArcLength p => N p -> p -> N p -> N p
+ Knit.Report.Input.Visualization.Diagrams: arrow :: (TypeableFloat n, Renderable (Path V2 n) b) => n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrow' :: (TypeableFloat n, Renderable (Path V2 n) b) => ArrowOpts n -> n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowAt :: (TypeableFloat n, Renderable (Path V2 n) b) => Point V2 n -> V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowAt' :: (TypeableFloat n, Renderable (Path V2 n) b) => ArrowOpts n -> Point V2 n -> V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowBetween :: (TypeableFloat n, Renderable (Path V2 n) b) => Point V2 n -> Point V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowBetween' :: (TypeableFloat n, Renderable (Path V2 n) b) => ArrowOpts n -> Point V2 n -> Point V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowHead :: () => Lens' (ArrowOpts n) (ArrowHT n)
+ Knit.Report.Input.Visualization.Diagrams: arrowShaft :: () => Lens' (ArrowOpts n) (Trail V2 n)
+ Knit.Report.Input.Visualization.Diagrams: arrowTail :: () => Lens' (ArrowOpts n) (ArrowHT n)
+ Knit.Report.Input.Visualization.Diagrams: arrowV :: (TypeableFloat n, Renderable (Path V2 n) b) => V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowV' :: (TypeableFloat n, Renderable (Path V2 n) b) => ArrowOpts n -> V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: arrowheadDart :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowheadHalfDart :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowheadSpike :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowheadThorn :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowheadTriangle :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowtailBlock :: RealFloat n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: arrowtailQuill :: OrderedField n => Angle n -> ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: asDeformation :: (Additive v, Num n) => Transformation v n -> Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
+ Knit.Report.Input.Visualization.Diagrams: aside :: () => APrism s t a b -> Prism (e, s) (e, t) (e, a) (e, b)
+ Knit.Report.Input.Visualization.Diagrams: asinA :: Floating n => n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: aspect :: (CameraLens l, Floating n) => l n -> n
+ Knit.Report.Input.Visualization.Diagrams: assign :: MonadState s m => ASetter s s a b -> b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: assignA :: Arrow p => ASetter s t a b -> p s b -> p s t
+ Knit.Report.Input.Visualization.Diagrams: asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
+ Knit.Report.Input.Visualization.Diagrams: at :: () => a -> Point (V a) (N a) -> Located a
+ Knit.Report.Input.Visualization.Diagrams: atAttr :: AttributeClass a => Lens' (Style v n) (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: atDirection :: (InSpace v n a, Metric v, Floating n, Juxtaposable a, Semigroup a) => Direction v n -> a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: atEnd :: EndValues p => p -> Codomain p (N p)
+ Knit.Report.Input.Visualization.Diagrams: atLeast :: Ord n => Measure n -> Measure n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: atMAttr :: (AttributeClass a, Typeable n) => Lens' (Style v n) (Maybe (Measured n a))
+ Knit.Report.Input.Visualization.Diagrams: atMost :: Ord n => Measure n -> Measure n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: atParam :: Parametric p => p -> N p -> Codomain p (N p)
+ Knit.Report.Input.Visualization.Diagrams: atPoints :: (InSpace v n a, HasOrigin a, Monoid' a) => [Point v n] -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: atStart :: EndValues p => p -> Codomain p (N p)
+ Knit.Report.Input.Visualization.Diagrams: atTAttr :: (V a ~ v, N a ~ n, AttributeClass a, Transformable a) => Lens' (Style v n) (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: atTime :: () => Time Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: atan2A :: RealFloat n => n -> n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: atan2A' :: OrderedField n => n -> n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: atanA :: Floating n => n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: atop :: (OrderedField n, Metric v, Semigroup m) => QDiagram b v n m -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: au :: Functor f => AnIso s t a b -> ((b -> t) -> f s) -> f a
+ Knit.Report.Input.Visualization.Diagrams: auf :: () => Optic (Costar f) g s t a b -> (f a -> g b) -> f s -> g t
+ Knit.Report.Input.Visualization.Diagrams: avgScale :: (Additive v, Traversable v, Floating n) => Transformation v n -> n
+ Knit.Report.Input.Visualization.Diagrams: azure :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: backwards :: () => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: baselineText :: (TypeableFloat n, Renderable (Text n) b) => String -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: basis :: (Additive t, Traversable t, Num a) => [t a]
+ Knit.Report.Input.Visualization.Diagrams: basisFor :: (Traversable t, Num a) => t b -> [t a]
+ Knit.Report.Input.Visualization.Diagrams: beige :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
+ Knit.Report.Input.Visualization.Diagrams: beneath :: (Metric v, OrderedField n, Monoid' m) => QDiagram b v n m -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: beside :: (Juxtaposable a, Semigroup a) => Vn a -> a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: bezier3 :: () => v n -> v n -> v n -> Segment Closed v n
+ Knit.Report.Input.Visualization.Diagrams: bg :: (TypeableFloat n, Renderable (Path V2 n) b) => Colour Double -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: bgFrame :: (TypeableFloat n, Renderable (Path V2 n) b) => n -> Colour Double -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
+ Knit.Report.Input.Visualization.Diagrams: bimapping :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (f s s') (g t t') (f a a') (g b b')
+ Knit.Report.Input.Visualization.Diagrams: bisque :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: black :: Num a => Colour a
+ Knit.Report.Input.Visualization.Diagrams: blanchedalmond :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: blend :: (Num a, AffineSpace f) => a -> f a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: block :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: blue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: blueviolet :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: bold :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: bolder :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: both :: Bitraversable r => Traversal (r a a) (r b b) a b
+ Knit.Report.Input.Visualization.Diagrams: both1 :: Bitraversable1 r => Traversal1 (r a a) (r b b) a b
+ Knit.Report.Input.Visualization.Diagrams: boundaryFrom :: (OrderedField n, Metric v, Semigroup m) => Subdiagram b v n m -> v n -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: boundaryFromMay :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> v n -> Maybe (Point v n)
+ Knit.Report.Input.Visualization.Diagrams: boundingBox :: (InSpace v n a, HasBasis v, Enveloped a) => a -> BoundingBox v n
+ Knit.Report.Input.Visualization.Diagrams: boundingRect :: (InSpace V2 n a, SameSpace a t, Enveloped t, Transformable t, TrailLike t, Monoid t, Enveloped a) => a -> t
+ Knit.Report.Input.Visualization.Diagrams: boxCenter :: (Additive v, Fractional n) => BoundingBox v n -> Maybe (Point v n)
+ Knit.Report.Input.Visualization.Diagrams: boxExtents :: (Additive v, Num n) => BoundingBox v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: boxFit :: (InSpace v n a, HasBasis v, Enveloped a, Transformable a, Monoid a) => BoundingBox v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: boxGrid :: (Traversable v, Additive v, Num n, Enum n) => n -> BoundingBox v n -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: boxTransform :: (Additive v, Fractional n) => BoundingBox v n -> BoundingBox v n -> Maybe (Transformation v n)
+ Knit.Report.Input.Visualization.Diagrams: brown :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: bspline :: (TrailLike t, V t ~ v, N t ~ n) => BSpline v n -> t
+ Knit.Report.Input.Visualization.Diagrams: burlywood :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: bézier3 :: () => v n -> v n -> v n -> Segment Closed v n
+ Knit.Report.Input.Visualization.Diagrams: cadetblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: camAspect :: (Floating n, CameraLens l) => Camera l n -> n
+ Knit.Report.Input.Visualization.Diagrams: camForward :: () => Camera l n -> Direction V3 n
+ Knit.Report.Input.Visualization.Diagrams: camLens :: () => Camera l n -> l n
+ Knit.Report.Input.Visualization.Diagrams: camRight :: Fractional n => Camera l n -> Direction V3 n
+ Knit.Report.Input.Visualization.Diagrams: camUp :: () => Camera l n -> Direction V3 n
+ Knit.Report.Input.Visualization.Diagrams: camelCaseFields :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: camelCaseNamer :: FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: cat :: (InSpace v n a, Metric v, Floating n, Juxtaposable a, Monoid' a, HasOrigin a) => v n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: cat' :: (InSpace v n a, Metric v, Floating n, Juxtaposable a, Monoid' a, HasOrigin a) => v n -> CatOpts n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: catMethod :: () => Lens' (CatOpts n) CatMethod
+ Knit.Report.Input.Visualization.Diagrams: censoring :: MonadWriter w m => Setter w w u v -> (u -> v) -> m a -> m a
+ Knit.Report.Input.Visualization.Diagrams: center :: (InSpace v n a, Fractional n, Traversable v, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerPoint :: (InSpace v n a, HasBasis v, Enveloped a) => a -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: centerV :: (InSpace v n a, Fractional n, Alignable a, HasOrigin a) => v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerX :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerXY :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerXYZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerXZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerY :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerYZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centerZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: centroid :: (Additive v, Fractional n) => [Point v n] -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: chartreuse :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: chocolate :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: choosing :: Functor f => LensLike f s t a b -> LensLike f s' t' a b -> LensLike f (Either s s') (Either t t') a b
+ Knit.Report.Input.Visualization.Diagrams: chosen :: () => IndexPreservingLens (Either a a) (Either b b) a b
+ Knit.Report.Input.Visualization.Diagrams: circle :: (TrailLike t, V t ~ V2, N t ~ n, Transformable t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: clamp :: () => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: clampAfter :: () => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: clampBefore :: () => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: class Functor f => Additive (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Additive Diff p => Affine (p :: Type -> Type) where {
+ Knit.Report.Input.Visualization.Diagrams: class Alignable a
+ Knit.Report.Input.Visualization.Diagrams: class Functor f => Applicative (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class AsEmpty a
+ Knit.Report.Input.Visualization.Diagrams: class Ixed m => At m
+ Knit.Report.Input.Visualization.Diagrams: class (Typeable a, Semigroup a) => AttributeClass a
+ Knit.Report.Input.Visualization.Diagrams: class Backend b (v :: Type -> Type) n where {
+ Knit.Report.Input.Visualization.Diagrams: class Bifunctor (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Profunctor p => Choice (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Color c
+ Knit.Report.Input.Visualization.Diagrams: class ColourOps (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class (Choice p, Corepresentable p, Comonad Corep p, Traversable Corep p, Strong p, Representable p, Monad Rep p, MonadFix Rep p, Distributive Rep p, Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Cons s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Contains m
+ Knit.Report.Input.Visualization.Diagrams: class Contravariant (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Coordinates c where {
+ Knit.Report.Input.Visualization.Diagrams: class Default a
+ Knit.Report.Input.Visualization.Diagrams: class Deformable a b
+ Knit.Report.Input.Visualization.Diagrams: class DomainBounds p
+ Knit.Report.Input.Visualization.Diagrams: class Each s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class (Parametric p, DomainBounds p) => EndValues p
+ Knit.Report.Input.Visualization.Diagrams: class (Metric V a, OrderedField N a) => Enveloped a
+ Knit.Report.Input.Visualization.Diagrams: class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Foldable f => FoldableWithIndex i (f :: Type -> Type) | f -> i
+ Knit.Report.Input.Visualization.Diagrams: class Functor f => FunctorWithIndex i (f :: Type -> Type) | f -> i
+ Knit.Report.Input.Visualization.Diagrams: class GPlated a (g :: k -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class GPlated1 (f :: k -> Type) (g :: k -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Parametric p => HasArcLength p
+ Knit.Report.Input.Visualization.Diagrams: class HasOrigin t
+ Knit.Report.Input.Visualization.Diagrams: class HasTheta t => HasPhi (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class HasQuery t m | t -> m
+ Knit.Report.Input.Visualization.Diagrams: class HasR (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class HasStyle a
+ Knit.Report.Input.Visualization.Diagrams: class HasTheta (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Conjoined p => Indexable i (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class (Typeable a, Ord a, Show a) => IsName a
+ Knit.Report.Input.Visualization.Diagrams: class Ixed m
+ Knit.Report.Input.Visualization.Diagrams: class Juxtaposable a
+ Knit.Report.Input.Visualization.Diagrams: class (Magnified m ~ Magnified n, MonadReader b m, MonadReader a n) => Magnify (m :: Type -> Type) (n :: Type -> Type) b a | m -> b, n -> a, m a -> n, n b -> m
+ Knit.Report.Input.Visualization.Diagrams: class Additive f => Metric (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Parametric p
+ Knit.Report.Input.Visualization.Diagrams: class Plated a
+ Knit.Report.Input.Visualization.Diagrams: class Profunctor (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Qualifiable q
+ Knit.Report.Input.Visualization.Diagrams: class R1 (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class R1 t => R2 (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class R2 t => R3 (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Transformable t => Renderable t b
+ Knit.Report.Input.Visualization.Diagrams: class Reversing t
+ Knit.Report.Input.Visualization.Diagrams: class (Profunctor p, Bifunctor p) => Reviewable (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Wrapped s => Rewrapped s t
+ Knit.Report.Input.Visualization.Diagrams: class (Rewrapped s t, Rewrapped t s) => Rewrapping s t
+ Knit.Report.Input.Visualization.Diagrams: class DomainBounds p => Sectionable p
+ Knit.Report.Input.Visualization.Diagrams: class Semigroup a
+ Knit.Report.Input.Visualization.Diagrams: class (Applicative f, Distributive f, Traversable f) => Settable (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class Skinned t
+ Knit.Report.Input.Visualization.Diagrams: class Snoc s t a b | s -> a, t -> b, s b -> t, t a -> s
+ Knit.Report.Input.Visualization.Diagrams: class Strict lazy strict | lazy -> strict, strict -> lazy
+ Knit.Report.Input.Visualization.Diagrams: class Bifunctor p => Swapped (p :: Type -> Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class ToPath t
+ Knit.Report.Input.Visualization.Diagrams: class (Additive V a, Ord N a) => Traced a
+ Knit.Report.Input.Visualization.Diagrams: class (Metric V t, OrderedField N t) => TrailLike t
+ Knit.Report.Input.Visualization.Diagrams: class Transformable t
+ Knit.Report.Input.Visualization.Diagrams: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class (Foldable1 t, Traversable t) => Traversable1 (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | t -> i
+ Knit.Report.Input.Visualization.Diagrams: class Ord k => TraverseMax k (m :: Type -> Type) | m -> k
+ Knit.Report.Input.Visualization.Diagrams: class Ord k => TraverseMin k (m :: Type -> Type) | m -> k
+ Knit.Report.Input.Visualization.Diagrams: class Wrapped s where {
+ Knit.Report.Input.Visualization.Diagrams: class (MonadState s m, MonadState t n) => Zoom (m :: Type -> Type) (n :: Type -> Type) s t | m -> s, n -> t, m t -> n, n s -> m
+ Knit.Report.Input.Visualization.Diagrams: classUnderscoreNoPrefixFields :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: classUnderscoreNoPrefixNamer :: FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: classyRules :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: classyRules_ :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: clearValue :: () => QDiagram b v n m -> QDiagram b v n Any
+ Knit.Report.Input.Visualization.Diagrams: clipBy :: (HasStyle a, V a ~ V2, N a ~ n, TypeableFloat n) => Path V2 n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: clipTo :: TypeableFloat n => Path V2 n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: clipped :: TypeableFloat n => Path V2 n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexPreservingLens :: () => ALens s t a b -> IndexPreservingLens s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexPreservingSetter :: () => ASetter s t a b -> IndexPreservingSetter s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexPreservingTraversal :: () => ATraversal s t a b -> IndexPreservingTraversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexPreservingTraversal1 :: () => ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexedLens :: () => AnIndexedLens i s t a b -> IndexedLens i s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexedSetter :: () => AnIndexedSetter i s t a b -> IndexedSetter i s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexedTraversal :: () => AnIndexedTraversal i s t a b -> IndexedTraversal i s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIndexedTraversal1 :: () => AnIndexedTraversal1 i s t a b -> IndexedTraversal1 i s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneIso :: () => AnIso s t a b -> Iso s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneLens :: () => ALens s t a b -> Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: clonePrism :: () => APrism s t a b -> Prism s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneSetter :: () => ASetter s t a b -> Setter s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneTraversal :: () => ATraversal s t a b -> Traversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: cloneTraversal1 :: () => ATraversal1 s t a b -> Traversal1 s t a b
+ Knit.Report.Input.Visualization.Diagrams: closeLine :: () => Trail' Line v n -> Trail' Loop v n
+ Knit.Report.Input.Visualization.Diagrams: closeTrail :: () => Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: coerced :: (Coercible s a, Coercible t b) => Iso s t a b
+ Knit.Report.Input.Visualization.Diagrams: colorToRGBA :: Color c => c -> (Double, Double, Double, Double)
+ Knit.Report.Input.Visualization.Diagrams: colorToSRGBA :: Color c => c -> (Double, Double, Double, Double)
+ Knit.Report.Input.Visualization.Diagrams: colourConvert :: (Fractional b, Real a) => Colour a -> Colour b
+ Knit.Report.Input.Visualization.Diagrams: committed :: () => Iso (Recommend a) (Recommend b) a b
+ Knit.Report.Input.Visualization.Diagrams: composOpFold :: Plated a => b -> (b -> b -> b) -> (a -> b) -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: composeAligned :: (Monoid' m, Floating n, Ord n, Metric v) => (QDiagram b v n m -> QDiagram b v n m) -> ([QDiagram b v n m] -> QDiagram b v n m) -> [QDiagram b v n m] -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: concatMapOf :: () => Getting [r] s a -> (a -> [r]) -> s -> [r]
+ Knit.Report.Input.Visualization.Diagrams: concatOf :: () => Getting [r] s [r] -> s -> [r]
+ Knit.Report.Input.Visualization.Diagrams: cone :: Num n => Frustum n
+ Knit.Report.Input.Visualization.Diagrams: confusing :: Applicative f => LensLike (Curried (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
+ Knit.Report.Input.Visualization.Diagrams: conjoined :: Conjoined p => ((p ~ ((->) :: Type -> Type -> Type)) -> q (a -> b) r) -> q (p a b) r -> q (p a b) r
+ Knit.Report.Input.Visualization.Diagrams: conjugate :: (Additive v, Num n) => Transformation v n -> Transformation v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: connect :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => n1 -> n2 -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: connect' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => ArrowOpts n -> n1 -> n2 -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: connectOutside :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => n1 -> n2 -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: connectOutside' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => ArrowOpts n -> n1 -> n2 -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: connectPerim :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => n1 -> n2 -> Angle n -> Angle n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: connectPerim' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName n1, IsName n2) => ArrowOpts n -> n1 -> n2 -> Angle n -> Angle n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: cons :: Cons s s a a => a -> s -> s
+ Knit.Report.Input.Visualization.Diagrams: contains' :: (Additive v, Foldable v, Ord n) => BoundingBox v n -> Point v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: contexts :: Plated a => a -> [Context a a a]
+ Knit.Report.Input.Visualization.Diagrams: contextsOf :: () => ATraversal' a a -> a -> [Context a a a]
+ Knit.Report.Input.Visualization.Diagrams: contextsOn :: Plated a => ATraversal s t a a -> s -> [Context a a t]
+ Knit.Report.Input.Visualization.Diagrams: contextsOnOf :: () => ATraversal s t a a -> ATraversal' a a -> s -> [Context a a t]
+ Knit.Report.Input.Visualization.Diagrams: contramap :: Contravariant f => (a -> b) -> f b -> f a
+ Knit.Report.Input.Visualization.Diagrams: contramapped :: Contravariant f => Setter (f b) (f a) a b
+ Knit.Report.Input.Visualization.Diagrams: contramapping :: Contravariant f => AnIso s t a b -> Iso (f a) (f b) (f s) (f t)
+ Knit.Report.Input.Visualization.Diagrams: coords :: Coordinates c => c -> Decomposition c
+ Knit.Report.Input.Visualization.Diagrams: coral :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: cornflowerblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: cornsilk :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: cosA :: Floating n => Angle n -> n
+ Knit.Report.Input.Visualization.Diagrams: cosmos :: Plated a => Fold a a
+ Knit.Report.Input.Visualization.Diagrams: cosmosOf :: (Applicative f, Contravariant f) => LensLike' f a a -> LensLike' f a a
+ Knit.Report.Input.Visualization.Diagrams: cosmosOn :: (Applicative f, Contravariant f, Plated a) => LensLike' f s a -> LensLike' f s a
+ Knit.Report.Input.Visualization.Diagrams: cosmosOnOf :: (Applicative f, Contravariant f) => LensLike' f s a -> LensLike' f a a -> LensLike' f s a
+ Knit.Report.Input.Visualization.Diagrams: createClass :: Lens' LensRules Bool
+ Knit.Report.Input.Visualization.Diagrams: crimson :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: cube :: Num n => Box n
+ Knit.Report.Input.Visualization.Diagrams: cubicSpline :: (V t ~ v, N t ~ n, TrailLike t, Fractional (v n)) => Bool -> [Point v n] -> t
+ Knit.Report.Input.Visualization.Diagrams: curried :: () => Iso ((a, b) -> c) ((d, e) -> f) (a -> b -> c) (d -> e -> f)
+ Knit.Report.Input.Visualization.Diagrams: cutLoop :: (Metric v, OrderedField n) => Trail' Loop v n -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: cutTrail :: (Metric v, OrderedField n) => Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: cyan :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: cycle1 :: Semigroup m => m -> m
+ Knit.Report.Input.Visualization.Diagrams: cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
+ Knit.Report.Input.Visualization.Diagrams: cylinder :: Num n => Frustum n
+ Knit.Report.Input.Visualization.Diagrams: darkblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkcyan :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darken :: (ColourOps f, Num a) => a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: darkgoldenrod :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkgray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkgrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkkhaki :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkmagenta :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkolivegreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkorange :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkorchid :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkred :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darksalmon :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkseagreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkslateblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkslategray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkslategrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkturquoise :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: darkviolet :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: dart :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: dart' :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: dashing :: (N a ~ n, HasStyle a, Typeable n) => [Measure n] -> Measure n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: dashingG :: (N a ~ n, HasStyle a, Typeable n, Num n) => [n] -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: dashingL :: (N a ~ n, HasStyle a, Typeable n, Num n) => [n] -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: dashingN :: (N a ~ n, HasStyle a, Typeable n, Num n) => [n] -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: dashingO :: (N a ~ n, HasStyle a, Typeable n) => [n] -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: data (:&) a b
+ Knit.Report.Input.Visualization.Diagrams: data AName
+ Knit.Report.Input.Visualization.Diagrams: data Active a
+ Knit.Report.Input.Visualization.Diagrams: data AdjustMethod n
+ Knit.Report.Input.Visualization.Diagrams: data AdjustOpts n
+ Knit.Report.Input.Visualization.Diagrams: data AdjustSide
+ Knit.Report.Input.Visualization.Diagrams: data AlphaColour a
+ Knit.Report.Input.Visualization.Diagrams: data Angle n
+ Knit.Report.Input.Visualization.Diagrams: data Arg a b
+ Knit.Report.Input.Visualization.Diagrams: data ArrowOpts n
+ Knit.Report.Input.Visualization.Diagrams: data Attribute (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data BoundingBox (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Box n
+ Knit.Report.Input.Visualization.Diagrams: data CSG n
+ Knit.Report.Input.Visualization.Diagrams: data Camera (l :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data CatMethod
+ Knit.Report.Input.Visualization.Diagrams: data CatOpts n
+ Knit.Report.Input.Visualization.Diagrams: data Closed
+ Knit.Report.Input.Visualization.Diagrams: data Colour a
+ Knit.Report.Input.Visualization.Diagrams: data Context a b t
+ Knit.Report.Input.Visualization.Diagrams: data DImage a b
+ Knit.Report.Input.Visualization.Diagrams: data Dashing n
+ Knit.Report.Input.Visualization.Diagrams: data DefName
+ Knit.Report.Input.Visualization.Diagrams: data Direction (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Duration n
+ Knit.Report.Input.Visualization.Diagrams: data Dynamic a
+ Knit.Report.Input.Visualization.Diagrams: data Ellipsoid n
+ Knit.Report.Input.Visualization.Diagrams: data Embedded
+ Knit.Report.Input.Visualization.Diagrams: data EnvelopeOpts n
+ Knit.Report.Input.Visualization.Diagrams: data Era n
+ Knit.Report.Input.Visualization.Diagrams: data External
+ Knit.Report.Input.Visualization.Diagrams: data FillOpacity
+ Knit.Report.Input.Visualization.Diagrams: data FillRule
+ Knit.Report.Input.Visualization.Diagrams: data FixedSegment (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Frustum n
+ Knit.Report.Input.Visualization.Diagrams: data GradientStop d
+ Knit.Report.Input.Visualization.Diagrams: data ImageData a
+ Knit.Report.Input.Visualization.Diagrams: data LGradient n
+ Knit.Report.Input.Visualization.Diagrams: data Leftmost a
+ Knit.Report.Input.Visualization.Diagrams: data LensRules
+ Knit.Report.Input.Visualization.Diagrams: data Level i a
+ Knit.Report.Input.Visualization.Diagrams: data Line
+ Knit.Report.Input.Visualization.Diagrams: data LineCap
+ Knit.Report.Input.Visualization.Diagrams: data LineJoin
+ Knit.Report.Input.Visualization.Diagrams: data LineWidth n
+ Knit.Report.Input.Visualization.Diagrams: data Located a
+ Knit.Report.Input.Visualization.Diagrams: data Loop
+ Knit.Report.Input.Visualization.Diagrams: data Magma i t b a
+ Knit.Report.Input.Visualization.Diagrams: data Measured n a
+ Knit.Report.Input.Visualization.Diagrams: data Name
+ Knit.Report.Input.Visualization.Diagrams: data Native t
+ Knit.Report.Input.Visualization.Diagrams: data NullBackend
+ Knit.Report.Input.Visualization.Diagrams: data Offset c (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data OffsetEnvelope (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Opacity
+ Knit.Report.Input.Visualization.Diagrams: data Open
+ Knit.Report.Input.Visualization.Diagrams: data OriginOpts n
+ Knit.Report.Input.Visualization.Diagrams: data OrthoLens n
+ Knit.Report.Input.Visualization.Diagrams: data ParallelLight n
+ Knit.Report.Input.Visualization.Diagrams: data PerspectiveLens n
+ Knit.Report.Input.Visualization.Diagrams: data PointLight n
+ Knit.Report.Input.Visualization.Diagrams: data PolyOrientation n
+ Knit.Report.Input.Visualization.Diagrams: data PolyType n
+ Knit.Report.Input.Visualization.Diagrams: data PolygonOpts n
+ Knit.Report.Input.Visualization.Diagrams: data Prim b (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data QDiagram b (v :: Type -> Type) n m
+ Knit.Report.Input.Visualization.Diagrams: data RGB a
+ Knit.Report.Input.Visualization.Diagrams: data RGradient n
+ Knit.Report.Input.Visualization.Diagrams: data Rightmost a
+ Knit.Report.Input.Visualization.Diagrams: data RoundedRectOpts d
+ Knit.Report.Input.Visualization.Diagrams: data Segment c (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Sequenced a (m :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: data SizeSpec (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data SomeColor
+ Knit.Report.Input.Visualization.Diagrams: data SortedList a
+ Knit.Report.Input.Visualization.Diagrams: data Specular
+ Knit.Report.Input.Visualization.Diagrams: data SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: data StarOpts
+ Knit.Report.Input.Visualization.Diagrams: data StrokeOpacity
+ Knit.Report.Input.Visualization.Diagrams: data StrokeOpts a
+ Knit.Report.Input.Visualization.Diagrams: data Style (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Subdiagram b (v :: Type -> Type) n m
+ Knit.Report.Input.Visualization.Diagrams: data Texture n
+ Knit.Report.Input.Visualization.Diagrams: data Time n
+ Knit.Report.Input.Visualization.Diagrams: data TraceOpts n
+ Knit.Report.Input.Visualization.Diagrams: data Trail (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Trail' l (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Transformation (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: data Traversed a (f :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: data V2 a
+ Knit.Report.Input.Visualization.Diagrams: data V3 a
+ Knit.Report.Input.Visualization.Diagrams: data family Vector a :: Type
+ Knit.Report.Input.Visualization.Diagrams: data Identical (a :: k) (b :: k1) (s :: k) (t :: k1) :: forall k k1. () => k -> k1 -> k -> k1 -> Type
+ Knit.Report.Input.Visualization.Diagrams: decagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: declareClassy :: DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareClassyFor :: [(String, (String, String))] -> [(String, String)] -> DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareFields :: DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareLenses :: DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareLensesFor :: [(String, String)] -> DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareLensesWith :: LensRules -> DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declarePrisms :: DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: declareWrapped :: DecsQ -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: deep :: (Conjoined p, Applicative f, Plated s) => Traversing p f s s a b -> Over p f s s a b
+ Knit.Report.Input.Visualization.Diagrams: deepOf :: (Conjoined p, Applicative f) => LensLike f s t s t -> Traversing p f s t a b -> Over p f s t a b
+ Knit.Report.Input.Visualization.Diagrams: deeppink :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: deepskyblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: def :: Default a => a
+ Knit.Report.Input.Visualization.Diagrams: defaultBoundary :: (Alignable a, V a ~ v, N a ~ n) => v n -> a -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: defaultFieldRules :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: defaultLG :: Fractional n => Texture n
+ Knit.Report.Input.Visualization.Diagrams: defaultRG :: Fractional n => Texture n
+ Knit.Report.Input.Visualization.Diagrams: deform :: Deformable a b => Deformation (V a) (V b) (N a) -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: deform' :: Deformable a b => N a -> Deformation (V a) (V b) (N a) -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: deg :: Floating n => Iso' (Angle n) n
+ Knit.Report.Input.Visualization.Diagrams: determinant :: (Additive v, Traversable v, Num n) => Transformation v n -> n
+ Knit.Report.Input.Visualization.Diagrams: devoid :: () => Over p f Void Void a b
+ Knit.Report.Input.Visualization.Diagrams: diameter :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n
+ Knit.Report.Input.Visualization.Diagrams: diff :: Semigroup m => m -> Endo m
+ Knit.Report.Input.Visualization.Diagrams: difference :: (CsgPrim a, CsgPrim b) => a n -> b n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: diffuse :: HasStyle d => Double -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: dimap :: Profunctor p => (a -> b) -> (c -> d) -> p b c -> p a d
+ Knit.Report.Input.Visualization.Diagrams: dimapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> AnIso s' t' a' b' -> Iso (p a s') (q b t') (p s a') (q t b')
+ Knit.Report.Input.Visualization.Diagrams: dimension :: (Additive (V a), Traversable (V a)) => a -> Int
+ Knit.Report.Input.Visualization.Diagrams: dimgray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: dimgrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: dims :: () => v n -> SizeSpec v n
+ Knit.Report.Input.Visualization.Diagrams: dims2D :: () => n -> n -> SizeSpec V2 n
+ Knit.Report.Input.Visualization.Diagrams: dirBetween :: (Additive v, Num n) => Point v n -> Point v n -> Direction v n
+ Knit.Report.Input.Visualization.Diagrams: direction :: () => v n -> Direction v n
+ Knit.Report.Input.Visualization.Diagrams: discrete :: () => [a] -> Active a
+ Knit.Report.Input.Visualization.Diagrams: dissolve :: Num a => a -> AlphaColour a -> AlphaColour a
+ Knit.Report.Input.Visualization.Diagrams: distance :: (Metric f, Floating a) => f a -> f a -> a
+ Knit.Report.Input.Visualization.Diagrams: distanceA :: (Floating a, Foldable (Diff p), Affine p) => p a -> p a -> a
+ Knit.Report.Input.Visualization.Diagrams: distrib :: (Conjoined p, Functor f) => p a b -> p (f a) (f b)
+ Knit.Report.Input.Visualization.Diagrams: dodecagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: dodgerblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: domainBounds :: DomainBounds p => p -> (N p, N p)
+ Knit.Report.Input.Visualization.Diagrams: domainLower :: DomainBounds p => p -> N p
+ Knit.Report.Input.Visualization.Diagrams: domainUpper :: DomainBounds p => p -> N p
+ Knit.Report.Input.Visualization.Diagrams: dot :: (Metric f, Num a) => f a -> f a -> a
+ Knit.Report.Input.Visualization.Diagrams: dropTransl :: (Additive v, Num n) => Transformation v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
+ Knit.Report.Input.Visualization.Diagrams: droppingWhile :: (Conjoined p, Profunctor q, Applicative f) => (a -> Bool) -> Optical p q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
+ Knit.Report.Input.Visualization.Diagrams: duration :: Num n => Era n -> Duration n
+ Knit.Report.Input.Visualization.Diagrams: during :: () => Active a -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: eColor :: () => Lens' (EnvelopeOpts n) (Colour Double)
+ Knit.Report.Input.Visualization.Diagrams: eLineWidth :: () => Lens (EnvelopeOpts n1) (EnvelopeOpts n2) (Measure n1) (Measure n2)
+ Knit.Report.Input.Visualization.Diagrams: ePoints :: () => Lens' (EnvelopeOpts n) Int
+ Knit.Report.Input.Visualization.Diagrams: each :: Each s t a b => Traversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: eachName :: (Typeable a, Ord a, Show a) => Traversal' Name a
+ Knit.Report.Input.Visualization.Diagrams: elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
+ Knit.Report.Input.Visualization.Diagrams: elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
+ Knit.Report.Input.Visualization.Diagrams: elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: element :: Traversable t => Int -> IndexedTraversal' Int (t a) a
+ Knit.Report.Input.Visualization.Diagrams: elementOf :: Applicative f => LensLike (Indexing f) s t a a -> Int -> IndexedLensLike Int f s t a a
+ Knit.Report.Input.Visualization.Diagrams: elements :: Traversable t => (Int -> Bool) -> IndexedTraversal' Int (t a) a
+ Knit.Report.Input.Visualization.Diagrams: elementsOf :: Applicative f => LensLike (Indexing f) s t a a -> (Int -> Bool) -> IndexedLensLike Int f s t a a
+ Knit.Report.Input.Visualization.Diagrams: ellipse :: (TrailLike t, V t ~ V2, N t ~ n, Transformable t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: ellipseXY :: (TrailLike t, V t ~ V2, N t ~ n, Transformable t) => n -> n -> t
+ Knit.Report.Input.Visualization.Diagrams: emptyBox :: () => BoundingBox v n
+ Knit.Report.Input.Visualization.Diagrams: emptyLine :: (Metric v, OrderedField n) => Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: emptyTrail :: (Metric v, OrderedField n) => Trail v n
+ Knit.Report.Input.Visualization.Diagrams: end :: () => Era n -> Time n
+ Knit.Report.Input.Visualization.Diagrams: enum :: Enum a => Iso' Int a
+ Knit.Report.Input.Visualization.Diagrams: envelope :: (OrderedField n, Metric v, Monoid' m) => Lens' (QDiagram b v n m) (Envelope v n)
+ Knit.Report.Input.Visualization.Diagrams: envelopeBoundary :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: envelopeP :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: envelopePMay :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> Maybe (Point v n)
+ Knit.Report.Input.Visualization.Diagrams: envelopeV :: Enveloped a => Vn a -> a -> Vn a
+ Knit.Report.Input.Visualization.Diagrams: envelopeVMay :: Enveloped a => Vn a -> a -> Maybe (Vn a)
+ Knit.Report.Input.Visualization.Diagrams: eqTriangle :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: explodePath :: (V t ~ v, N t ~ n, TrailLike t) => Path v n -> [[t]]
+ Knit.Report.Input.Visualization.Diagrams: explodeTrail :: (V t ~ v, N t ~ n, TrailLike t) => Located (Trail v n) -> [t]
+ Knit.Report.Input.Visualization.Diagrams: extentX :: (InSpace v n a, R1 v, Enveloped a) => a -> Maybe (n, n)
+ Knit.Report.Input.Visualization.Diagrams: extentY :: (InSpace v n a, R2 v, Enveloped a) => a -> Maybe (n, n)
+ Knit.Report.Input.Visualization.Diagrams: extrudeBottom :: (OrderedField n, Monoid' m) => n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: extrudeEnvelope :: (Metric v, OrderedField n, Monoid' m) => v n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: extrudeLeft :: (OrderedField n, Monoid' m) => n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: extrudeRight :: (OrderedField n, Monoid' m) => n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: extrudeTop :: (OrderedField n, Monoid' m) => n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: eye :: (HasBasis v, Num n) => v (v n)
+ Knit.Report.Input.Visualization.Diagrams: facingX :: (R1 v, Functor v, Fractional n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: facingY :: (R2 v, Functor v, Fractional n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: facingZ :: (R3 v, Functor v, Fractional n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: facing_ZCamera :: (Floating n, Ord n, Typeable n, CameraLens l, Renderable (Camera l n) b) => l n -> QDiagram b V3 n Any
+ Knit.Report.Input.Visualization.Diagrams: failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
+ Knit.Report.Input.Visualization.Diagrams: failover :: Alternative m => LensLike ((,) Any) s t a b -> (a -> b) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: fc :: (InSpace V2 n a, Floating n, Typeable n, HasStyle a) => Colour Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fcA :: (InSpace V2 n a, Floating n, Typeable n, HasStyle a) => AlphaColour Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fillColor :: (InSpace V2 n a, Color c, Typeable n, Floating n, HasStyle a) => c -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fillOpacity :: HasStyle a => Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fillRule :: HasStyle a => FillRule -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fillTexture :: (InSpace V2 n a, Typeable n, Floating n, HasStyle a) => Texture n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
+ Knit.Report.Input.Visualization.Diagrams: findHsFile :: FilePath -> IO (Maybe FilePath)
+ Knit.Report.Input.Visualization.Diagrams: findIndexOf :: () => IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
+ Knit.Report.Input.Visualization.Diagrams: findIndicesOf :: () => IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
+ Knit.Report.Input.Visualization.Diagrams: findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: findOf :: () => Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: findSandbox :: [FilePath] -> IO (Maybe FilePath)
+ Knit.Report.Input.Visualization.Diagrams: firebrick :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: first1Of :: () => Getting (First a) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: firstOf :: () => Getting (Leftmost a) s a -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: firsting :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f s x) (g t y) (f a x) (g b y)
+ Knit.Report.Input.Visualization.Diagrams: fixPath :: (Metric v, OrderedField n) => Path v n -> [[FixedSegment v n]]
+ Knit.Report.Input.Visualization.Diagrams: fixTrail :: (Metric v, OrderedField n) => Located (Trail v n) -> [FixedSegment v n]
+ Knit.Report.Input.Visualization.Diagrams: fixedSegIso :: (Num n, Additive v) => Iso' (FixedSegment v n) (Located (Segment Closed v n))
+ Knit.Report.Input.Visualization.Diagrams: flipped :: () => Iso (a -> b -> c) (a' -> b' -> c') (b -> a -> c) (b' -> a' -> c')
+ Knit.Report.Input.Visualization.Diagrams: floralwhite :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: foldB :: () => (a -> a -> a) -> a -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
+ Knit.Report.Input.Visualization.Diagrams: foldByOf :: () => Fold s a -> (a -> a -> a) -> a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
+ Knit.Report.Input.Visualization.Diagrams: foldMapByOf :: () => Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldMapOf :: () => Getting r s a -> (a -> r) -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldOf :: () => Getting a s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: folded :: Foldable f => IndexedFold Int (f a) a
+ Knit.Report.Input.Visualization.Diagrams: folded64 :: Foldable f => IndexedFold Int64 (f a) a
+ Knit.Report.Input.Visualization.Diagrams: folding :: Foldable f => (s -> f a) -> Fold s a
+ Knit.Report.Input.Visualization.Diagrams: foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: foldlMOf :: Monad m => Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
+ Knit.Report.Input.Visualization.Diagrams: foldlOf :: () => Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldlOf' :: () => Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: foldrMOf :: Monad m => Getting (Dual (Endo (r -> m r))) s a -> (a -> r -> m r) -> r -> s -> m r
+ Knit.Report.Input.Visualization.Diagrams: foldrOf :: () => Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldrOf' :: () => Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
+ Knit.Report.Input.Visualization.Diagrams: font :: HasStyle a => String -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fontSize :: (N a ~ n, Typeable n, HasStyle a) => Measure n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fontSizeG :: (N a ~ n, Typeable n, Num n, HasStyle a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fontSizeL :: (N a ~ n, Typeable n, Num n, HasStyle a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fontSizeN :: (N a ~ n, Typeable n, Num n, HasStyle a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: fontSizeO :: (N a ~ n, Typeable n, HasStyle a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
+ Knit.Report.Input.Visualization.Diagrams: forMOf :: () => LensLike (WrappedMonad m) s t a b -> s -> (a -> m b) -> m t
+ Knit.Report.Input.Visualization.Diagrams: forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: forOf :: () => LensLike f s t a b -> s -> (a -> f b) -> f t
+ Knit.Report.Input.Visualization.Diagrams: forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
+ Knit.Report.Input.Visualization.Diagrams: forestgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: frame :: (Metric v, OrderedField n, Monoid' m) => n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: from :: () => AnIso s t a b -> Iso b a t s
+ Knit.Report.Input.Visualization.Diagrams: fromAlphaColour :: Color c => AlphaColour Double -> c
+ Knit.Report.Input.Visualization.Diagrams: fromCorners :: (Additive v, Foldable v, Ord n) => Point v n -> Point v n -> BoundingBox v n
+ Knit.Report.Input.Visualization.Diagrams: fromDir :: (Metric v, Floating n) => Direction v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: fromDirection :: (Metric v, Floating n) => Direction v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: fromDuration :: () => Duration n -> n
+ Knit.Report.Input.Visualization.Diagrams: fromDynamic :: () => Dynamic a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: fromEq :: () => AnEquality s t a b -> Equality b a t s
+ Knit.Report.Input.Visualization.Diagrams: fromFixedSeg :: (Num n, Additive v) => FixedSegment v n -> Located (Segment Closed v n)
+ Knit.Report.Input.Visualization.Diagrams: fromLinear :: (Additive v, Num n) => (v n :-: v n) -> (v n :-: v n) -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: fromLocOffsets :: (V t ~ v, N t ~ n, V (v n) ~ v, N (v n) ~ n, TrailLike t) => Located [v n] -> t
+ Knit.Report.Input.Visualization.Diagrams: fromLocSegments :: TrailLike t => Located [Segment Closed (V t) (N t)] -> t
+ Knit.Report.Input.Visualization.Diagrams: fromMeasured :: Num n => n -> n -> Measured n a -> a
+ Knit.Report.Input.Visualization.Diagrams: fromNames :: IsName a => [(a, Subdiagram b v n m)] -> SubMap b v n m
+ Knit.Report.Input.Visualization.Diagrams: fromOffsets :: TrailLike t => [Vn t] -> t
+ Knit.Report.Input.Visualization.Diagrams: fromPoint :: () => Point v n -> BoundingBox v n
+ Knit.Report.Input.Visualization.Diagrams: fromPoints :: (Additive v, Ord n) => [Point v n] -> BoundingBox v n
+ Knit.Report.Input.Visualization.Diagrams: fromSegments :: TrailLike t => [Segment Closed (V t) (N t)] -> t
+ Knit.Report.Input.Visualization.Diagrams: fromTime :: () => Time n -> n
+ Knit.Report.Input.Visualization.Diagrams: fromVertices :: TrailLike t => [Point (V t) (N t)] -> t
+ Knit.Report.Input.Visualization.Diagrams: frustum :: Num n => n -> n -> Frustum n
+ Knit.Report.Input.Visualization.Diagrams: fuchsia :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: fullTurn :: Floating v => Angle v
+ Knit.Report.Input.Visualization.Diagrams: fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
+ Knit.Report.Input.Visualization.Diagrams: gainsboro :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: gap :: () => Traversal' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: gaps :: () => Traversal' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: generateLazyPatterns :: Lens' LensRules Bool
+ Knit.Report.Input.Visualization.Diagrams: generateSignatures :: Lens' LensRules Bool
+ Knit.Report.Input.Visualization.Diagrams: generateUpdateableOptics :: Lens' LensRules Bool
+ Knit.Report.Input.Visualization.Diagrams: getAllCorners :: (Additive v, Traversable v) => BoundingBox v n -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: getArcLengthBounded :: (Num n, Ord n) => n -> ArcLength n -> Interval n
+ Knit.Report.Input.Visualization.Diagrams: getArcLengthCached :: () => ArcLength n -> Interval n
+ Knit.Report.Input.Visualization.Diagrams: getArcLengthFun :: () => ArcLength n -> n -> Interval n
+ Knit.Report.Input.Visualization.Diagrams: getAttr :: AttributeClass a => Style v n -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: getCorners :: () => BoundingBox v n -> Maybe (Point v n, Point v n)
+ Knit.Report.Input.Visualization.Diagrams: getDashing :: () => Dashing n -> Dashing n
+ Knit.Report.Input.Visualization.Diagrams: getEnvelope :: Enveloped a => a -> Envelope (V a) (N a)
+ Knit.Report.Input.Visualization.Diagrams: getFillOpacity :: FillOpacity -> Double
+ Knit.Report.Input.Visualization.Diagrams: getFillTexture :: () => FillTexture n -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: getLineCap :: LineCap -> LineCap
+ Knit.Report.Input.Visualization.Diagrams: getLineJoin :: LineJoin -> LineJoin
+ Knit.Report.Input.Visualization.Diagrams: getLineMiterLimit :: LineMiterLimit -> Double
+ Knit.Report.Input.Visualization.Diagrams: getLineTexture :: () => LineTexture n -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: getLineWidth :: () => LineWidth n -> n
+ Knit.Report.Input.Visualization.Diagrams: getOpacity :: Opacity -> Double
+ Knit.Report.Input.Visualization.Diagrams: getQuery :: HasQuery t m => t -> Query (V t) (N t) m
+ Knit.Report.Input.Visualization.Diagrams: getSegment :: () => t -> GetSegment t
+ Knit.Report.Input.Visualization.Diagrams: getSortedList :: () => SortedList a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: getSpec :: (Functor v, Num n, Ord n) => SizeSpec v n -> v (Maybe n)
+ Knit.Report.Input.Visualization.Diagrams: getStrokeOpacity :: StrokeOpacity -> Double
+ Knit.Report.Input.Visualization.Diagrams: getSub :: (Metric v, OrderedField n, Semigroup m) => Subdiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: getTrace :: Traced a => a -> Trace (V a) (N a)
+ Knit.Report.Input.Visualization.Diagrams: getting :: (Profunctor p, Profunctor q, Functor f, Contravariant f) => Optical p q f s t a b -> Optical' p q f s a
+ Knit.Report.Input.Visualization.Diagrams: ghostwhite :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: global :: Num n => n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: globalPackage :: IO FilePath
+ Knit.Report.Input.Visualization.Diagrams: glueLine :: (Metric v, OrderedField n) => Trail' Line v n -> Trail' Loop v n
+ Knit.Report.Input.Visualization.Diagrams: glueTrail :: (Metric v, OrderedField n) => Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: gold :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: goldenrod :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
+ Knit.Report.Input.Visualization.Diagrams: gplate1 :: (Generic1 f, GPlated1 f (Rep1 f)) => Traversal' (f a) (f a)
+ Knit.Report.Input.Visualization.Diagrams: gray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: green :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: greenyellow :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: grey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: groupOpacity :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: halfDart :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: halfDart' :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: halfTurn :: Floating v => Angle v
+ Knit.Report.Input.Visualization.Diagrams: has :: () => Getting Any s a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: hasn't :: () => Getting All s a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: hcat :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: hcat' :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => CatOpts n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: headGap :: () => Lens' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: headLength :: () => Lens' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: headStyle :: () => Lens' (ArrowOpts n) (Style V2 n)
+ Knit.Report.Input.Visualization.Diagrams: headTexture :: TypeableFloat n => Lens' (ArrowOpts n) (Texture n)
+ Knit.Report.Input.Visualization.Diagrams: heavy :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: height :: (InSpace V2 n a, Enveloped a) => a -> n
+ Knit.Report.Input.Visualization.Diagrams: hendecagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: heptagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: hexagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: highlight :: HasStyle d => Specular -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: highlightIntensity :: () => Traversal' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: highlightSize :: () => Traversal' (Style v n) Double
+ Knit.Report.Input.Visualization.Diagrams: holes :: Plated a => a -> [Pretext ((->) :: Type -> Type -> Type) a a a]
+ Knit.Report.Input.Visualization.Diagrams: holes1Of :: Conjoined p => Over p (Bazaar1 p a a) s t a a -> s -> NonEmpty (Pretext p a a t)
+ Knit.Report.Input.Visualization.Diagrams: holesOf :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
+ Knit.Report.Input.Visualization.Diagrams: holesOn :: Conjoined p => Over p (Bazaar p a a) s t a a -> s -> [Pretext p a a t]
+ Knit.Report.Input.Visualization.Diagrams: holesOnOf :: Conjoined p => LensLike (Bazaar p r r) s t a b -> Over p (Bazaar p r r) a b r r -> s -> [Pretext p r r t]
+ Knit.Report.Input.Visualization.Diagrams: honeydew :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: horizontalFieldOfView :: () => Lens' (PerspectiveLens n) (Angle n)
+ Knit.Report.Input.Visualization.Diagrams: hotpink :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: href :: (Metric v, OrderedField n, Semigroup m) => String -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: hrule :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: hsep :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: huge :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Knit.Report.Input.Visualization.Diagrams: iallOf :: () => IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Knit.Report.Input.Visualization.Diagrams: ianyOf :: () => IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: iat :: At m => Index m -> IndexedLens' (Index m) m (Maybe (IxValue m))
+ Knit.Report.Input.Visualization.Diagrams: icensoring :: MonadWriter w m => IndexedSetter i w w u v -> (i -> u -> v) -> m a -> m a
+ Knit.Report.Input.Visualization.Diagrams: icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r
+ Knit.Report.Input.Visualization.Diagrams: iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]
+ Knit.Report.Input.Visualization.Diagrams: iconcatMapOf :: () => IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
+ Knit.Report.Input.Visualization.Diagrams: icontains :: Contains m => Index m -> IndexedLens' (Index m) m Bool
+ Knit.Report.Input.Visualization.Diagrams: idroppingWhile :: (Indexable i p, Profunctor q, Applicative f) => (i -> a -> Bool) -> Optical (Indexed i) q (Compose (State Bool) f) s t a a -> Optical p q f s t a a
+ Knit.Report.Input.Visualization.Diagrams: ifailover :: Alternative m => Over (Indexed i) ((,) Any) s t a b -> (i -> a -> b) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
+ Knit.Report.Input.Visualization.Diagrams: ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)
+ Knit.Report.Input.Visualization.Diagrams: ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: ifindOf :: () => IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: ifoldMap :: (FoldableWithIndex i f, Monoid m) => (i -> a -> m) -> f a -> m
+ Knit.Report.Input.Visualization.Diagrams: ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldMapByOf :: () => IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldMapOf :: () => IndexedGetting i m s a -> (i -> a -> m) -> s -> m
+ Knit.Report.Input.Visualization.Diagrams: ifolded :: FoldableWithIndex i f => IndexedFold i (f a) a
+ Knit.Report.Input.Visualization.Diagrams: ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
+ Knit.Report.Input.Visualization.Diagrams: ifoldl :: FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b
+ Knit.Report.Input.Visualization.Diagrams: ifoldl' :: FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b
+ Knit.Report.Input.Visualization.Diagrams: ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b
+ Knit.Report.Input.Visualization.Diagrams: ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
+ Knit.Report.Input.Visualization.Diagrams: ifoldlOf :: () => IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldlOf' :: () => IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldr :: FoldableWithIndex i f => (i -> a -> b -> b) -> b -> f a -> b
+ Knit.Report.Input.Visualization.Diagrams: ifoldr' :: FoldableWithIndex i f => (i -> a -> b -> b) -> b -> f a -> b
+ Knit.Report.Input.Visualization.Diagrams: ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b
+ Knit.Report.Input.Visualization.Diagrams: ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
+ Knit.Report.Input.Visualization.Diagrams: ifoldrOf :: () => IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldrOf' :: () => IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
+ Knit.Report.Input.Visualization.Diagrams: ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
+ Knit.Report.Input.Visualization.Diagrams: ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)
+ Knit.Report.Input.Visualization.Diagrams: iforMOf :: () => (Indexed i a (WrappedMonad m b) -> s -> WrappedMonad m t) -> s -> (i -> a -> m b) -> m t
+ Knit.Report.Input.Visualization.Diagrams: iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: iforM_ :: (FoldableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: iforOf :: () => (Indexed i a (f b) -> s -> f t) -> s -> (i -> a -> f b) -> f t
+ Knit.Report.Input.Visualization.Diagrams: iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
+ Knit.Report.Input.Visualization.Diagrams: ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()
+ Knit.Report.Input.Visualization.Diagrams: ignored :: Applicative f => pafb -> s -> f s
+ Knit.Report.Input.Visualization.Diagrams: iix :: Ixed m => Index m -> IndexedTraversal' (Index m) m (IxValue m)
+ Knit.Report.Input.Visualization.Diagrams: ilens :: () => (s -> (i, a)) -> (s -> b -> t) -> IndexedLens i s t a b
+ Knit.Report.Input.Visualization.Diagrams: ilevels :: Applicative f => Traversing (Indexed i) f s t a b -> IndexedLensLike Int f s t (Level i a) (Level j b)
+ Knit.Report.Input.Visualization.Diagrams: ilike :: (Indexable i p, Contravariant f, Functor f) => i -> a -> Over' p f s a
+ Knit.Report.Input.Visualization.Diagrams: ilistening :: MonadWriter w m => IndexedGetting i (i, u) w u -> m a -> m (a, (i, u))
+ Knit.Report.Input.Visualization.Diagrams: ilistenings :: MonadWriter w m => IndexedGetting i v w u -> (i -> u -> v) -> m a -> m (a, v)
+ Knit.Report.Input.Visualization.Diagrams: ilocally :: MonadReader s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m r -> m r
+ Knit.Report.Input.Visualization.Diagrams: iloci :: () => IndexedTraversal i (Bazaar (Indexed i) a c s) (Bazaar (Indexed i) b c s) a b
+ Knit.Report.Input.Visualization.Diagrams: image :: (TypeableFloat n, Typeable a, Renderable (DImage n a) b) => DImage n a -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: imagma :: () => Over (Indexed i) (Molten i a b) s t a b -> Iso s t' (Magma i t b a) (Magma j t' c c)
+ Knit.Report.Input.Visualization.Diagrams: imap :: FunctorWithIndex i f => (i -> a -> b) -> f a -> f b
+ Knit.Report.Input.Visualization.Diagrams: imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Knit.Report.Input.Visualization.Diagrams: imapAccumLOf :: () => Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Knit.Report.Input.Visualization.Diagrams: imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)
+ Knit.Report.Input.Visualization.Diagrams: imapAccumROf :: () => Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Knit.Report.Input.Visualization.Diagrams: imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)
+ Knit.Report.Input.Visualization.Diagrams: imapMOf :: () => Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
+ Knit.Report.Input.Visualization.Diagrams: imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()
+ Knit.Report.Input.Visualization.Diagrams: imapOf :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: imapped :: FunctorWithIndex i f => IndexedSetter i (f a) (f b) a b
+ Knit.Report.Input.Visualization.Diagrams: imodifying :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a
+ Knit.Report.Input.Visualization.Diagrams: indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: indianred :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: indigo :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: infix 4 <#=
+ Knit.Report.Input.Visualization.Diagrams: infix 5 `at`
+ Knit.Report.Input.Visualization.Diagrams: infixl 1 ??
+ Knit.Report.Input.Visualization.Diagrams: infixl 4 >$
+ Knit.Report.Input.Visualization.Diagrams: infixl 5 `snoc`
+ Knit.Report.Input.Visualization.Diagrams: infixl 6 `beneath`
+ Knit.Report.Input.Visualization.Diagrams: infixl 7 :&
+ Knit.Report.Input.Visualization.Diagrams: infixl 8 ^@?!
+ Knit.Report.Input.Visualization.Diagrams: infixr 2 `zoom`
+ Knit.Report.Input.Visualization.Diagrams: infixr 4 <#~
+ Knit.Report.Input.Visualization.Diagrams: infixr 5 `cons`
+ Knit.Report.Input.Visualization.Diagrams: infixr 6 <>
+ Knit.Report.Input.Visualization.Diagrams: infixr 7 :-:
+ Knit.Report.Input.Visualization.Diagrams: infixr 8 ##
+ Knit.Report.Input.Visualization.Diagrams: infixr 9 <.
+ Knit.Report.Input.Visualization.Diagrams: inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool
+ Knit.Report.Input.Visualization.Diagrams: inoneOf :: () => IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: inquire :: HasQuery t Any => t -> Point (V t) (N t) -> Bool
+ Knit.Report.Input.Visualization.Diagrams: inside' :: (Additive v, Foldable v, Ord n) => BoundingBox v n -> BoundingBox v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: intersectPoints :: (InSpace V2 n t, SameSpace t s, ToPath t, ToPath s, OrderedField n) => t -> s -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersectPoints' :: (InSpace V2 n t, SameSpace t s, ToPath t, ToPath s, OrderedField n) => n -> t -> s -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersectPointsP :: OrderedField n => Path V2 n -> Path V2 n -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersectPointsP' :: OrderedField n => n -> Path V2 n -> Path V2 n -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersectPointsT :: OrderedField n => Located (Trail V2 n) -> Located (Trail V2 n) -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersectPointsT' :: OrderedField n => n -> Located (Trail V2 n) -> Located (Trail V2 n) -> [P2 n]
+ Knit.Report.Input.Visualization.Diagrams: intersection :: (CsgPrim a, CsgPrim b) => a n -> b n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: interval :: Fractional a => Time Rational -> Time Rational -> Active a
+ Knit.Report.Input.Visualization.Diagrams: intrudeEnvelope :: (Metric v, OrderedField n, Monoid' m) => v n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: inv :: (Functor v, Num n) => Transformation v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: involuted :: () => (a -> a) -> Iso' a a
+ Knit.Report.Input.Visualization.Diagrams: iover :: () => AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: ipartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a a -> Over p f s t [a] [a]
+ Knit.Report.Input.Visualization.Diagrams: ipartsOf' :: (Indexable [i] p, Functor f) => Over (Indexed i) (Bazaar' (Indexed i) a) s t a a -> Over p f s t [a] [a]
+ Knit.Report.Input.Visualization.Diagrams: ipassing :: MonadWriter w m => IndexedSetter i w w u v -> m (a, i -> u -> v) -> m a
+ Knit.Report.Input.Visualization.Diagrams: iplens :: () => (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
+ Knit.Report.Input.Visualization.Diagrams: ipre :: () => IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
+ Knit.Report.Input.Visualization.Diagrams: ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
+ Knit.Report.Input.Visualization.Diagrams: ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
+ Knit.Report.Input.Visualization.Diagrams: ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
+ Knit.Report.Input.Visualization.Diagrams: ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
+ Knit.Report.Input.Visualization.Diagrams: isCommitted :: () => Lens' (Recommend a) Bool
+ Knit.Report.Input.Visualization.Diagrams: isConstant :: () => Active a -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isDynamic :: () => Active a -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isEmptyBox :: () => BoundingBox v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isLine :: () => Trail v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isLineEmpty :: (Metric v, OrderedField n) => Trail' Line v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isLoop :: () => Trail v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isReflection :: (Additive v, Traversable v, Num n, Ord n) => Transformation v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: isTrailEmpty :: (Metric v, OrderedField n) => Trail v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: iset :: () => AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: isets :: () => ((i -> a -> b) -> s -> t) -> IndexedSetter i s t a b
+ Knit.Report.Input.Visualization.Diagrams: isn't :: () => APrism s t a b -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: iso :: () => (s -> a) -> (b -> t) -> Iso s t a b
+ Knit.Report.Input.Visualization.Diagrams: itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f) => (i -> a -> Bool) -> Optical' (Indexed i) q (Const (Endo (f s)) :: Type -> Type) s a -> Optical' p q f s a
+ Knit.Report.Input.Visualization.Diagrams: italic :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: iterateN :: () => Int -> (a -> a) -> a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: iterated :: Apply f => (a -> a) -> LensLike' f a a
+ Knit.Report.Input.Visualization.Diagrams: ito :: (Indexable i p, Contravariant f) => (s -> (i, a)) -> Over' p f s a
+ Knit.Report.Input.Visualization.Diagrams: itoList :: FoldableWithIndex i f => f a -> [(i, a)]
+ Knit.Report.Input.Visualization.Diagrams: itoListOf :: () => IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
+ Knit.Report.Input.Visualization.Diagrams: itraverse :: (TraversableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: itraverseBy :: TraversableWithIndex i t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: itraverseByOf :: () => IndexedTraversal i s t a b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: itraverseOf :: () => (Indexed i a (f b) -> s -> f t) -> (i -> a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
+ Knit.Report.Input.Visualization.Diagrams: itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()
+ Knit.Report.Input.Visualization.Diagrams: itraversed :: TraversableWithIndex i t => IndexedTraversal i (t a) (t b) a b
+ Knit.Report.Input.Visualization.Diagrams: iunsafePartsOf :: (Indexable [i] p, Functor f) => Traversing (Indexed i) f s t a b -> Over p f s t [a] [b]
+ Knit.Report.Input.Visualization.Diagrams: iunsafePartsOf' :: () => Over (Indexed i) (Bazaar (Indexed i) a b) s t a b -> IndexedLens [i] s t [a] [b]
+ Knit.Report.Input.Visualization.Diagrams: iuse :: MonadState s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Knit.Report.Input.Visualization.Diagrams: iuses :: MonadState s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: iview :: MonadReader s m => IndexedGetting i (i, a) s a -> m (i, a)
+ Knit.Report.Input.Visualization.Diagrams: iviews :: MonadReader s m => IndexedGetting i r s a -> (i -> a -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: ivory :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: ix :: Ixed m => Index m -> Traversal' m (IxValue m)
+ Knit.Report.Input.Visualization.Diagrams: ixAt :: At m => Index m -> Traversal' m (IxValue m)
+ Knit.Report.Input.Visualization.Diagrams: juxtapose :: Juxtaposable a => Vn a -> a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: juxtaposeDefault :: (Enveloped a, HasOrigin a) => Vn a -> a -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: khaki :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lGradEnd :: () => Lens' (LGradient n) (Point V2 n)
+ Knit.Report.Input.Visualization.Diagrams: lGradSpreadMethod :: () => Lens' (LGradient n) SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: lGradStart :: () => Lens' (LGradient n) (Point V2 n)
+ Knit.Report.Input.Visualization.Diagrams: lGradStops :: () => Lens' (LGradient n) [GradientStop n]
+ Knit.Report.Input.Visualization.Diagrams: lGradTrans :: () => Lens' (LGradient n) (Transformation V2 n)
+ Knit.Report.Input.Visualization.Diagrams: lapp :: () => (u :-: v) -> u -> v
+ Knit.Report.Input.Visualization.Diagrams: large :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: last1Of :: () => Getting (Last a) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: lastOf :: () => Getting (Rightmost a) s a -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: lavender :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lavenderblush :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lawngreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lazy :: Strict lazy strict => Iso' strict lazy
+ Knit.Report.Input.Visualization.Diagrams: lc :: (InSpace V2 n a, Typeable n, Floating n, HasStyle a) => Colour Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lcA :: (InSpace V2 n a, Typeable n, Floating n, HasStyle a) => AlphaColour Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: left' :: Choice p => p a b -> p (Either a c) (Either b c)
+ Knit.Report.Input.Visualization.Diagrams: leftTurn :: (Num n, Ord n) => V2 n -> V2 n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: lemonchiffon :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lengthOf :: () => Getting (Endo (Endo Int)) s a -> s -> Int
+ Knit.Report.Input.Visualization.Diagrams: lengths :: () => Traversal' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: lens :: () => (s -> a) -> (s -> b -> t) -> Lens s t a b
+ Knit.Report.Input.Visualization.Diagrams: lensClass :: Lens' LensRules ClassyNamer
+ Knit.Report.Input.Visualization.Diagrams: lensField :: Lens' LensRules FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: lensP :: () => Lens' (Point g a) (g a)
+ Knit.Report.Input.Visualization.Diagrams: lensRules :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: lensRulesFor :: [(String, String)] -> LensRules
+ Knit.Report.Input.Visualization.Diagrams: lerp :: (Additive f, Num a) => a -> f a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: liftA :: Applicative f => (a -> b) -> f a -> f b
+ Knit.Report.Input.Visualization.Diagrams: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
+ Knit.Report.Input.Visualization.Diagrams: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ Knit.Report.Input.Visualization.Diagrams: liftI2 :: Additive f => (a -> b -> c) -> f a -> f b -> f c
+ Knit.Report.Input.Visualization.Diagrams: liftU2 :: Additive f => (a -> a -> a) -> f a -> f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: lifted :: Monad m => Setter (m a) (m b) a b
+ Knit.Report.Input.Visualization.Diagrams: light :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: lightblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightcoral :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightcyan :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lighter :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: lightgoldenrodyellow :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightgray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightgrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightpink :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightsalmon :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightseagreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightskyblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightslategray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightslategrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightsteelblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lightyellow :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: like :: (Profunctor p, Contravariant f, Functor f) => a -> Optic' p f s a
+ Knit.Report.Input.Visualization.Diagrams: lime :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: limegreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: lineCap :: HasStyle a => LineCap -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineColor :: (InSpace V2 n a, Color c, Typeable n, Floating n, HasStyle a) => c -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineFromOffsets :: (Metric v, OrderedField n) => [v n] -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: lineFromSegments :: (Metric v, OrderedField n) => [Segment Closed v n] -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: lineFromVertices :: (Metric v, OrderedField n) => [Point v n] -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: lineHead :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: lineJoin :: HasStyle a => LineJoin -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineMiterLimit :: HasStyle a => Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineMiterLimitA :: HasStyle a => LineMiterLimit -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineOffset :: (Metric v, OrderedField n) => Trail' Line v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: lineOffsets :: () => Trail' Line v n -> [v n]
+ Knit.Report.Input.Visualization.Diagrams: lineSegments :: () => Trail' Line v n -> [Segment Closed v n]
+ Knit.Report.Input.Visualization.Diagrams: lineTail :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: lineTexture :: (InSpace V2 n a, Typeable n, Floating n, HasStyle a) => Texture n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineTextureA :: (InSpace V2 n a, Typeable n, Floating n, HasStyle a) => LineTexture n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineVertices :: (Metric v, OrderedField n) => Located (Trail' Line v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: lineVertices' :: (Metric v, OrderedField n) => n -> Located (Trail' Line v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: lineWidth :: (N a ~ n, HasStyle a, Typeable n) => Measure n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lineWidthM :: (N a ~ n, HasStyle a, Typeable n) => LineWidthM n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lined :: Applicative f => IndexedLensLike' Int f String String
+ Knit.Report.Input.Visualization.Diagrams: linen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: linv :: () => (u :-: v) -> v :-: u
+ Knit.Report.Input.Visualization.Diagrams: listening :: MonadWriter w m => Getting u w u -> m a -> m (a, u)
+ Knit.Report.Input.Visualization.Diagrams: listenings :: MonadWriter w m => Getting v w u -> (u -> v) -> m a -> m (a, v)
+ Knit.Report.Input.Visualization.Diagrams: lmap :: Profunctor p => (a -> b) -> p b c -> p a c
+ Knit.Report.Input.Visualization.Diagrams: lmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)
+ Knit.Report.Input.Visualization.Diagrams: loadImageEmb :: Num n => FilePath -> IO (Either String (DImage n Embedded))
+ Knit.Report.Input.Visualization.Diagrams: loadImageExt :: Num n => FilePath -> IO (Either String (DImage n External))
+ Knit.Report.Input.Visualization.Diagrams: local :: Num n => n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: localize :: (Metric v, OrderedField n, Semigroup m) => QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: locally :: MonadReader s m => ASetter s s a b -> (a -> b) -> m r -> m r
+ Knit.Report.Input.Visualization.Diagrams: located :: SameSpace a b => Lens (Located a) (Located b) a b
+ Knit.Report.Input.Visualization.Diagrams: location :: (Additive v, Num n) => Subdiagram b v n m -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: loci :: () => Traversal (Bazaar ((->) :: Type -> Type -> Type) a c s) (Bazaar ((->) :: Type -> Type -> Type) b c s) a b
+ Knit.Report.Input.Visualization.Diagrams: locus :: IndexedComonadStore p => Lens (p a c s) (p b c s) a b
+ Knit.Report.Input.Visualization.Diagrams: lookingupNamer :: [(String, String)] -> FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: lookupName :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> QDiagram b v n m -> Maybe (Subdiagram b v n m)
+ Knit.Report.Input.Visualization.Diagrams: lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
+ Knit.Report.Input.Visualization.Diagrams: lookupSub :: IsName nm => nm -> SubMap b v n m -> Maybe [Subdiagram b v n m]
+ Knit.Report.Input.Visualization.Diagrams: loopFromSegments :: (Metric v, OrderedField n) => [Segment Closed v n] -> Segment Open v n -> Trail' Loop v n
+ Knit.Report.Input.Visualization.Diagrams: loopOffsets :: (Metric v, OrderedField n) => Trail' Loop v n -> [v n]
+ Knit.Report.Input.Visualization.Diagrams: loopSegments :: () => Trail' Loop v n -> ([Segment Closed v n], Segment Open v n)
+ Knit.Report.Input.Visualization.Diagrams: loopVertices :: (Metric v, OrderedField n) => Located (Trail' Loop v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: loopVertices' :: (Metric v, OrderedField n) => n -> Located (Trail' Loop v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: lw :: (N a ~ n, HasStyle a, Typeable n) => Measure n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lwG :: (N a ~ n, HasStyle a, Typeable n, Num n) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lwL :: (N a ~ n, HasStyle a, Typeable n, Num n) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lwN :: (N a ~ n, HasStyle a, Typeable n, Num n) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: lwO :: (N a ~ n, HasStyle a, Typeable n) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: mCenterPoint :: (InSpace v n a, HasBasis v, Enveloped a) => a -> Maybe (Point v n)
+ Knit.Report.Input.Visualization.Diagrams: magenta :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: magma :: () => LensLike (Mafic a b) s t a b -> Iso s u (Magma Int t b a) (Magma j u c c)
+ Knit.Report.Input.Visualization.Diagrams: magnify :: Magnify m n b a => LensLike' (Magnified m c) a b -> m c -> n c
+ Knit.Report.Input.Visualization.Diagrams: makeClassy :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeClassyFor :: String -> String -> [(String, String)] -> Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeClassyPrisms :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeClassy_ :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeFields :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeFieldsNoPrefix :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeLenses :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeLensesFor :: [(String, String)] -> Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeLensesWith :: LensRules -> Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makePrisms :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: makeWrapped :: Name -> DecsQ
+ Knit.Report.Input.Visualization.Diagrams: mapAccumLOf :: () => LensLike (State acc) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Knit.Report.Input.Visualization.Diagrams: mapAccumROf :: () => LensLike (Backwards (State acc)) s t a b -> (acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
+ Knit.Report.Input.Visualization.Diagrams: mapEq :: () => AnEquality s t a b -> f s -> f a
+ Knit.Report.Input.Visualization.Diagrams: mapLoc :: SameSpace a b => (a -> b) -> Located a -> Located b
+ Knit.Report.Input.Visualization.Diagrams: mapMOf :: () => LensLike (WrappedMonad m) s t a b -> (a -> m b) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
+ Knit.Report.Input.Visualization.Diagrams: mapOf :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: mapSegmentVectors :: () => (v n -> v' n') -> Segment c v n -> Segment c v' n'
+ Knit.Report.Input.Visualization.Diagrams: mapped :: Functor f => Setter (f a) (f b) a b
+ Knit.Report.Input.Visualization.Diagrams: mapping :: (Functor f, Functor g) => AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
+ Knit.Report.Input.Visualization.Diagrams: mappingNamer :: (String -> [String]) -> FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: maroon :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: matching :: () => APrism s t a b -> s -> Either t a
+ Knit.Report.Input.Visualization.Diagrams: maxRayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
+ Knit.Report.Input.Visualization.Diagrams: maxRayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n)
+ Knit.Report.Input.Visualization.Diagrams: maxTraceP :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
+ Knit.Report.Input.Visualization.Diagrams: maxTraceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n)
+ Knit.Report.Input.Visualization.Diagrams: maximum1Of :: Ord a => Getting (Max a) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: maximumByOf :: () => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: medium :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: mediumWeight :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: mediumaquamarine :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumorchid :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumpurple :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumseagreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumslateblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumspringgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumturquoise :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mediumvioletred :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: midnightblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: minimum1Of :: Ord a => Getting (Min a) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: minimumByOf :: () => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
+ Knit.Report.Input.Visualization.Diagrams: mintcream :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mistyrose :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: mkActive :: () => Time Rational -> Time Rational -> (Time Rational -> a) -> Active a
+ Knit.Report.Input.Visualization.Diagrams: mkDynamic :: () => Time Rational -> Time Rational -> (Time Rational -> a) -> Dynamic a
+ Knit.Report.Input.Visualization.Diagrams: mkEnvelope :: () => (v n -> n) -> Envelope v n
+ Knit.Report.Input.Visualization.Diagrams: mkEra :: () => Time n -> Time n -> Era n
+ Knit.Report.Input.Visualization.Diagrams: mkFixedSeg :: (Num n, Additive v) => Located (Segment Closed v n) -> FixedSegment v n
+ Knit.Report.Input.Visualization.Diagrams: mkHeight :: Num n => n -> SizeSpec V2 n
+ Knit.Report.Input.Visualization.Diagrams: mkLinearGradient :: Num n => [GradientStop n] -> Point V2 n -> Point V2 n -> SpreadMethod -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: mkP2 :: () => n -> n -> P2 n
+ Knit.Report.Input.Visualization.Diagrams: mkP3 :: () => n -> n -> n -> P3 n
+ Knit.Report.Input.Visualization.Diagrams: mkQD :: () => Prim b v n -> Envelope v n -> Trace v n -> SubMap b v n m -> Query v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: mkR2 :: () => n -> n -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: mkR3 :: () => n -> n -> n -> V3 n
+ Knit.Report.Input.Visualization.Diagrams: mkRadialGradient :: Num n => [GradientStop n] -> Point V2 n -> n -> Point V2 n -> n -> SpreadMethod -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: mkSizeSpec :: (Functor v, Num n) => v (Maybe n) -> SizeSpec v n
+ Knit.Report.Input.Visualization.Diagrams: mkSizeSpec2D :: Num n => Maybe n -> Maybe n -> SizeSpec V2 n
+ Knit.Report.Input.Visualization.Diagrams: mkSortedList :: Ord a => [a] -> SortedList a
+ Knit.Report.Input.Visualization.Diagrams: mkStops :: () => [(Colour Double, d, Double)] -> [GradientStop d]
+ Knit.Report.Input.Visualization.Diagrams: mkSubdiagram :: () => QDiagram b v n m -> Subdiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: mkTrace :: () => (Point v n -> v n -> SortedList n) -> Trace v n
+ Knit.Report.Input.Visualization.Diagrams: mkWidth :: Num n => n -> SizeSpec V2 n
+ Knit.Report.Input.Visualization.Diagrams: mm50 :: Floating n => PerspectiveLens n
+ Knit.Report.Input.Visualization.Diagrams: mm50Camera :: (Typeable n, Floating n, Ord n, Renderable (Camera PerspectiveLens n) b) => QDiagram b V3 n Any
+ Knit.Report.Input.Visualization.Diagrams: mm50Narrow :: Floating n => PerspectiveLens n
+ Knit.Report.Input.Visualization.Diagrams: mm50Wide :: Floating n => PerspectiveLens n
+ Knit.Report.Input.Visualization.Diagrams: moccasin :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: modActive :: () => (a -> b) -> (Dynamic a -> Dynamic b) -> Active a -> Active b
+ Knit.Report.Input.Visualization.Diagrams: modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
+ Knit.Report.Input.Visualization.Diagrams: moveOriginBy :: (V t ~ v, N t ~ n, HasOrigin t) => v n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: moveOriginTo :: HasOrigin t => Point (V t) (N t) -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: moveTo :: (InSpace v n t, HasOrigin t) => Point v n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: movedFrom :: (InSpace v n a, SameSpace a b, HasOrigin a, HasOrigin b) => Point v n -> Iso a b a b
+ Knit.Report.Input.Visualization.Diagrams: movedTo :: (InSpace v n a, SameSpace a b, HasOrigin a, HasOrigin b) => Point v n -> Iso a b a b
+ Knit.Report.Input.Visualization.Diagrams: movie :: () => [Active a] -> Active a
+ Knit.Report.Input.Visualization.Diagrams: msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
+ Knit.Report.Input.Visualization.Diagrams: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: namePoint :: (IsName nm, Metric v, OrderedField n, Semigroup m) => (QDiagram b v n m -> Point v n) -> nm -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: nameSub :: (IsName nm, Metric v, OrderedField n, Semigroup m) => (QDiagram b v n m -> Subdiagram b v n m) -> nm -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: named :: (IsName nm, Metric v, OrderedField n, Semigroup m) => nm -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: names :: (Metric v, Semigroup m, OrderedField n) => QDiagram b v n m -> [(Name, [Point v n])]
+ Knit.Report.Input.Visualization.Diagrams: navajowhite :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: navy :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: nearly :: () => a -> (a -> Bool) -> Prism' a ()
+ Knit.Report.Input.Visualization.Diagrams: negated :: (Functor f, Num a) => f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: newtype All
+ Knit.Report.Input.Visualization.Diagrams: newtype Ambient
+ Knit.Report.Input.Visualization.Diagrams: newtype Any
+ Knit.Report.Input.Visualization.Diagrams: newtype ArcLength n
+ Knit.Report.Input.Visualization.Diagrams: newtype Bazaar (p :: Type -> Type -> Type) a b t
+ Knit.Report.Input.Visualization.Diagrams: newtype Bazaar1 (p :: Type -> Type -> Type) a b t
+ Knit.Report.Input.Visualization.Diagrams: newtype Deformation (v :: Type -> Type) (u :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype Diffuse
+ Knit.Report.Input.Visualization.Diagrams: newtype Dual a
+ Knit.Report.Input.Visualization.Diagrams: newtype E (t :: Type -> Type)
+ Knit.Report.Input.Visualization.Diagrams: newtype Endo a
+ Knit.Report.Input.Visualization.Diagrams: newtype Envelope (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype First a
+ Knit.Report.Input.Visualization.Diagrams: newtype GetSegment t
+ Knit.Report.Input.Visualization.Diagrams: newtype GetSegmentCodomain (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype Highlight
+ Knit.Report.Input.Visualization.Diagrams: newtype Identity a
+ Knit.Report.Input.Visualization.Diagrams: newtype Indexed i a b
+ Knit.Report.Input.Visualization.Diagrams: newtype Last a
+ Knit.Report.Input.Visualization.Diagrams: newtype LineMiterLimit
+ Knit.Report.Input.Visualization.Diagrams: newtype Max a
+ Knit.Report.Input.Visualization.Diagrams: newtype Min a
+ Knit.Report.Input.Visualization.Diagrams: newtype Option a
+ Knit.Report.Input.Visualization.Diagrams: newtype Path (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype Point (f :: Type -> Type) a
+ Knit.Report.Input.Visualization.Diagrams: newtype Product a
+ Knit.Report.Input.Visualization.Diagrams: newtype Query (v :: Type -> Type) n m
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedFold s a
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedGetter s a
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIndexedFold i s a
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIndexedGetter i s a
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIndexedLens i s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIndexedSetter i s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIndexedTraversal i s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedIso s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedLens s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedPrism s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedSetter s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype ReifiedTraversal s t a b
+ Knit.Report.Input.Visualization.Diagrams: newtype SegCount
+ Knit.Report.Input.Visualization.Diagrams: newtype SegTree (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype SubMap b (v :: Type -> Type) n m
+ Knit.Report.Input.Visualization.Diagrams: newtype Sum a
+ Knit.Report.Input.Visualization.Diagrams: newtype SurfaceColor
+ Knit.Report.Input.Visualization.Diagrams: newtype Tangent t
+ Knit.Report.Input.Visualization.Diagrams: newtype TotalOffset (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype Trace (v :: Type -> Type) n
+ Knit.Report.Input.Visualization.Diagrams: newtype TransInv t
+ Knit.Report.Input.Visualization.Diagrams: newtype Const a (b :: k) :: forall k. () => Type -> k -> Type
+ Knit.Report.Input.Visualization.Diagrams: newtype WrappedMonoid m
+ Knit.Report.Input.Visualization.Diagrams: noHead :: () => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: noTail :: () => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: non :: Eq a => a -> Iso' (Maybe a) a
+ Knit.Report.Input.Visualization.Diagrams: non' :: () => APrism' a () -> Iso' (Maybe a) a
+ Knit.Report.Input.Visualization.Diagrams: nonagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: none :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: noneOf :: () => Getting Any s a -> (a -> Bool) -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: norm :: (Metric f, Floating a) => f a -> a
+ Knit.Report.Input.Visualization.Diagrams: normal :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: normalAtEnd :: (InSpace V2 n t, EndValues (Tangent t), Floating n) => t -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: normalAtParam :: (InSpace V2 n t, Parametric (Tangent t), Floating n) => t -> n -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: normalAtStart :: (InSpace V2 n t, EndValues (Tangent t), Floating n) => t -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: normalize :: (Floating a, Metric f, Epsilon a) => f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: normalizeAngle :: (Floating n, Real n) => Angle n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: normalized :: Num n => n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: notNullOf :: () => Getting Any s a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: nullOf :: () => Getting All s a -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: numSegs :: (Num c, Measured (SegMeasure v n) a) => a -> c
+ Knit.Report.Input.Visualization.Diagrams: oColor :: () => Lens' (OriginOpts n) (Colour Double)
+ Knit.Report.Input.Visualization.Diagrams: oMinSize :: () => Lens' (OriginOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: oScale :: () => Lens' (OriginOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: oblique :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: octagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: oeEnvelope :: () => Lens' (OffsetEnvelope v n) (Envelope v n)
+ Knit.Report.Input.Visualization.Diagrams: oeOffset :: () => Lens' (OffsetEnvelope v n) (TotalOffset v n)
+ Knit.Report.Input.Visualization.Diagrams: offset :: (OrderedField n, Metric v, Measured (SegMeasure v n) t) => t -> v n
+ Knit.Report.Input.Visualization.Diagrams: oldlace :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: olive :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: olivedrab :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: onActive :: () => (a -> b) -> (Dynamic a -> b) -> Active a -> b
+ Knit.Report.Input.Visualization.Diagrams: onDynamic :: () => (Time Rational -> Time Rational -> (Time Rational -> a) -> b) -> Dynamic a -> b
+ Knit.Report.Input.Visualization.Diagrams: onEnvelope :: () => ((v n -> n) -> v n -> n) -> Envelope v n -> Envelope v n
+ Knit.Report.Input.Visualization.Diagrams: onLine :: (Metric v, OrderedField n) => (Trail' Line v n -> Trail' Line v n) -> Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: onLineSegments :: (Metric v, OrderedField n) => ([Segment Closed v n] -> [Segment Closed v n]) -> Trail' Line v n -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: onTrail :: () => (Trail' Line v n -> Trail' l1 v n) -> (Trail' Loop v n -> Trail' l2 v n) -> Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: only :: Eq a => a -> Prism' a ()
+ Knit.Report.Input.Visualization.Diagrams: op :: Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
+ Knit.Report.Input.Visualization.Diagrams: opacity :: HasStyle a => Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: opacityGroup :: (Metric v, OrderedField n, Semigroup m) => Double -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: opaque :: Num a => Colour a -> AlphaColour a
+ Knit.Report.Input.Visualization.Diagrams: openCubic :: () => v n -> v n -> Segment Open v n
+ Knit.Report.Input.Visualization.Diagrams: openLinear :: () => Segment Open v n
+ Knit.Report.Input.Visualization.Diagrams: option :: () => b -> (a -> b) -> Option a -> b
+ Knit.Report.Input.Visualization.Diagrams: orOf :: () => Getting Any s Bool -> s -> Bool
+ Knit.Report.Input.Visualization.Diagrams: orange :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: orangered :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: orchid :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: origin :: (Additive f, Num a) => Point f a
+ Knit.Report.Input.Visualization.Diagrams: orthoHeight :: () => Lens' (OrthoLens n) n
+ Knit.Report.Input.Visualization.Diagrams: orthoWidth :: () => Lens' (OrthoLens n) n
+ Knit.Report.Input.Visualization.Diagrams: outer :: (Functor f, Functor g, Num a) => f a -> g a -> f (g a)
+ Knit.Report.Input.Visualization.Diagrams: output :: () => n -> Measure n
+ Knit.Report.Input.Visualization.Diagrams: outside' :: (Additive v, Foldable v, Ord n) => BoundingBox v n -> BoundingBox v n -> Bool
+ Knit.Report.Input.Visualization.Diagrams: over :: () => ASetter s t a b -> (a -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: overA :: Arrow ar => LensLike (Context a b) s t a b -> ar a b -> ar s t
+ Knit.Report.Input.Visualization.Diagrams: p2 :: () => (n, n) -> P2 n
+ Knit.Report.Input.Visualization.Diagrams: p3 :: () => (n, n, n) -> P3 n
+ Knit.Report.Input.Visualization.Diagrams: p3Iso :: () => Iso' (P3 n) (n, n, n)
+ Knit.Report.Input.Visualization.Diagrams: pad :: (Metric v, OrderedField n, Monoid' m) => n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: padX :: (Metric v, R2 v, OrderedField n, Monoid' m) => n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: padY :: (Metric v, R2 v, Monoid' m, OrderedField n) => n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: palegoldenrod :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: palegreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: paleturquoise :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: palevioletred :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: papayawhip :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: papply :: (Additive v, Num n) => Transformation v n -> Point v n -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: para :: Plated a => (a -> [r] -> r) -> a -> r
+ Knit.Report.Input.Visualization.Diagrams: paraOf :: () => Getting (Endo [a]) a a -> (a -> [r] -> r) -> a -> r
+ Knit.Report.Input.Visualization.Diagrams: parallelLight :: (Typeable n, OrderedField n, Renderable (ParallelLight n) b) => Direction V3 n -> Colour Double -> QDiagram b V3 n Any
+ Knit.Report.Input.Visualization.Diagrams: parallelX0 :: (R1 v, Num n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: parallelY0 :: (R2 v, Num n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: parallelZ0 :: (R3 v, Num n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: partitionPath :: () => (Located (Trail v n) -> Bool) -> Path v n -> (Path v n, Path v n)
+ Knit.Report.Input.Visualization.Diagrams: parts :: Plated a => Lens' a [a]
+ Knit.Report.Input.Visualization.Diagrams: partsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a a -> LensLike f s t [a] [a]
+ Knit.Report.Input.Visualization.Diagrams: partsOf' :: () => ATraversal s t a a -> Lens s t [a] [a]
+ Knit.Report.Input.Visualization.Diagrams: passing :: MonadWriter w m => Setter w w u v -> m (a, u -> v) -> m a
+ Knit.Report.Input.Visualization.Diagrams: pathCentroid :: (Metric v, OrderedField n) => Path v n -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: pathFromLocTrail :: (Metric v, OrderedField n) => Located (Trail v n) -> Path v n
+ Knit.Report.Input.Visualization.Diagrams: pathFromTrail :: (Metric v, OrderedField n) => Trail v n -> Path v n
+ Knit.Report.Input.Visualization.Diagrams: pathFromTrailAt :: (Metric v, OrderedField n) => Trail v n -> Point v n -> Path v n
+ Knit.Report.Input.Visualization.Diagrams: pathLocSegments :: (Metric v, OrderedField n) => Path v n -> [[Located (Segment Closed v n)]]
+ Knit.Report.Input.Visualization.Diagrams: pathOffsets :: (Metric v, OrderedField n) => Path v n -> [v n]
+ Knit.Report.Input.Visualization.Diagrams: pathTrails :: () => Path v n -> [Located (Trail v n)]
+ Knit.Report.Input.Visualization.Diagrams: pathVertices :: (Metric v, OrderedField n) => Path v n -> [[Point v n]]
+ Knit.Report.Input.Visualization.Diagrams: pathVertices' :: (Metric v, OrderedField n) => n -> Path v n -> [[Point v n]]
+ Knit.Report.Input.Visualization.Diagrams: pattern Wrapped :: forall s. Rewrapped s s => () => Unwrapped s -> s
+ Knit.Report.Input.Visualization.Diagrams: pattern List :: forall l. IsList l => () => [Item l] -> l
+ Knit.Report.Input.Visualization.Diagrams: pattern (:<) :: forall b a. Cons b b a a => () => a -> b -> b
+ Knit.Report.Input.Visualization.Diagrams: pattern Swapped :: forall (p :: Type -> Type -> Type) c d. Swapped p => () => p d c -> p c d
+ Knit.Report.Input.Visualization.Diagrams: pattern Empty :: forall s. AsEmpty s => () => s
+ Knit.Report.Input.Visualization.Diagrams: pattern Unwrapped :: forall t. Rewrapped t t => () => t -> Unwrapped t
+ Knit.Report.Input.Visualization.Diagrams: peachpuff :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: pentagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: perp :: Num a => V2 a -> V2 a
+ Knit.Report.Input.Visualization.Diagrams: perspectiveX1 :: (R1 v, Functor v, Fractional n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: perspectiveY1 :: (R2 v, Functor v, Floating n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: perspectiveZ1 :: (R3 v, Functor v, Fractional n) => Deformation v v n
+ Knit.Report.Input.Visualization.Diagrams: peru :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: phantom :: (InSpace v n a, Monoid' m, Enveloped a, Traced a) => a -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: pink :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: place :: (InSpace v n t, HasOrigin t) => t -> Point v n -> t
+ Knit.Report.Input.Visualization.Diagrams: plate :: Plated a => Traversal' a a
+ Knit.Report.Input.Visualization.Diagrams: plum :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: pointAt :: (Floating n, Ord n) => Direction V3 n -> Direction V3 n -> Direction V3 n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: pointAt' :: (Floating n, Ord n) => V3 n -> V3 n -> V3 n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: pointDiagram :: (Metric v, Fractional n) => Point v n -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: pointLight :: (Typeable n, Num n, Ord n, Renderable (PointLight n) b) => Colour Double -> QDiagram b V3 n Any
+ Knit.Report.Input.Visualization.Diagrams: polyCenter :: () => Lens' (PolygonOpts n) (Point V2 n)
+ Knit.Report.Input.Visualization.Diagrams: polyOrient :: () => Lens' (PolygonOpts n) (PolyOrientation n)
+ Knit.Report.Input.Visualization.Diagrams: polyTrail :: OrderedField n => PolygonOpts n -> Located (Trail V2 n)
+ Knit.Report.Input.Visualization.Diagrams: polyType :: () => Lens' (PolygonOpts n) (PolyType n)
+ Knit.Report.Input.Visualization.Diagrams: polygon :: (InSpace V2 n t, TrailLike t) => PolygonOpts n -> t
+ Knit.Report.Input.Visualization.Diagrams: position :: (InSpace v n a, HasOrigin a, Monoid' a) => [(Point v n, a)] -> a
+ Knit.Report.Input.Visualization.Diagrams: powderblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: pr :: Coordinates c => PrevDim c -> FinalCoord c -> c
+ Knit.Report.Input.Visualization.Diagrams: pre :: () => Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
+ Knit.Report.Input.Visualization.Diagrams: preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
+ Knit.Report.Input.Visualization.Diagrams: previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
+ Knit.Report.Input.Visualization.Diagrams: prism :: () => (b -> t) -> (s -> Either t a) -> Prism s t a b
+ Knit.Report.Input.Visualization.Diagrams: prism' :: () => (b -> s) -> (s -> Maybe a) -> Prism s s a b
+ Knit.Report.Input.Visualization.Diagrams: productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: project :: (Metric v, Fractional a) => v a -> v a -> v a
+ Knit.Report.Input.Visualization.Diagrams: pure :: Applicative f => a -> f a
+ Knit.Report.Input.Visualization.Diagrams: purple :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: qd :: (Metric f, Num a) => f a -> f a -> a
+ Knit.Report.Input.Visualization.Diagrams: qdA :: (Affine p, Foldable (Diff p), Num a) => p a -> p a -> a
+ Knit.Report.Input.Visualization.Diagrams: quadrance :: (Metric f, Num a) => f a -> a
+ Knit.Report.Input.Visualization.Diagrams: quarterTurn :: Floating v => Angle v
+ Knit.Report.Input.Visualization.Diagrams: query :: Monoid m => QDiagram b v n m -> Query v n m
+ Knit.Report.Input.Visualization.Diagrams: queryFillRule :: () => Lens' (StrokeOpts a) FillRule
+ Knit.Report.Input.Visualization.Diagrams: quill :: (Floating n, Ord n) => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: r2 :: () => (n, n) -> V2 n
+ Knit.Report.Input.Visualization.Diagrams: r2PolarIso :: RealFloat n => Iso' (V2 n) (n, Angle n)
+ Knit.Report.Input.Visualization.Diagrams: r3 :: () => (n, n, n) -> V3 n
+ Knit.Report.Input.Visualization.Diagrams: r3CylindricalIso :: RealFloat n => Iso' (V3 n) (n, Angle n, n)
+ Knit.Report.Input.Visualization.Diagrams: r3Iso :: () => Iso' (V3 n) (n, n, n)
+ Knit.Report.Input.Visualization.Diagrams: r3SphericalIso :: RealFloat n => Iso' (V3 n) (n, Angle n, Angle n)
+ Knit.Report.Input.Visualization.Diagrams: rGradCenter0 :: () => Lens' (RGradient n) (Point V2 n)
+ Knit.Report.Input.Visualization.Diagrams: rGradCenter1 :: () => Lens' (RGradient n) (Point V2 n)
+ Knit.Report.Input.Visualization.Diagrams: rGradRadius0 :: () => Lens' (RGradient n) n
+ Knit.Report.Input.Visualization.Diagrams: rGradRadius1 :: () => Lens' (RGradient n) n
+ Knit.Report.Input.Visualization.Diagrams: rGradSpreadMethod :: () => Lens' (RGradient n) SpreadMethod
+ Knit.Report.Input.Visualization.Diagrams: rGradStops :: () => Lens' (RGradient n) [GradientStop n]
+ Knit.Report.Input.Visualization.Diagrams: rGradTrans :: () => Lens' (RGradient n) (Transformation V2 n)
+ Knit.Report.Input.Visualization.Diagrams: rad :: () => Iso' (Angle n) n
+ Knit.Report.Input.Visualization.Diagrams: radius :: (V a ~ v, N a ~ n, Enveloped a) => v n -> a -> n
+ Knit.Report.Input.Visualization.Diagrams: radiusBL :: () => Lens' (RoundedRectOpts d) d
+ Knit.Report.Input.Visualization.Diagrams: radiusBR :: () => Lens' (RoundedRectOpts d) d
+ Knit.Report.Input.Visualization.Diagrams: radiusTL :: () => Lens' (RoundedRectOpts d) d
+ Knit.Report.Input.Visualization.Diagrams: radiusTR :: () => Lens' (RoundedRectOpts d) d
+ Knit.Report.Input.Visualization.Diagrams: raster :: Num n => (Int -> Int -> AlphaColour Double) -> Int -> Int -> DImage n Embedded
+ Knit.Report.Input.Visualization.Diagrams: rasterDia :: (TypeableFloat n, Renderable (DImage n Embedded) b) => (Int -> Int -> AlphaColour Double) -> Int -> Int -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: rawSub :: () => Subdiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: rayTraceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
+ Knit.Report.Input.Visualization.Diagrams: rayTraceV :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (V a n)
+ Knit.Report.Input.Visualization.Diagrams: re :: () => AReview t b -> Getter b t
+ Knit.Report.Input.Visualization.Diagrams: readColourName :: (MonadFail m, Monad m, Ord a, Floating a) => String -> m (Colour a)
+ Knit.Report.Input.Visualization.Diagrams: recommendFillColor :: (InSpace V2 n a, Color c, Typeable n, Floating n, HasStyle a) => c -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: rect :: (InSpace V2 n t, TrailLike t) => n -> n -> t
+ Knit.Report.Input.Visualization.Diagrams: rectEnvelope :: (OrderedField n, Monoid' m) => Point V2 n -> V2 n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: red :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: reflectAbout :: (InSpace V2 n t, OrderedField n, Transformable t) => P2 n -> Direction V2 n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectAcross :: (InSpace v n t, Metric v, Fractional n, Transformable t) => Point v n -> v n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectX :: (InSpace v n t, R1 v, Transformable t) => t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectXY :: (InSpace v n t, R2 v, Transformable t) => t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectY :: (InSpace v n t, R2 v, Transformable t) => t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectZ :: (InSpace v n t, R3 v, Transformable t) => t -> t
+ Knit.Report.Input.Visualization.Diagrams: reflectionAbout :: OrderedField n => P2 n -> Direction V2 n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: reflectionAcross :: (Metric v, Fractional n) => Point v n -> v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: reflectionX :: (Additive v, R1 v, Num n) => Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: reflectionXY :: (Additive v, R2 v, Num n) => Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: reflectionY :: (Additive v, R2 v, Num n) => Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: reflectionZ :: (Additive v, R3 v, Num n) => Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: regPoly :: (InSpace V2 n t, TrailLike t) => Int -> n -> t
+ Knit.Report.Input.Visualization.Diagrams: reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r
+ Knit.Report.Input.Visualization.Diagrams: relative :: (Additive f, Num a) => Point f a -> Iso' (Point f a) (f a)
+ Knit.Report.Input.Visualization.Diagrams: rememberAs :: IsName a => a -> QDiagram b v n m -> SubMap b v n m -> SubMap b v n m
+ Knit.Report.Input.Visualization.Diagrams: render :: Renderable t b => b -> t -> Render b (V t) (N t)
+ Knit.Report.Input.Visualization.Diagrams: renderDia :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> Result b v n
+ Knit.Report.Input.Visualization.Diagrams: renderDiaT :: (Backend b v n, HasLinearMap v, Metric v, Typeable n, OrderedField n, Monoid' m) => b -> Options b v n -> QDiagram b v n m -> (Transformation v n, Result b v n)
+ Knit.Report.Input.Visualization.Diagrams: renderRTree :: Backend b v n => b -> Options b v n -> RTree b v n Annotation -> Result b v n
+ Knit.Report.Input.Visualization.Diagrams: repeated :: Apply f => LensLike' f a a
+ Knit.Report.Input.Visualization.Diagrams: replicated :: () => Int -> Fold a a
+ Knit.Report.Input.Visualization.Diagrams: requiredScale :: (Additive v, Foldable v, Fractional n, Ord n) => SizeSpec v n -> v n -> n
+ Knit.Report.Input.Visualization.Diagrams: requiredScaling :: (Additive v, Foldable v, Fractional n, Ord n) => SizeSpec v n -> v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: resetValue :: (Eq m, Monoid m) => QDiagram b v n m -> QDiagram b v n Any
+ Knit.Report.Input.Visualization.Diagrams: retagged :: (Profunctor p, Bifunctor p) => p a b -> p s b
+ Knit.Report.Input.Visualization.Diagrams: reuse :: MonadState b m => AReview t b -> m t
+ Knit.Report.Input.Visualization.Diagrams: reuses :: MonadState b m => AReview t b -> (t -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: reverseDomain :: Sectionable p => p -> p
+ Knit.Report.Input.Visualization.Diagrams: reverseLine :: (Metric v, OrderedField n) => Trail' Line v n -> Trail' Line v n
+ Knit.Report.Input.Visualization.Diagrams: reverseLocLine :: (Metric v, OrderedField n) => Located (Trail' Line v n) -> Located (Trail' Line v n)
+ Knit.Report.Input.Visualization.Diagrams: reverseLocLoop :: (Metric v, OrderedField n) => Located (Trail' Loop v n) -> Located (Trail' Loop v n)
+ Knit.Report.Input.Visualization.Diagrams: reverseLocTrail :: (Metric v, OrderedField n) => Located (Trail v n) -> Located (Trail v n)
+ Knit.Report.Input.Visualization.Diagrams: reverseLoop :: (Metric v, OrderedField n) => Trail' Loop v n -> Trail' Loop v n
+ Knit.Report.Input.Visualization.Diagrams: reversePath :: (Metric v, OrderedField n) => Path v n -> Path v n
+ Knit.Report.Input.Visualization.Diagrams: reverseSegment :: (Num n, Additive v) => Segment Closed v n -> Segment Closed v n
+ Knit.Report.Input.Visualization.Diagrams: reverseTrail :: (Metric v, OrderedField n) => Trail v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: reversed :: Reversing a => Iso' a a
+ Knit.Report.Input.Visualization.Diagrams: reversing :: Reversing t => t -> t
+ Knit.Report.Input.Visualization.Diagrams: review :: MonadReader b m => AReview t b -> m t
+ Knit.Report.Input.Visualization.Diagrams: reviews :: MonadReader b m => AReview t b -> (t -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: rewrite :: Plated a => (a -> Maybe a) -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: rewriteM :: (Monad m, Plated a) => (a -> m (Maybe a)) -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: rewriteMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> a -> m b
+ Knit.Report.Input.Visualization.Diagrams: rewriteMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m (Maybe a)) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: rewriteMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m (Maybe a)) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: rewriteOf :: () => ASetter a b a b -> (b -> Maybe a) -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: rewriteOn :: Plated a => ASetter s t a a -> (a -> Maybe a) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: rewriteOnOf :: () => ASetter s t a b -> ASetter a b a b -> (b -> Maybe a) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: right' :: Choice p => p a b -> p (Either c a) (Either c b)
+ Knit.Report.Input.Visualization.Diagrams: rmap :: Profunctor p => (b -> c) -> p a b -> p a c
+ Knit.Report.Input.Visualization.Diagrams: rmapping :: (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)
+ Knit.Report.Input.Visualization.Diagrams: rosybrown :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: rotate :: (InSpace V2 n t, Transformable t, Floating n) => Angle n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: rotateAbout :: (InSpace V3 n t, Floating n, Transformable t) => Point V3 n -> Direction V3 n -> Angle n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: rotateAround :: (InSpace V2 n t, Transformable t, Floating n) => P2 n -> Angle n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: rotateBy :: (InSpace V2 n t, Transformable t, Floating n) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: rotateTo :: (InSpace V2 n t, OrderedField n, Transformable t) => Direction V2 n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: rotated :: (InSpace V2 n a, Floating n, SameSpace a b, Transformable a, Transformable b) => Angle n -> Iso a b a b
+ Knit.Report.Input.Visualization.Diagrams: rotation :: Floating n => Angle n -> Transformation V2 n
+ Knit.Report.Input.Visualization.Diagrams: rotationAbout :: Floating n => Point V3 n -> Direction V3 n -> Angle n -> Transformation V3 n
+ Knit.Report.Input.Visualization.Diagrams: rotationAround :: Floating n => P2 n -> Angle n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: rotationTo :: OrderedField n => Direction V2 n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: roundedRect :: (InSpace V2 n t, TrailLike t, RealFloat n) => n -> n -> n -> t
+ Knit.Report.Input.Visualization.Diagrams: roundedRect' :: (InSpace V2 n t, TrailLike t, RealFloat n) => n -> n -> RoundedRectOpts n -> t
+ Knit.Report.Input.Visualization.Diagrams: royalblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: runActive :: () => Active a -> Time Rational -> a
+ Knit.Report.Input.Visualization.Diagrams: runEq :: () => AnEquality s t a b -> Identical s t a b
+ Knit.Report.Input.Visualization.Diagrams: sRGB :: (Ord b, Floating b) => b -> b -> b -> Colour b
+ Knit.Report.Input.Visualization.Diagrams: sRGB24 :: (Ord b, Floating b) => Word8 -> Word8 -> Word8 -> Colour b
+ Knit.Report.Input.Visualization.Diagrams: sRGB24read :: (Ord b, Floating b) => String -> Colour b
+ Knit.Report.Input.Visualization.Diagrams: sRGB24reads :: (Ord b, Floating b) => ReadS (Colour b)
+ Knit.Report.Input.Visualization.Diagrams: sRGB24show :: (RealFrac b, Floating b) => Colour b -> String
+ Knit.Report.Input.Visualization.Diagrams: sRGB24shows :: (RealFrac b, Floating b) => Colour b -> ShowS
+ Knit.Report.Input.Visualization.Diagrams: sRGBBounded :: (Ord b, Floating b, Integral a, Bounded a) => a -> a -> a -> Colour b
+ Knit.Report.Input.Visualization.Diagrams: sRGBSpace :: (Ord a, Floating a) => RGBSpace a
+ Knit.Report.Input.Visualization.Diagrams: saddlebrown :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: salmon :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: sample :: HasQuery t m => t -> Point (V t) (N t) -> m
+ Knit.Report.Input.Visualization.Diagrams: sandybrown :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: sans :: At m => Index m -> m -> m
+ Knit.Report.Input.Visualization.Diagrams: sc :: HasStyle d => Colour Double -> d -> d
+ Knit.Report.Input.Visualization.Diagrams: scale :: (InSpace v n a, Eq n, Fractional n, Transformable a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: scaleLocal :: Num n => n -> Measured n a -> Measured n a
+ Knit.Report.Input.Visualization.Diagrams: scalePath :: (HasLinearMap v, Metric v, OrderedField n) => n -> Path v n -> Path v n
+ Knit.Report.Input.Visualization.Diagrams: scaleRotateTo :: (InSpace V2 n t, Transformable t, Floating n) => V2 n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleToX :: (InSpace v n t, R2 v, Enveloped t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleToY :: (InSpace v n t, R2 v, Enveloped t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleUToX :: (InSpace v n t, R1 v, Enveloped t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleUToY :: (InSpace v n t, R2 v, Enveloped t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleX :: (InSpace v n t, R2 v, Fractional n, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleY :: (InSpace v n t, R2 v, Fractional n, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaleZ :: (InSpace v n t, R3 v, Fractional n, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: scaled :: (Traversable t, Num a) => t a -> t (t a)
+ Knit.Report.Input.Visualization.Diagrams: scaling :: (Additive v, Fractional n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: scalingRotationTo :: Floating n => V2 n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: scalingX :: (Additive v, R1 v, Fractional n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: scalingY :: (Additive v, R2 v, Fractional n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: scalingZ :: (Additive v, R3 v, Fractional n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: scanl1Of :: () => LensLike (State (Maybe a)) s t a a -> (a -> a -> a) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: scanr1Of :: () => LensLike (Backwards (State (Maybe a))) s t a a -> (a -> a -> a) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: sconcat :: Semigroup a => NonEmpty a -> a
+ Knit.Report.Input.Visualization.Diagrams: scribe :: (MonadWriter t m, Monoid s) => ASetter s t a b -> b -> m ()
+ Knit.Report.Input.Visualization.Diagrams: seagreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: seashell :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: seconding :: (Bifunctor f, Bifunctor g) => AnIso s t a b -> Iso (f x s) (g y t) (f x a) (g y b)
+ Knit.Report.Input.Visualization.Diagrams: section :: Sectionable p => p -> N p -> N p -> p
+ Knit.Report.Input.Visualization.Diagrams: segOffset :: () => Segment Closed v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: selfIndex :: Indexable a p => p a fb -> a -> fb
+ Knit.Report.Input.Visualization.Diagrams: semiBold :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: sep :: () => Lens' (CatOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: septagon :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
+ Knit.Report.Input.Visualization.Diagrams: sequenceAOf :: () => LensLike f s t (f b) b -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
+ Knit.Report.Input.Visualization.Diagrams: sequenceBy :: Traversable t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> t (f a) -> f (t a)
+ Knit.Report.Input.Visualization.Diagrams: sequenceByOf :: () => Traversal s t (f b) b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: sequenceOf :: () => LensLike (WrappedMonad m) s t (m b) b -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
+ Knit.Report.Input.Visualization.Diagrams: set :: () => ASetter s t a b -> b -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: set' :: () => ASetter' s a -> a -> s -> s
+ Knit.Report.Input.Visualization.Diagrams: setEnvelope :: (OrderedField n, Metric v, Monoid' m) => Envelope v n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: setEra :: () => Era Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: setTrace :: (OrderedField n, Metric v, Semigroup m) => Trace v n -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: sets :: (Profunctor p, Profunctor q, Settable f) => (p a b -> q s t) -> Optical p q f s t a b
+ Knit.Report.Input.Visualization.Diagrams: setting :: () => ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
+ Knit.Report.Input.Visualization.Diagrams: shaftStyle :: () => Lens' (ArrowOpts n) (Style V2 n)
+ Knit.Report.Input.Visualization.Diagrams: shaftTexture :: TypeableFloat n => Lens' (ArrowOpts n) (Texture n)
+ Knit.Report.Input.Visualization.Diagrams: shearX :: (InSpace V2 n t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: shearY :: (InSpace V2 n t, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: shearingX :: Num n => n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: shearingY :: Num n => n -> T2 n
+ Knit.Report.Input.Visualization.Diagrams: shift :: () => Duration Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: shiftDynamic :: () => Duration Rational -> Dynamic a -> Dynamic a
+ Knit.Report.Input.Visualization.Diagrams: showEnvelope :: (Enum n, TypeableFloat n, Renderable (Path V2 n) b) => QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: showEnvelope' :: (Enum n, TypeableFloat n, Renderable (Path V2 n) b) => EnvelopeOpts n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: showLabels :: (TypeableFloat n, Renderable (Text n) b, Semigroup m) => QDiagram b V2 n m -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: showOrigin :: (TypeableFloat n, Renderable (Path V2 n) b, Monoid' m) => QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: showOrigin' :: (TypeableFloat n, Renderable (Path V2 n) b, Monoid' m) => OriginOpts n -> QDiagram b V2 n m -> QDiagram b V2 n m
+ Knit.Report.Input.Visualization.Diagrams: showTrace :: (Enum n, TypeableFloat n, Renderable (Path V2 n) b) => QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: showTrace' :: (Enum n, TypeableFloat n, Renderable (Path V2 n) b) => TraceOpts n -> QDiagram b V2 n Any -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: sienna :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: signedAngleBetween :: RealFloat n => V2 n -> V2 n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: signedAngleBetweenDirs :: RealFloat n => Direction V2 n -> Direction V2 n -> Angle n
+ Knit.Report.Input.Visualization.Diagrams: signorm :: (Metric f, Floating a) => f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: silver :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: simple :: () => Equality' a a
+ Knit.Report.Input.Visualization.Diagrams: simpleLenses :: Lens' LensRules Bool
+ Knit.Report.Input.Visualization.Diagrams: simply :: () => (Optic' p f s a -> r) -> Optic' p f s a -> r
+ Knit.Report.Input.Visualization.Diagrams: simulate :: () => Rational -> Active a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: sinA :: Floating n => Angle n -> n
+ Knit.Report.Input.Visualization.Diagrams: size :: (V a ~ v, N a ~ n, Enveloped a, HasBasis v) => a -> v n
+ Knit.Report.Input.Visualization.Diagrams: sizeAdjustment :: (Additive v, Foldable v, OrderedField n) => SizeSpec v n -> BoundingBox v n -> (v n, Transformation v n)
+ Knit.Report.Input.Visualization.Diagrams: sized :: (InSpace v n a, HasLinearMap v, Transformable a, Enveloped a) => SizeSpec v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: sizedAs :: (InSpace v n a, SameSpace a b, HasLinearMap v, Transformable a, Enveloped a, Enveloped b) => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: skin :: (Skinned t, Renderable t b, N t ~ n, TypeableFloat n) => t -> QDiagram b V3 n Any
+ Knit.Report.Input.Visualization.Diagrams: skyblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: slateblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: slategray :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: slategrey :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: small :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: snapshot :: () => Time Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: snoc :: Snoc s s a a => s -> a -> s
+ Knit.Report.Input.Visualization.Diagrams: snow :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: snug :: (InSpace v n a, Fractional n, Alignable a, Traced a, HasOrigin a) => v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugB :: (InSpace V2 n a, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugBy :: (InSpace v n a, Fractional n, Alignable a, Traced a, HasOrigin a) => v n -> n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenter :: (InSpace v n a, Traversable v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterV :: (InSpace v n a, Fractional n, Alignable a, Traced a, HasOrigin a) => v n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterX :: (InSpace v n a, R1 v, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterXY :: (InSpace v n a, R2 v, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterXYZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterXZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterY :: (InSpace v n a, R2 v, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterYZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugCenterZ :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugL :: (InSpace V2 n a, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugR :: (InSpace V2 n a, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugT :: (InSpace V2 n a, Fractional n, Alignable a, Traced a, HasOrigin a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugX :: (InSpace v n a, R1 v, Fractional n, Alignable a, Traced a, HasOrigin a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugXMax :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugXMin :: (InSpace v n a, R1 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugY :: (InSpace v n a, R2 v, Fractional n, Alignable a, Traced a, HasOrigin a) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugYMax :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugYMin :: (InSpace v n a, R2 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugZ :: (V a ~ v, N a ~ n, Alignable a, Traced a, HasOrigin a, R3 v, Fractional n) => n -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugZMax :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: snugZMin :: (InSpace v n a, R3 v, Fractional n, Alignable a, HasOrigin a, Traced a) => a -> a
+ Knit.Report.Input.Visualization.Diagrams: solid :: Color a => a -> Texture n
+ Knit.Report.Input.Visualization.Diagrams: someToAlpha :: SomeColor -> AlphaColour Double
+ Knit.Report.Input.Visualization.Diagrams: specToSize :: (Foldable v, Functor v, Num n, Ord n) => n -> SizeSpec v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: specularIntensity :: Lens' Specular Double
+ Knit.Report.Input.Visualization.Diagrams: specularSize :: Lens' Specular Double
+ Knit.Report.Input.Visualization.Diagrams: sphere :: Num n => Ellipsoid n
+ Knit.Report.Input.Visualization.Diagrams: spike :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: spike' :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: splitAtParam :: Sectionable p => p -> N p -> (p, p)
+ Knit.Report.Input.Visualization.Diagrams: springgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: square :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: star :: OrderedField n => StarOpts -> [Point V2 n] -> Path V2 n
+ Knit.Report.Input.Visualization.Diagrams: start :: () => Era n -> Time n
+ Knit.Report.Input.Visualization.Diagrams: stdArcLength :: HasArcLength p => p -> N p
+ Knit.Report.Input.Visualization.Diagrams: stdArcLengthToParam :: HasArcLength p => p -> N p -> N p
+ Knit.Report.Input.Visualization.Diagrams: stdTolerance :: Fractional a => a
+ Knit.Report.Input.Visualization.Diagrams: steelblue :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: stimes :: (Semigroup a, Integral b) => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: stimesIdempotent :: Integral b => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: stopColor :: () => Lens' (GradientStop n) SomeColor
+ Knit.Report.Input.Visualization.Diagrams: stopFraction :: () => Lens' (GradientStop n) n
+ Knit.Report.Input.Visualization.Diagrams: storing :: () => ALens s t a b -> b -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: straight :: () => v n -> Segment Closed v n
+ Knit.Report.Input.Visualization.Diagrams: straightShaft :: OrderedField n => Trail V2 n
+ Knit.Report.Input.Visualization.Diagrams: stretch :: () => Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: stretchTo :: () => Duration Rational -> Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: strict :: Strict lazy strict => Iso' lazy strict
+ Knit.Report.Input.Visualization.Diagrams: stroke :: (InSpace V2 n t, ToPath t, TypeableFloat n, Renderable (Path V2 n) b) => t -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: stroke' :: (InSpace V2 n t, ToPath t, TypeableFloat n, Renderable (Path V2 n) b, IsName a) => StrokeOpts a -> t -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLine :: (TypeableFloat n, Renderable (Path V2 n) b) => Trail' Line V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLocLine :: (TypeableFloat n, Renderable (Path V2 n) b) => Located (Trail' Line V2 n) -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLocLoop :: (TypeableFloat n, Renderable (Path V2 n) b) => Located (Trail' Loop V2 n) -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLocT :: (TypeableFloat n, Renderable (Path V2 n) b) => Located (Trail V2 n) -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLocTrail :: (TypeableFloat n, Renderable (Path V2 n) b) => Located (Trail V2 n) -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeLoop :: (TypeableFloat n, Renderable (Path V2 n) b) => Trail' Loop V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeOpacity :: HasStyle a => Double -> a -> a
+ Knit.Report.Input.Visualization.Diagrams: strokeP :: (TypeableFloat n, Renderable (Path V2 n) b) => Path V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeP' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName a) => StrokeOpts a -> Path V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokePath :: (TypeableFloat n, Renderable (Path V2 n) b) => Path V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokePath' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName a) => StrokeOpts a -> Path V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeT :: (TypeableFloat n, Renderable (Path V2 n) b) => Trail V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeT' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName a) => StrokeOpts a -> Trail V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeTrail :: (TypeableFloat n, Renderable (Path V2 n) b) => Trail V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strokeTrail' :: (TypeableFloat n, Renderable (Path V2 n) b, IsName a) => StrokeOpts a -> Trail V2 n -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: strut :: (Metric v, OrderedField n) => v n -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: strutX :: (Metric v, R1 v, OrderedField n) => n -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: strutY :: (Metric v, R2 v, OrderedField n) => n -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: subMap :: (Metric v, Semigroup m, OrderedField n) => Lens' (QDiagram b v n m) (SubMap b v n m)
+ Knit.Report.Input.Visualization.Diagrams: subPoint :: (Metric v, OrderedField n) => Point v n -> Subdiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: substEq :: () => AnEquality s t a b -> ((s ~ a) -> (t ~ b) -> r) -> r
+ Knit.Report.Input.Visualization.Diagrams: sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
+ Knit.Report.Input.Visualization.Diagrams: sumV :: (Foldable f, Additive v, Num a) => f (v a) -> v a
+ Knit.Report.Input.Visualization.Diagrams: swapped :: Swapped p => Iso (p a b) (p c d) (p b a) (p d c)
+ Knit.Report.Input.Visualization.Diagrams: tColor :: () => Lens' (TraceOpts n) (Colour Double)
+ Knit.Report.Input.Visualization.Diagrams: tMinSize :: () => Lens' (TraceOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: tPoints :: () => Lens' (TraceOpts n) Int
+ Knit.Report.Input.Visualization.Diagrams: tScale :: () => Lens' (TraceOpts n) n
+ Knit.Report.Input.Visualization.Diagrams: tailGap :: () => Lens' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: tailLength :: () => Lens' (ArrowOpts n) (Measure n)
+ Knit.Report.Input.Visualization.Diagrams: tailStyle :: () => Lens' (ArrowOpts n) (Style V2 n)
+ Knit.Report.Input.Visualization.Diagrams: tailTexture :: TypeableFloat n => Lens' (ArrowOpts n) (Texture n)
+ Knit.Report.Input.Visualization.Diagrams: taking :: (Conjoined p, Applicative f) => Int -> Traversing p f s t a a -> Over p f s t a a
+ Knit.Report.Input.Visualization.Diagrams: takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
+ Knit.Report.Input.Visualization.Diagrams: tanA :: Floating n => Angle n -> n
+ Knit.Report.Input.Visualization.Diagrams: tangentAtEnd :: EndValues (Tangent t) => t -> Vn t
+ Knit.Report.Input.Visualization.Diagrams: tangentAtParam :: Parametric (Tangent t) => t -> N t -> Vn t
+ Knit.Report.Input.Visualization.Diagrams: tangentAtStart :: EndValues (Tangent t) => t -> Vn t
+ Knit.Report.Input.Visualization.Diagrams: tau :: Floating a => a
+ Knit.Report.Input.Visualization.Diagrams: teal :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: text :: (TypeableFloat n, Renderable (Text n) b) => String -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: thick :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: thin :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: thinWeight :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: thistle :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: thorn :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: thorn' :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: tiny :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: to :: (Profunctor p, Contravariant f) => (s -> a) -> Optic' p f s a
+ Knit.Report.Input.Visualization.Diagrams: toAlphaColour :: Color c => c -> AlphaColour Double
+ Knit.Report.Input.Visualization.Diagrams: toDuration :: () => n -> Duration n
+ Knit.Report.Input.Visualization.Diagrams: toListOf :: () => Getting (Endo [a]) s a -> s -> [a]
+ Knit.Report.Input.Visualization.Diagrams: toName :: IsName a => a -> Name
+ Knit.Report.Input.Visualization.Diagrams: toNonEmptyOf :: () => Getting (NonEmptyDList a) s a -> s -> NonEmpty a
+ Knit.Report.Input.Visualization.Diagrams: toPath :: ToPath t => t -> Path (V t) (N t)
+ Knit.Report.Input.Visualization.Diagrams: toSRGB :: (Ord b, Floating b) => Colour b -> RGB b
+ Knit.Report.Input.Visualization.Diagrams: toSRGB24 :: (RealFrac b, Floating b) => Colour b -> RGB Word8
+ Knit.Report.Input.Visualization.Diagrams: toSRGBBounded :: (RealFrac b, Floating b, Integral a, Bounded a) => Colour b -> RGB a
+ Knit.Report.Input.Visualization.Diagrams: toTime :: () => n -> Time n
+ Knit.Report.Input.Visualization.Diagrams: tomato :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: topLeftText :: (TypeableFloat n, Renderable (Text n) b) => String -> QDiagram b V2 n Any
+ Knit.Report.Input.Visualization.Diagrams: traceBoundary :: (V a ~ v, N a ~ n, Num n, Traced a) => v n -> a -> Point v n
+ Knit.Report.Input.Visualization.Diagrams: traceP :: (n ~ N a, Traced a, Num n) => Point (V a) n -> V a n -> a -> Maybe (Point (V a) n)
+ Knit.Report.Input.Visualization.Diagrams: traceV :: (n ~ N a, Num n, Traced a) => Point (V a) n -> V a n -> a -> Maybe (V a n)
+ Knit.Report.Input.Visualization.Diagrams: trailFromOffsets :: (Metric v, OrderedField n) => [v n] -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: trailFromSegments :: (Metric v, OrderedField n) => [Segment Closed v n] -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: trailFromVertices :: (Metric v, OrderedField n) => [Point v n] -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: trailLike :: TrailLike t => Located (Trail (V t) (N t)) -> t
+ Knit.Report.Input.Visualization.Diagrams: trailLocSegments :: (Metric v, OrderedField n) => Located (Trail v n) -> [Located (Segment Closed v n)]
+ Knit.Report.Input.Visualization.Diagrams: trailMeasure :: (SegMeasure v n :>: m, Measured (SegMeasure v n) t) => a -> (m -> a) -> t -> a
+ Knit.Report.Input.Visualization.Diagrams: trailOffset :: (Metric v, OrderedField n) => Trail v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: trailOffsets :: (Metric v, OrderedField n) => Trail v n -> [v n]
+ Knit.Report.Input.Visualization.Diagrams: trailSegments :: (Metric v, OrderedField n) => Trail v n -> [Segment Closed v n]
+ Knit.Report.Input.Visualization.Diagrams: trailVertices :: (Metric v, OrderedField n) => Located (Trail v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: trailVertices' :: (Metric v, OrderedField n) => n -> Located (Trail v n) -> [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: transform :: Transformable t => Transformation (V t) (N t) -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: transformM :: (Monad m, Plated a) => (a -> m a) -> a -> m a
+ Knit.Report.Input.Visualization.Diagrams: transformMOf :: Monad m => LensLike (WrappedMonad m) a b a b -> (b -> m b) -> a -> m b
+ Knit.Report.Input.Visualization.Diagrams: transformMOn :: (Monad m, Plated a) => LensLike (WrappedMonad m) s t a a -> (a -> m a) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: transformMOnOf :: Monad m => LensLike (WrappedMonad m) s t a b -> LensLike (WrappedMonad m) a b a b -> (b -> m b) -> s -> m t
+ Knit.Report.Input.Visualization.Diagrams: transformOf :: () => ASetter a b a b -> (b -> b) -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: transformOn :: Plated a => ASetter s t a a -> (a -> a) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: transformOnOf :: () => ASetter s t a b -> ASetter a b a b -> (b -> b) -> s -> t
+ Knit.Report.Input.Visualization.Diagrams: transformed :: (InSpace v n a, SameSpace a b, Transformable a, Transformable b) => Transformation v n -> Iso a b a b
+ Knit.Report.Input.Visualization.Diagrams: transl :: () => Transformation v n -> v n
+ Knit.Report.Input.Visualization.Diagrams: translate :: Transformable t => Vn t -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: translateX :: (InSpace v n t, R1 v, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: translateY :: (InSpace v n t, R2 v, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: translateZ :: (InSpace v n t, R3 v, Transformable t) => n -> t -> t
+ Knit.Report.Input.Visualization.Diagrams: translated :: (InSpace v n a, SameSpace a b, Transformable a, Transformable b) => v n -> Iso a b a b
+ Knit.Report.Input.Visualization.Diagrams: translation :: () => v n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: translationX :: (Additive v, R1 v, Num n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: translationY :: (Additive v, R2 v, Num n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: translationZ :: (Additive v, R3 v, Num n) => n -> Transformation v n
+ Knit.Report.Input.Visualization.Diagrams: transp :: () => Transformation v n -> v n :-: v n
+ Knit.Report.Input.Visualization.Diagrams: transparent :: Num a => AlphaColour a
+ Knit.Report.Input.Visualization.Diagrams: transposeOf :: () => LensLike ZipList s t [a] a -> s -> [t]
+ Knit.Report.Input.Visualization.Diagrams: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: traverse1 :: (Traversable1 t, Apply f) => (a -> f b) -> t a -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
+ Knit.Report.Input.Visualization.Diagrams: traverseBy :: Traversable t => (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (a -> f b) -> t a -> f (t b)
+ Knit.Report.Input.Visualization.Diagrams: traverseByOf :: () => Traversal s t a b -> (forall x. () => x -> f x) -> (forall x y. () => f (x -> y) -> f x -> f y) -> (a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: traverseMax :: TraverseMax k m => IndexedTraversal' k (m v) v
+ Knit.Report.Input.Visualization.Diagrams: traverseMin :: TraverseMin k m => IndexedTraversal' k (m v) v
+ Knit.Report.Input.Visualization.Diagrams: traverseOf :: () => LensLike f s t a b -> (a -> f b) -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
+ Knit.Report.Input.Visualization.Diagrams: traversed :: Traversable f => IndexedTraversal Int (f a) (f b) a b
+ Knit.Report.Input.Visualization.Diagrams: traversed1 :: Traversable1 f => IndexedTraversal1 Int (f a) (f b) a b
+ Knit.Report.Input.Visualization.Diagrams: traversed64 :: Traversable f => IndexedTraversal Int64 (f a) (f b) a b
+ Knit.Report.Input.Visualization.Diagrams: tri :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: tri' :: RealFloat n => ArrowHT n
+ Knit.Report.Input.Visualization.Diagrams: triangle :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: trim :: Monoid a => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: trimAfter :: Monoid a => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: trimBefore :: Monoid a => Active a -> Active a
+ Knit.Report.Input.Visualization.Diagrams: turn :: Floating n => Iso' (Angle n) n
+ Knit.Report.Input.Visualization.Diagrams: turquoise :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: type ALens s t a b = LensLike Pretext ((->) :: Type -> Type -> Type) a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type ALens' s a = ALens s s a a
+ Knit.Report.Input.Visualization.Diagrams: type APrism s t a b = Market a b a Identity b -> Market a b s Identity t
+ Knit.Report.Input.Visualization.Diagrams: type APrism' s a = APrism s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AReview t b = Optic' (Tagged :: Type -> Type -> Type) Identity t b
+ Knit.Report.Input.Visualization.Diagrams: type ASetter s t a b = a -> Identity b -> s -> Identity t
+ Knit.Report.Input.Visualization.Diagrams: type ASetter' s a = ASetter s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ATraversal s t a b = LensLike Bazaar ((->) :: Type -> Type -> Type) a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type ATraversal' s a = ATraversal s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ATraversal1 s t a b = LensLike Bazaar1 ((->) :: Type -> Type -> Type) a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type ATraversal1' s a = ATraversal1 s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Accessing (p :: Type -> Type -> Type) m s a = p a Const m a -> s -> Const m s
+ Knit.Report.Input.Visualization.Diagrams: type AnEquality (s :: k1) (t :: k2) (a :: k1) (b :: k2) = Identical a Proxy b a Proxy b -> Identical a Proxy b s Proxy t
+ Knit.Report.Input.Visualization.Diagrams: type AnEquality' (s :: k2) (a :: k2) = AnEquality s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedLens i s t a b = Optical Indexed i ((->) :: Type -> Type -> Type) Pretext Indexed i a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedLens' i s a = AnIndexedLens i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedSetter i s t a b = Indexed i a Identity b -> s -> Identity t
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedSetter' i s a = AnIndexedSetter i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedTraversal i s t a b = Over Indexed i Bazaar Indexed i a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedTraversal' i s a = AnIndexedTraversal i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedTraversal1 i s t a b = Over Indexed i Bazaar1 Indexed i a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type AnIndexedTraversal1' i s a = AnIndexedTraversal1 i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type AnIso s t a b = Exchange a b a Identity b -> Exchange a b s Identity t
+ Knit.Report.Input.Visualization.Diagrams: type AnIso' s a = AnIso s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Animation b (v :: Type -> Type) n = QAnimation b v n Any
+ Knit.Report.Input.Visualization.Diagrams: type ArgMax a b = Max Arg a b
+ Knit.Report.Input.Visualization.Diagrams: type ArgMin a b = Min Arg a b
+ Knit.Report.Input.Visualization.Diagrams: type ArrowHT n = n -> n -> (Path V2 n, Path V2 n)
+ Knit.Report.Input.Visualization.Diagrams: type As (a :: k2) = Equality' a a
+ Knit.Report.Input.Visualization.Diagrams: type BSpline (v :: Type -> Type) n = [Point v n]
+ Knit.Report.Input.Visualization.Diagrams: type Bazaar' (p :: Type -> Type -> Type) a = Bazaar p a a
+ Knit.Report.Input.Visualization.Diagrams: type Bazaar1' (p :: Type -> Type -> Type) a = Bazaar1 p a a
+ Knit.Report.Input.Visualization.Diagrams: type ClassyNamer = Name -> Maybe (Name, Name)
+ Knit.Report.Input.Visualization.Diagrams: type Context' a = Context a a
+ Knit.Report.Input.Visualization.Diagrams: type D (v :: Type -> Type) n = QDiagram NullBackend v n Any
+ Knit.Report.Input.Visualization.Diagrams: type Diagram b = QDiagram b V b N b Any
+ Knit.Report.Input.Visualization.Diagrams: type Equality' (s :: k2) (a :: k2) = Equality s s a a
+ Knit.Report.Input.Visualization.Diagrams: type FieldNamer = Name -> [Name] -> Name -> [DefName]
+ Knit.Report.Input.Visualization.Diagrams: type Getting r s a = a -> Const r a -> s -> Const r s
+ Knit.Report.Input.Visualization.Diagrams: type HasBasis (v :: Type -> Type) = (Additive v, Representable v, Rep v ~ E v)
+ Knit.Report.Input.Visualization.Diagrams: type HasLinearMap (v :: Type -> Type) = (HasBasis v, Traversable v)
+ Knit.Report.Input.Visualization.Diagrams: type InSpace (v :: Type -> Type) n a = (V a ~ v, N a ~ n, Additive v, Num n)
+ Knit.Report.Input.Visualization.Diagrams: type IndexPreservingLens' s a = IndexPreservingLens s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexPreservingSetter' s a = IndexPreservingSetter s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexPreservingTraversal' s a = IndexPreservingTraversal s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexPreservingTraversal1' s a = IndexPreservingTraversal1 s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexedGetting i m s a = Indexed i a Const m a -> s -> Const m s
+ Knit.Report.Input.Visualization.Diagrams: type IndexedLens' i s a = IndexedLens i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexedLensLike' i (f :: Type -> Type) s a = IndexedLensLike i f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexedSetter' i s a = IndexedSetter i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexedTraversal' i s a = IndexedTraversal i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type IndexedTraversal1' i s a = IndexedTraversal1 i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Iso' s a = Iso s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Lens' s a = Lens s s a a
+ Knit.Report.Input.Visualization.Diagrams: type LensLike (f :: k -> Type) s (t :: k) a (b :: k) = a -> f b -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: type LensLike' (f :: Type -> Type) s a = LensLike f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Measure n = Measured n n
+ Knit.Report.Input.Visualization.Diagrams: type Monoid' = Monoid
+ Knit.Report.Input.Visualization.Diagrams: type Optic (p :: k1 -> k -> Type) (f :: k2 -> k) (s :: k1) (t :: k2) (a :: k1) (b :: k2) = p a f b -> p s f t
+ Knit.Report.Input.Visualization.Diagrams: type Review t b = forall (p :: Type -> Type -> Type) (f :: Type -> Type). (Choice p, Bifunctor p, Settable f) => Optic' p f t b
+ Knit.Report.Input.Visualization.Diagrams: type Optical (p :: k2 -> k -> Type) (q :: k1 -> k -> Type) (f :: k3 -> k) (s :: k1) (t :: k3) (a :: k2) (b :: k3) = p a f b -> q s f t
+ Knit.Report.Input.Visualization.Diagrams: type Optical' (p :: k1 -> k -> Type) (q :: k1 -> k -> Type) (f :: k1 -> k) (s :: k1) (a :: k1) = Optical p q f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type OrderedField s = (Floating s, Ord s)
+ Knit.Report.Input.Visualization.Diagrams: type Over (p :: k -> Type -> Type) (f :: k1 -> Type) s (t :: k1) (a :: k) (b :: k1) = p a f b -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: type Over' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Over p f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type P2 = Point V2
+ Knit.Report.Input.Visualization.Diagrams: type P3 = Point V3
+ Knit.Report.Input.Visualization.Diagrams: type Prism' s a = Prism s s a a
+ Knit.Report.Input.Visualization.Diagrams: type QAnimation b (v :: Type -> Type) n m = Active QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedIso' s a = ReifiedIso s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedLens' s a = ReifiedLens s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedPrism' s a = ReifiedPrism s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedSetter' s a = ReifiedSetter s s a a
+ Knit.Report.Input.Visualization.Diagrams: type ReifiedTraversal' s a = ReifiedTraversal s s a a
+ Knit.Report.Input.Visualization.Diagrams: type SameSpace a b = (V a ~ V b, N a ~ N b)
+ Knit.Report.Input.Visualization.Diagrams: type SegMeasure (v :: Type -> Type) n = SegCount ::: ArcLength n ::: OffsetEnvelope v n ::: ()
+ Knit.Report.Input.Visualization.Diagrams: type Setter' s a = Setter s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Setting (p :: Type -> Type -> Type) s t a b = p a Identity b -> s -> Identity t
+ Knit.Report.Input.Visualization.Diagrams: type Setting' (p :: Type -> Type -> Type) s a = Setting p s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Simple (f :: k -> k -> k1 -> k1 -> k2) (s :: k) (a :: k1) = f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type T2 = Transformation V2
+ Knit.Report.Input.Visualization.Diagrams: type T3 = Transformation V3
+ Knit.Report.Input.Visualization.Diagrams: type Traversal' s a = Traversal s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Traversal1' s a = Traversal1 s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Traversing (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p BazaarT p f a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type Traversing' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing p f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type Traversing1 (p :: Type -> Type -> Type) (f :: Type -> Type) s t a b = Over p BazaarT1 p f a b s t a b
+ Knit.Report.Input.Visualization.Diagrams: type Traversing1' (p :: Type -> Type -> Type) (f :: Type -> Type) s a = Traversing1 p f s s a a
+ Knit.Report.Input.Visualization.Diagrams: type TypeableFloat n = (Typeable n, RealFloat n)
+ Knit.Report.Input.Visualization.Diagrams: type Vn a = V a N a
+ Knit.Report.Input.Visualization.Diagrams: type Lens s t a b = forall (f :: Type -> Type). Functor f => a -> f b -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: type family Index s :: Type
+ Knit.Report.Input.Visualization.Diagrams: type IndexedLens i s t a b = forall (f :: Type -> Type) (p :: Type -> Type -> Type). (Indexable i p, Functor f) => p a f b -> s -> f t
+ Knit.Report.Input.Visualization.Diagrams: ui :: Fractional a => Active a
+ Knit.Report.Input.Visualization.Diagrams: ultraBold :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: ultraLight :: HasStyle a => a -> a
+ Knit.Report.Input.Visualization.Diagrams: ultraThick :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: ultraThin :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: un :: (Profunctor p, Bifunctor p, Functor f) => Getting a s a -> Optic' p f a s
+ Knit.Report.Input.Visualization.Diagrams: unP :: () => Point f a -> f a
+ Knit.Report.Input.Visualization.Diagrams: uncheckedImageRef :: Num n => FilePath -> Int -> Int -> DImage n External
+ Knit.Report.Input.Visualization.Diagrams: uncons :: Cons s s a a => s -> Maybe (a, s)
+ Knit.Report.Input.Visualization.Diagrams: uncurried :: () => Iso (a -> b -> c) (d -> e -> f) ((a, b) -> c) ((d, e) -> f)
+ Knit.Report.Input.Visualization.Diagrams: under :: () => AnIso s t a b -> (t -> s) -> b -> a
+ Knit.Report.Input.Visualization.Diagrams: underT :: (InSpace v n a, SameSpace a b, Transformable a, Transformable b) => (a -> b) -> Transformation v n -> a -> b
+ Knit.Report.Input.Visualization.Diagrams: underscoreFields :: LensRules
+ Knit.Report.Input.Visualization.Diagrams: underscoreNamer :: FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: underscoreNoPrefixNamer :: FieldNamer
+ Knit.Report.Input.Visualization.Diagrams: unfixTrail :: (Metric v, Ord n, Floating n) => [FixedSegment v n] -> Located (Trail v n)
+ Knit.Report.Input.Visualization.Diagrams: unfolded :: () => (b -> Maybe (a, b)) -> Fold b a
+ Knit.Report.Input.Visualization.Diagrams: union :: (CsgPrim a, CsgPrim b) => a n -> b n -> CSG n
+ Knit.Report.Input.Visualization.Diagrams: unit :: (Additive t, Num a) => ASetter' (t a) a -> t a
+ Knit.Report.Input.Visualization.Diagrams: unitCircle :: (TrailLike t, V t ~ V2, N t ~ n) => t
+ Knit.Report.Input.Visualization.Diagrams: unitSquare :: (InSpace V2 n t, TrailLike t) => t
+ Knit.Report.Input.Visualization.Diagrams: unitX :: (R1 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: unitY :: (R2 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: unitZ :: (R3 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: unit_X :: (R1 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: unit_Y :: (R2 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: unit_Z :: (R3 v, Additive v, Num n) => v n
+ Knit.Report.Input.Visualization.Diagrams: united :: () => Lens' a ()
+ Knit.Report.Input.Visualization.Diagrams: universe :: Plated a => a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: universeOf :: () => Getting [a] a a -> a -> [a]
+ Knit.Report.Input.Visualization.Diagrams: universeOn :: Plated a => Getting [a] s a -> s -> [a]
+ Knit.Report.Input.Visualization.Diagrams: universeOnOf :: () => Getting [a] s a -> Getting [a] a a -> s -> [a]
+ Knit.Report.Input.Visualization.Diagrams: unp2 :: () => P2 n -> (n, n)
+ Knit.Report.Input.Visualization.Diagrams: unp3 :: () => P3 n -> (n, n, n)
+ Knit.Report.Input.Visualization.Diagrams: unr2 :: () => V2 n -> (n, n)
+ Knit.Report.Input.Visualization.Diagrams: unr3 :: () => V3 n -> (n, n, n)
+ Knit.Report.Input.Visualization.Diagrams: unsafePartsOf :: Functor f => Traversing ((->) :: Type -> Type -> Type) f s t a b -> LensLike f s t [a] [b]
+ Knit.Report.Input.Visualization.Diagrams: unsafePartsOf' :: () => ATraversal s t a b -> Lens s t [a] [b]
+ Knit.Report.Input.Visualization.Diagrams: unsafeSingular :: (HasCallStack, Conjoined p, Functor f) => Traversing p f s t a b -> Over p f s t a b
+ Knit.Report.Input.Visualization.Diagrams: unsnoc :: Snoc s s a a => s -> Maybe (s, a)
+ Knit.Report.Input.Visualization.Diagrams: unto :: (Profunctor p, Bifunctor p, Functor f) => (b -> t) -> Optic p f s t a b
+ Knit.Report.Input.Visualization.Diagrams: use :: MonadState s m => Getting a s a -> m a
+ Knit.Report.Input.Visualization.Diagrams: uses :: MonadState s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: value :: Monoid m => m -> QDiagram b v n Any -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: vcat :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: vcat' :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => CatOpts n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: vertexNames :: () => Lens (StrokeOpts a) (StrokeOpts a') [[a]] [[a']]
+ Knit.Report.Input.Visualization.Diagrams: verticalFieldOfView :: () => Lens' (PerspectiveLens n) (Angle n)
+ Knit.Report.Input.Visualization.Diagrams: veryLarge :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: verySmall :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: veryThick :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: veryThin :: OrderedField n => Measure n
+ Knit.Report.Input.Visualization.Diagrams: view :: MonadReader s m => Getting a s a -> m a
+ Knit.Report.Input.Visualization.Diagrams: viewLoc :: () => Located a -> (Point (V a) (N a), a)
+ Knit.Report.Input.Visualization.Diagrams: views :: MonadReader s m => LensLike' (Const r :: Type -> Type) s a -> (a -> r) -> m r
+ Knit.Report.Input.Visualization.Diagrams: violet :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: vrule :: (InSpace V2 n t, TrailLike t) => n -> t
+ Knit.Report.Input.Visualization.Diagrams: vsep :: (InSpace V2 n a, Floating n, Juxtaposable a, HasOrigin a, Monoid' a) => n -> [a] -> a
+ Knit.Report.Input.Visualization.Diagrams: wedge :: (InSpace V2 n t, OrderedField n, TrailLike t) => n -> Direction V2 n -> Angle n -> t
+ Knit.Report.Input.Visualization.Diagrams: wheat :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: white :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: whitesmoke :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: width :: (InSpace V2 n a, Enveloped a) => a -> n
+ Knit.Report.Input.Visualization.Diagrams: with :: Default d => d
+ Knit.Report.Input.Visualization.Diagrams: withEnvelope :: (InSpace v n a, Monoid' m, Enveloped a) => a -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
+ Knit.Report.Input.Visualization.Diagrams: withIso :: () => AnIso s t a b -> ((s -> a) -> (b -> t) -> r) -> r
+ Knit.Report.Input.Visualization.Diagrams: withLine :: (Metric v, OrderedField n) => (Trail' Line v n -> r) -> Trail v n -> r
+ Knit.Report.Input.Visualization.Diagrams: withName :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> (Subdiagram b v n m -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: withNameAll :: (IsName nm, Metric v, Semigroup m, OrderedField n) => nm -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: withNames :: (IsName nm, Metric v, Semigroup m, OrderedField n) => [nm] -> ([Subdiagram b v n m] -> QDiagram b v n m -> QDiagram b v n m) -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: withOpacity :: Num a => Colour a -> a -> AlphaColour a
+ Knit.Report.Input.Visualization.Diagrams: withPrism :: () => APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
+ Knit.Report.Input.Visualization.Diagrams: withTrace :: (InSpace v n a, Metric v, OrderedField n, Monoid' m, Traced a) => a -> QDiagram b v n m -> QDiagram b v n m
+ Knit.Report.Input.Visualization.Diagrams: withTrail :: () => (Trail' Line v n -> r) -> (Trail' Loop v n -> r) -> Trail v n -> r
+ Knit.Report.Input.Visualization.Diagrams: withTrail' :: () => (Trail' Line v n -> r) -> (Trail' Loop v n -> r) -> Trail' l v n -> r
+ Knit.Report.Input.Visualization.Diagrams: without :: () => APrism s t a b -> APrism u v c d -> Prism (Either s u) (Either t v) (Either a c) (Either b d)
+ Knit.Report.Input.Visualization.Diagrams: worded :: Applicative f => IndexedLensLike' Int f String String
+ Knit.Report.Input.Visualization.Diagrams: wrapLine :: () => Trail' Line v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: wrapLoop :: () => Trail' Loop v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: wrapTrail :: () => Trail' l v n -> Trail v n
+ Knit.Report.Input.Visualization.Diagrams: xDir :: (R1 v, Additive v, Num n) => Direction v n
+ Knit.Report.Input.Visualization.Diagrams: yDir :: (R2 v, Additive v, Num n) => Direction v n
+ Knit.Report.Input.Visualization.Diagrams: yellow :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: yellowgreen :: (Ord a, Floating a) => Colour a
+ Knit.Report.Input.Visualization.Diagrams: zDir :: (R3 v, Additive v, Num n) => Direction v n
+ Knit.Report.Input.Visualization.Diagrams: zero :: (Additive f, Num a) => f a
+ Knit.Report.Input.Visualization.Diagrams: zoom :: Zoom m n s t => LensLike' (Zoomed m c) t s -> m c -> n c
+ Knit.Report.Input.Visualization.Diagrams: }
- Knit.Effect.PandocMonad: fileExists :: forall r_at8f. Member Pandoc r_at8f => FilePath -> Sem r_at8f Bool
+ Knit.Effect.PandocMonad: fileExists :: forall r_auQj. Member Pandoc r_auQj => FilePath -> Sem r_auQj Bool
- Knit.Effect.PandocMonad: getCommonState :: forall r_at8i. Member Pandoc r_at8i => Sem r_at8i CommonState
+ Knit.Effect.PandocMonad: getCommonState :: forall r_auQm. Member Pandoc r_auQm => Sem r_auQm CommonState
- Knit.Effect.PandocMonad: getCurrentTime :: forall r_at87. Member Pandoc r_at87 => Sem r_at87 UTCTime
+ Knit.Effect.PandocMonad: getCurrentTime :: forall r_auQb. Member Pandoc r_auQb => Sem r_auQb UTCTime
- Knit.Effect.PandocMonad: getCurrentTimeZone :: forall r_at88. Member Pandoc r_at88 => Sem r_at88 TimeZone
+ Knit.Effect.PandocMonad: getCurrentTimeZone :: forall r_auQc. Member Pandoc r_auQc => Sem r_auQc TimeZone
- Knit.Effect.PandocMonad: getDataFileName :: forall r_at8g. Member Pandoc r_at8g => FilePath -> Sem r_at8g FilePath
+ Knit.Effect.PandocMonad: getDataFileName :: forall r_auQk. Member Pandoc r_auQk => FilePath -> Sem r_auQk FilePath
- Knit.Effect.PandocMonad: getModificationTime :: forall r_at8h. Member Pandoc r_at8h => FilePath -> Sem r_at8h UTCTime
+ Knit.Effect.PandocMonad: getModificationTime :: forall r_auQl. Member Pandoc r_auQl => FilePath -> Sem r_auQl UTCTime
- Knit.Effect.PandocMonad: getsCommonState :: forall a_asNV. forall r_at8k. Member Pandoc r_at8k => (CommonState -> a_asNV) -> Sem r_at8k a_asNV
+ Knit.Effect.PandocMonad: getsCommonState :: forall a_auvZ. forall r_auQo. Member Pandoc r_auQo => (CommonState -> a_auvZ) -> Sem r_auQo a_auvZ
- Knit.Effect.PandocMonad: glob :: forall r_at8e. Member Pandoc r_at8e => String -> Sem r_at8e [FilePath]
+ Knit.Effect.PandocMonad: glob :: forall r_auQi. Member Pandoc r_auQi => String -> Sem r_auQi [FilePath]
- Knit.Effect.PandocMonad: logOutput :: forall r_at8m. Member Pandoc r_at8m => LogMessage -> Sem r_at8m ()
+ Knit.Effect.PandocMonad: logOutput :: forall r_auQq. Member Pandoc r_auQq => LogMessage -> Sem r_auQq ()
- Knit.Effect.PandocMonad: lookupEnv :: forall r_at86. Member Pandoc r_at86 => String -> Sem r_at86 (Maybe String)
+ Knit.Effect.PandocMonad: lookupEnv :: forall r_auQa. Member Pandoc r_auQa => String -> Sem r_auQa (Maybe String)
- Knit.Effect.PandocMonad: modifyCommonState :: forall r_at8l. Member Pandoc r_at8l => (CommonState -> CommonState) -> Sem r_at8l ()
+ Knit.Effect.PandocMonad: modifyCommonState :: forall r_auQp. Member Pandoc r_auQp => (CommonState -> CommonState) -> Sem r_auQp ()
- Knit.Effect.PandocMonad: newStdGen :: forall r_at89. Member Pandoc r_at89 => Sem r_at89 StdGen
+ Knit.Effect.PandocMonad: newStdGen :: forall r_auQd. Member Pandoc r_auQd => Sem r_auQd StdGen
- Knit.Effect.PandocMonad: newUniqueHash :: forall r_at8a. Member Pandoc r_at8a => Sem r_at8a Int
+ Knit.Effect.PandocMonad: newUniqueHash :: forall r_auQe. Member Pandoc r_auQe => Sem r_auQe Int
- Knit.Effect.PandocMonad: openURL :: forall r_at8b. Member Pandoc r_at8b => String -> Sem r_at8b (ByteString, Maybe MimeType)
+ Knit.Effect.PandocMonad: openURL :: forall r_auQf. Member Pandoc r_auQf => String -> Sem r_auQf (ByteString, Maybe MimeType)
- Knit.Effect.PandocMonad: putCommonState :: forall r_at8j. Member Pandoc r_at8j => CommonState -> Sem r_at8j ()
+ Knit.Effect.PandocMonad: putCommonState :: forall r_auQn. Member Pandoc r_auQn => CommonState -> Sem r_auQn ()
- Knit.Effect.PandocMonad: readFileLazy :: forall r_at8c. Member Pandoc r_at8c => FilePath -> Sem r_at8c ByteString
+ Knit.Effect.PandocMonad: readFileLazy :: forall r_auQg. Member Pandoc r_auQg => FilePath -> Sem r_auQg ByteString
- Knit.Effect.PandocMonad: readFileStrict :: forall r_at8d. Member Pandoc r_at8d => FilePath -> Sem r_at8d ByteString
+ Knit.Effect.PandocMonad: readFileStrict :: forall r_auQh. Member Pandoc r_auQh => FilePath -> Sem r_auQh ByteString
- Knit.Effect.PandocMonad: trace :: forall r_at8n. Member Pandoc r_at8n => String -> Sem r_at8n ()
+ Knit.Effect.PandocMonad: trace :: forall r_auQr. Member Pandoc r_auQr => String -> Sem r_auQr ()
- Knit.Report: addHvega :: (PandocEffects effs, Member ToPandoc effs) => Text -> VegaLite -> Sem effs ()
+ Knit.Report: addHvega :: (PandocEffects effs, Member ToPandoc effs, Member UnusedId effs) => Maybe Text -> Maybe Text -> VegaLite -> Sem effs Text
- Knit.Report.Input.Visualization.Hvega: addHvega :: (PandocEffects effs, Member ToPandoc effs) => Text -> VegaLite -> Sem effs ()
+ Knit.Report.Input.Visualization.Hvega: addHvega :: (PandocEffects effs, Member ToPandoc effs, Member UnusedId effs) => Maybe Text -> Maybe Text -> VegaLite -> Sem effs Text

Files

ChangeLog.md view
@@ -1,5 +1,16 @@-v 0.1.0.0  -* Initial version+v 0.3.0.0 +* Added exports of "Colonnade" and "Text.Blaze.Colonnade" to "Knit.Report.Input.Table.Colonnade"+* Added "knitError" function to Knit.Report to allow user throwing of errors.  These will become PandocSomeError and handled as a PandocError.+* Lowered bound on containers (to 0.5.0) to accomodate use of Plots.+* Added Knit.Report.Input.Visualization.Diagrams.  Adds Diagrams from diagrams-lib via SVG backend.+* Added some more re-exports (Colonnade, Diagrams.Prelude) from Knit.Report to simplify imports on use.+* Added an optional figure caption argument to Hvega and Diagrams inputs. (this is a breaking change since it requires another argument).+* Added a state effect wrapper to facilitate getting unused ids for figures, etc.+* Changed id argument for Hvega and Diagrams visualizations to "Maybe Text" from Text.  Will use built-in facilities for unique ids when set to Nothing.+* Visualization "addXXX" functions now return the figure id (as "Sem r Text") so it can be referred to elsewhere.+* Added KnitOne and KnitMany constraint-type-aliases to Knit.Report to simplify constraining doc producing functions.+* Updated examples.  Added a diagrams example to SimpleExample and fixed id and caption arguments throughout.+* Bumped upper bounds (network)  v 0.2.0.0 * Documentation Fixes@@ -8,3 +19,7 @@ * Added a multi-doc example * (internal) Removed odd, and no longer necessary, "LastMember" constraint from knit functions.  * Updated effects for polysemy 1.2++v 0.1.0.0  +* Initial version+
+ examples/ErrorExample.hs view
@@ -0,0 +1,67 @@+{-# LANGUAGE QuasiQuotes       #-}+{-# LANGUAGE FlexibleContexts  #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TypeApplications  #-}+{-# LANGUAGE GADTs             #-}+module Main where++import qualified Knit.Report as K    ++import qualified Data.Map                      as M+import qualified Data.Text.IO                  as T+import qualified Data.Text.Lazy                as TL+import qualified Data.Text                as T+import           Data.String.Here (here)+import qualified Graphics.Vega.VegaLite        as V++templateVars :: M.Map String String+templateVars = M.fromList+  [ ("lang"     , "English")+  , ("author"   , "Adam Conner-Sax")+  , ("pagetitle", "knit-haskell simple example")+--  , ("tufte","True")+  ]++main :: IO ()+main = do+  let pandocWriterConfig = K.PandocWriterConfig (Just "pandoc-templates/minWithVega-pandoc.html")  templateVars K.mindocOptionsF+  resSimpleE <- K.knitHtml (Just "SimpleExample.Main") K.logAll pandocWriterConfig makeDocWithKnitError+  case resSimpleE of+    Right htmlAsText ->+      T.writeFile "examples/html/example_simple.html"+        $ TL.toStrict+        $ htmlAsText+    Left err -> putStrLn $ "Pandoc Error: " ++ show err+    +md1 :: T.Text+md1 = [here|+## Some example markdown+* [Markdown][MarkdownLink] is a nice way to write formatted notes with a minimum of code.+* It supports links and tables and some *styling* information.++[MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown>+|]++makeDocWithKnitError :: K.KnitOne effs => K.Sem effs ()+makeDocWithKnitError = K.wrapPrefix "makeDocWithKnitError" $ do+  K.logLE K.Info "adding some markdown..."+  K.addMarkDown md1+  K.logLE K.Info "adding some latex..."+  K.addMarkDown "## Some example latex"+  K.addLatex "Overused favorite equation: $e^{i\\pi} + 1 = 0$"+  K.logLE K.Info "adding a visualization..."+  K.knitError "Uh oh!  Something went wrong which I am explaining with this message."+  K.addMarkDown "## An example hvega visualization"+  _ <- K.addHvega Nothing Nothing exampleVis+  return ()+++exampleVis :: V.VegaLite+exampleVis =+  let cars =  V.dataFromUrl "https://vega.github.io/vega-datasets/data/cars.json" []+      enc = V.encoding+        . V.position V.X [ V.PName "Horsepower", V.PmType V.Quantitative ]+        . V.position V.Y [ V.PName "Miles_per_Gallon", V.PmType V.Quantitative ]+        . V.color [ V.MName "Origin", V.MmType V.Nominal ]+      bkg = V.background "rgba(0, 0, 0, 0.05)"+  in V.toVegaLite [ bkg, cars, V.mark V.Circle [], enc [] ]  
examples/MtlExample.hs view
@@ -59,8 +59,7 @@ [MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown> |] -makeDoc :: (K.Member K.ToPandoc effs-           , K.PandocEffects effs+makeDoc :: ( K.KnitOne effs            , K.KnitBase ExampleApp effs) => K.Sem effs () makeDoc = K.wrapPrefix "makeDoc" $ do   K.logLE K.Info "adding some markdown..."@@ -72,7 +71,7 @@    K.logLE K.Info "adding a visualization..."   K.addMarkDown "## An example hvega visualization"-  K.addHvega "someID" exampleVis+  _ <- K.addHvega Nothing Nothing exampleVis    K.logLE K.Info "Retrieving some text from the base monad and current date-time."   envText <- K.liftKnit @ExampleApp getEnv
examples/MultiDocExample.hs view
@@ -43,10 +43,7 @@ [MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown> |] -makeDoc1 :: (K.Member K.ToPandoc effs -- required for the single-document variant-           , K.PandocEffects effs -- all effects for knitting-           ) -        => K.Sem effs ()+makeDoc1 :: K.KnitOne effs => K.Sem effs () makeDoc1 = K.wrapPrefix "makeDoc1" $ do   K.logLE K.Info "adding some markdown."   K.addMarkDown md1@@ -55,7 +52,8 @@   K.addLatex "Overused favorite equation: $e^{i\\pi} + 1 = 0$"   K.logLE K.Info "adding a visualization."   K.addMarkDown "## An example hvega visualization (Doc 1)"-  K.addHvega "someID" exampleVis+  _ <- K.addHvega Nothing Nothing exampleVis+  return ()  md2 :: T.Text md2 = [here|@@ -66,10 +64,7 @@ [MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown> |] -makeDoc2 :: (K.Member K.ToPandoc effs -- required for the single-document variant-           , K.PandocEffects effs -- all effects for knitting-           ) -        => K.Sem effs ()+makeDoc2 :: K.KnitOne effs => K.Sem effs () makeDoc2 = K.wrapPrefix "makeDoc2" $ do   K.logLE K.Info "adding some markdown."   K.addMarkDown md2@@ -78,7 +73,8 @@   K.addLatex "A different equation: $a^2 + b^2 = c^2$"   K.logLE K.Info "adding a visualization."   K.addMarkDown "## An example hvega visualization (Doc 2)"-  K.addHvega "someID" exampleVis  +  _ <- K.addHvega Nothing Nothing exampleVis+  return ()  exampleVis :: V.VegaLite exampleVis =@@ -89,3 +85,4 @@         . V.color [ V.MName "Origin", V.MmType V.Nominal ]       bkg = V.background "rgba(0, 0, 0, 0.05)"   in V.toVegaLite [ bkg, cars, V.mark V.Circle [], enc [] ]  +
examples/RandomExample.hs view
@@ -66,8 +66,7 @@ [MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown> |] -makeDoc :: (K.Member K.ToPandoc effs-           , K.PandocEffects effs+makeDoc :: ( K.KnitOne effs            , K.Member KR.Random effs -- this one needs to be handled before knitting            , K.KnitBase ExampleApp effs) => K.Sem effs () makeDoc = K.wrapPrefix "makeDoc" $ do@@ -80,7 +79,7 @@    K.logLE K.Info "adding a visualization..."   K.addMarkDown "## An example hvega visualization"-  K.addHvega "someID" exampleVis+  _ <- K.addHvega Nothing Nothing exampleVis    K.logLE K.Info "Retrieving some text from the base monad and current date-time."   envText <- K.liftKnit @ExampleApp getEnv
examples/SimpleExample.hs view
@@ -5,15 +5,17 @@ {-# LANGUAGE GADTs             #-} module Main where -import qualified Knit.Report as K    +import qualified Knit.Report              as K     -import qualified Data.Map                      as M-import qualified Data.Text.IO                  as T-import qualified Data.Text.Lazy                as TL+import qualified Data.Map                 as M+import qualified Data.Text.IO             as T+import qualified Data.Text.Lazy           as TL import qualified Data.Text                as T-import           Data.String.Here (here)-import qualified Graphics.Vega.VegaLite        as V+import           Data.String.Here          (here)+import qualified Graphics.Vega.VegaLite   as V +import qualified Plots                    as P+ templateVars :: M.Map String String templateVars = M.fromList   [ ("lang"     , "English")@@ -42,10 +44,7 @@ [MarkDownLink]:<https://pandoc.org/MANUAL.html#pandocs-markdown> |] -makeDoc :: (K.Member K.ToPandoc effs -- required for the single-document variant-           , K.PandocEffects effs -- all effects for knitting-           ) -        => K.Sem effs ()+makeDoc :: K.KnitOne effs => K.Sem effs () makeDoc = K.wrapPrefix "makeDoc" $ do   K.logLE K.Info "adding some markdown..."   K.addMarkDown md1@@ -54,8 +53,13 @@   K.addLatex "Overused favorite equation: $e^{i\\pi} + 1 = 0$"   K.logLE K.Info "adding a visualization..."   K.addMarkDown "## An example hvega visualization"-  K.addHvega "someID" exampleVis+  _ <- K.addHvega Nothing (Just "From the cars data-set") exampleVis+  K.addMarkDown "## An example Diagrams visualization"+  K.logLE K.Info "adding a Diagrams plot..."  +  _ <- K.addDiagramAsSVG Nothing (Just "Example diagrams visualization using the Plots library") 300 300 samplePlot+  return () +-- example using HVega   exampleVis :: V.VegaLite exampleVis =   let cars =  V.dataFromUrl "https://vega.github.io/vega-datasets/data/cars.json" []@@ -65,3 +69,22 @@         . V.color [ V.MName "Origin", V.MmType V.Nominal ]       bkg = V.background "rgba(0, 0, 0, 0.05)"   in V.toVegaLite [ bkg, cars, V.mark V.Circle [], enc [] ]  +++-- example using Plots (as an example of using Diagrams)+samplePlot :: K.Diagram K.SVG+samplePlot = P.renderAxis logAxis++logData = [K.V2 1 10, K.V2 2 100, K.V2 2.5 316, K.V2 3 1000]++logAxis :: P.Axis K.SVG K.V2 Double+logAxis = P.r2Axis K.&~ do+  P.scatterPlot' logData+  -- yMin ?= 200++  P.yAxis P.&= do+    P.logScale K..= P.LogAxis+    P.majorTicksFunction K..= P.logMajorTicks 5 -- <> pure [1]+    -- minorTicksFunction .= minorTicksHelper 5++--exampleDiagram :: 
knit-haskell.cabal view
@@ -1,7 +1,7 @@ cabal-version:       2.2  name:                knit-haskell-version:             0.2.0.0+version:             0.3.0.0 synopsis:            a minimal Rmarkdown sort-of-thing for haskell, by way of Pandoc description:         knit-haskell is a beginning attempt at bringing some of the benefits of                      Rmarkdown to Haskell.@@ -42,6 +42,7 @@                  , Knit.Effect.RandomFu                  , Knit.Effect.PandocMonad                  , Knit.Effect.Pandoc+                 , Knit.Effect.UnusedId                  , Knit.Report.Input.Table.Colonnade                  , Knit.Report.Input.Html                  , Knit.Report.Input.Html.Lucid@@ -49,6 +50,7 @@                  , Knit.Report.Input.Latex                  , Knit.Report.Input.MarkDown.PandocMarkDown                  , Knit.Report.Input.Visualization.Hvega+                 , Knit.Report.Input.Visualization.Diagrams                  , Knit.Report.Output                  , Knit.Report.Output.Html                  , Knit.Report@@ -62,13 +64,15 @@                     bytestring                        >= 0.10.8 && < 0.11,                     case-insensitive                  >= 1.2.0.11 && < 1.3.0.0,                     colonnade                         >= 1.1 && < 1.3,-                    containers                        >= 0.6.0 && < 0.7,+                    containers                        >= 0.5.0 && < 0.7,                     directory                         >= 1.3.3.0 && < 1.4.0.0,+                    diagrams-lib                      >= 1.4 && < 1.5.0.0,+                    diagrams-svg                      >= 1.4.1 && < 1.5.0.0,                     Glob                              >= 0.10.0 && < 0.11.0,                     http-client                       >= 0.6.4 && < 0.7.0,                     http-client-tls                   >= 0.3.5.3 && < 0.4.0.0,                     http-types                        >= 0.12.3 && < 0.13.0,-                    network                           >= 2.8.0.0 && < 3.1.0.0,+                    network                           >= 2.8.0.0 && < 3.2.0.0,                     network-uri                       >= 2.6.1.0 && < 2.7.0.0,                     text                              >= 1.2.3 && < 1.3,                     time                              >= 1.8.0 && < 2.0.0,@@ -83,6 +87,7 @@                     pandoc                            >= 2.7.2 && < 2.8,                     random-fu                         >= 0.2.7 && < 0.3,                     random-source                     >= 0.3.0 && < 0.4,+                    svg-builder                       >= 0.1.1 && < 0.2    hs-source-dirs:      src   default-language:    Haskell2010@@ -90,6 +95,21 @@  executable SimpleExample     main-is: SimpleExample.hs+    hs-source-dirs: examples+    ghc-options: -Wall +    build-depends: base,+                   blaze-html,+                   containers,+                   here                              >= 1.2.10 && < 1.3.0,+                   hvega,     +                   knit-haskell                      -any,+                   plots,+                   polysemy,  +                   text      +    default-language: Haskell2010++executable ErrorExample+    main-is: ErrorExample.hs     hs-source-dirs: examples     ghc-options: -Wall      build-depends: base,
src/Knit/Effect/Pandoc.hs view
@@ -5,9 +5,9 @@ {-# LANGUAGE PolyKinds           #-} {-# LANGUAGE TypeOperators       #-} {-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE StandaloneDeriving #-}-{-# LANGUAGE TypeApplications #-}-{-# LANGUAGE LambdaCase  #-}+{-# LANGUAGE StandaloneDeriving  #-}+{-# LANGUAGE TypeApplications    #-}+{-# LANGUAGE LambdaCase          #-} {-# OPTIONS_GHC -fwarn-incomplete-patterns #-} {-| Module      : Knit.Effect.Pandoc
+ src/Knit/Effect/UnusedId.hs view
@@ -0,0 +1,55 @@+{-# LANGUAGE FlexibleContexts              #-}+{-# LANGUAGE OverloadedStrings             #-}+{-# LANGUAGE DataKinds                     #-}+{-# LANGUAGE PolyKinds                     #-}+{-# LANGUAGE GADTs                         #-}+{-# LANGUAGE TypeOperators                 #-}+{-# LANGUAGE ScopedTypeVariables           #-}+{-# LANGUAGE TypeApplications              #-}+{-# OPTIONS_GHC -fwarn-incomplete-patterns #-}+{-|+Module      : Knit.Effect.UnusedId+Description : Wrapper around Polysemy.State for generating unused ids with a given prefix+Copyright   : (c) Adam Conner-Sax 2019+License     : BSD-3-Clause+Maintainer  : adam_conner_sax@yahoo.com+Stability   : experimental++-}+module Knit.Effect.UnusedId+  (+    -- * Effect+    UnusedId++    -- * actions    +  , getNextUnusedId++    -- * interpretations+  , runUnusedId+  )+where++import qualified Polysemy                      as P+import qualified Polysemy.State                as PS++import qualified Data.Map                      as M+import qualified Data.Text                     as T+import           Data.Maybe                     ( fromMaybe )++-- | Type alias for the dictionary ('M.Map') of current last used id at each prefix.+type IdMap = M.Map T.Text Int++-- | Type alias for 'Polysemy.State' using "IdMap".+type UnusedId = PS.State IdMap++-- | Get an unused id with prefix as specified.  Useful for figures, etc.+getNextUnusedId :: P.Member UnusedId r => T.Text -> P.Sem r T.Text+getNextUnusedId prefixT = do+  idMap <- PS.get @IdMap+  let nextId = fromMaybe 1 $ M.lookup prefixT idMap+  PS.put $ M.insert prefixT (nextId + 1) idMap+  return $ prefixT <> "_" <> (T.pack $ show nextId)++-- | Run the UnusedId effect and throw away the state.+runUnusedId :: P.Sem (UnusedId ': r) a -> P.Sem r a+runUnusedId = fmap snd . PS.runState M.empty
src/Knit/Report.hs view
@@ -40,6 +40,10 @@     knitHtml   , knitHtmls   , liftKnit+  , knitError+  , KnitEffects+  , KnitOne+  , KnitMany   , KnitBase      -- * Inputs@@ -50,6 +54,7 @@   , module Knit.Report.Input.Html.Lucid   , module Knit.Report.Input.Latex   , module Knit.Report.Input.Visualization.Hvega+  , module Knit.Report.Input.Visualization.Diagrams      -- * Output    , module Knit.Report.Output@@ -61,6 +66,7 @@   , module Knit.Effect.Docs   , module Knit.Effect.PandocMonad   , module Knit.Effect.Logger+  , module Knit.Effect.UnusedId   ) where @@ -86,10 +92,6 @@                                                 , LogWithPrefixesLE                                                 ) import           Knit.Report.Input.Table.Colonnade-                                                ( addColonnadeTextTable-                                                , addColonnadeHtmlTable-                                                , addColonnadeCellTable-                                                ) import           Knit.Report.Input.MarkDown.PandocMarkDown                                                 ( addMarkDown ) import           Knit.Report.Input.Html         ( addStrictTextHtml@@ -100,6 +102,8 @@ import           Knit.Report.Input.Latex        ( addLatex ) import           Knit.Report.Input.Visualization.Hvega                                                 ( addHvega )+import           Knit.Report.Input.Visualization.Diagrams+--                                         hiding ( trace ) -- trace conflicts with Pandoc.trace  import           Knit.Report.Output             ( PandocWriterConfig(..) ) import           Knit.Report.Output.Html        ( pandocWriterToBlazeDocument@@ -125,7 +129,8 @@ import qualified Knit.Effect.Pandoc            as KP import qualified Knit.Effect.PandocMonad       as KPM import qualified Knit.Effect.Logger            as KLog-+import qualified Knit.Effect.UnusedId          as KUI+import           Knit.Effect.UnusedId           ( getNextUnusedId )   -- | Create multiple HTML docs (as Text) from the named sets of pandoc fragments.@@ -165,11 +170,27 @@ liftKnit :: Member (Lift m) r => m a -> Sem r a liftKnit = P.sendM --- From here down is unexported.  +-- | Throw an error with a specific message.  This will emerge as a 'PandocSomeError' in order+-- to avoid complicating the error type.+-- NB: The Member constraint is satisfied by KnitEffectStack m.+knitError :: P.Member (PE.Error PA.PandocError) r => T.Text -> P.Sem r ()+knitError msg =+  PE.throw (PA.PandocSomeError $ "Knit User Error: " ++ T.unpack msg) +-- | Constraint alias for the effects we need when calling Knit+type KnitEffects r = (KPM.PandocEffects r, P.Member KUI.UnusedId r)++-- | Constraint alias for the effects we need to knit one document+type KnitOne r = (KnitEffects r, P.Member KP.ToPandoc r)++-- | Constraint alias for the effects we need to knit multiple documents.+type KnitMany r = (KnitEffects r, P.Member (KD.Docs KP.PandocWithRequirements) r)++-- From here down is unexported.   -- | The exact stack we are interpreting when we knit type KnitEffectStack m =-  '[ KPM.Pandoc+  '[ KUI.UnusedId+   , KPM.Pandoc    , KLog.Logger KLog.LogEntry    , KLog.PrefixLog    , PE.Error PA.PandocError@@ -196,5 +217,6 @@     . PE.runError     . KLog.filteredLogEntriesToIO ls     . KPM.interpretInIO -- PA.PandocIO+    . KUI.runUnusedId     . maybe id KLog.wrapPrefix loggingPrefixM 
src/Knit/Report/Input/Table/Colonnade.hs view
@@ -23,12 +23,17 @@     addColonnadeTextTable   , addColonnadeHtmlTable   , addColonnadeCellTable+  -- * Re-exports+  , module Colonnade+  , module Text.Blaze.Colonnade   ) where   import qualified Colonnade                     as C+import           Colonnade import qualified Text.Blaze.Colonnade          as BC+import           Text.Blaze.Colonnade import qualified Text.Blaze.Html               as BH import qualified Text.Blaze.Html5.Attributes   as BHA import           Knit.Report.Input.Html.Blaze   ( addBlaze )
+ src/Knit/Report/Input/Visualization/Diagrams.hs view
@@ -0,0 +1,85 @@+{-# LANGUAGE ExtendedDefaultRules #-}+{-# LANGUAGE OverloadedStrings    #-}+{-# LANGUAGE ScopedTypeVariables  #-}+{-# LANGUAGE FlexibleContexts     #-}+{-# LANGUAGE TypeOperators        #-}+{-# LANGUAGE DataKinds            #-}+{-# LANGUAGE GADTs                #-}+{-|+Module      : Knit.Report.Input.Visualization.Diagrams+Description : Support addition of Diagrams to knitted reports.+Copyright   : (c) Adam Conner-Sax 2019+License     : BSD-3-Clause+Maintainer  : adam_conner_sax@yahoo.com+Stability   : experimental++Functions to Diagrams (from the Diagrams library) to the current Pandoc document.+-}+module Knit.Report.Input.Visualization.Diagrams+  (+    -- * Add Diagrams Inputs+    addDiagramAsSVG+    -- * re-exports+  , module Diagrams.Prelude+  , module Diagrams.Backend.SVG+  )+where++import           Knit.Report.Input.Html.Blaze   ( addBlaze )+import           Text.Blaze.Html                ( preEscapedLazyText+                                                , toValue+                                                )+import qualified Text.Blaze.Html5              as BH+import qualified Text.Blaze.Html5.Attributes   as BHA++import qualified Data.Text                     as T+--import           Data.Maybe                     ( fromMaybe )++import qualified Diagrams.Prelude              as D+import           Diagrams.Prelude        hiding ( trace ) -- this conflicts with Pandoc trace.  TO get it, you'll need to import it directly+--import qualified Diagrams.TwoD.Size            as D+import qualified Diagrams.Backend.SVG          as DSVG+import           Diagrams.Backend.SVG+import qualified Graphics.Svg                  as SVG++import qualified Polysemy                      as P+import qualified Knit.Effect.Pandoc            as PE+import qualified Knit.Effect.PandocMonad       as PM+import qualified Knit.Effect.UnusedId          as KUI++-- | Add diagram (via svg inserted as html).+addDiagramAsSVG+  :: ( PM.PandocEffects effs+     , P.Member PE.ToPandoc effs+     , P.Member KUI.UnusedId effs+     )+  => Maybe T.Text -- ^ id attribute for figure.  Will use next unused "figure" id if Nothing+  -> Maybe T.Text -- ^ caption for figure+  -> Double -- ^ width in pixels (?)+  -> Double -- ^ height in pixels (?)+  -> D.QDiagram DSVG.SVG D.V2 Double D.Any-- ^ diagram+  -> P.Sem effs T.Text+addDiagramAsSVG idTextM captionTextM wPixels hPixels diagram = do+  idText <- maybe (KUI.getNextUnusedId "figure") return idTextM+  let svgOptions =+        DSVG.SVGOptions (D.dims2D wPixels hPixels) Nothing idText [] False+  addDiagramAsSVGWithOptions (Just idText) captionTextM svgOptions diagram++addDiagramAsSVGWithOptions+  :: ( PM.PandocEffects effs+     , P.Member PE.ToPandoc effs+     , P.Member KUI.UnusedId effs+     )+  => Maybe T.Text -- ^ id attribute for figure, will use next unsed "figure" id if nothing+  -> Maybe T.Text -- ^ caption for figure+  -> DSVG.Options DSVG.SVG D.V2 Double+  -> D.QDiagram DSVG.SVG D.V2 Double D.Any-- ^ diagram+  -> P.Sem effs T.Text+addDiagramAsSVGWithOptions idTextM captionTextM svgOptions diagram = do+  idText <- maybe (KUI.getNextUnusedId "figure") return idTextM+  addBlaze $ BH.figure BH.! BHA.id (toValue idText) $ do+    preEscapedLazyText $ SVG.renderText $ D.renderDia DSVG.SVG+                                                      svgOptions+                                                      diagram+    maybe (return ()) (BH.figcaption . BH.toHtml) captionTextM+  return idText
src/Knit/Report/Input/Visualization/Hvega.hs view
@@ -35,24 +35,30 @@ import qualified Polysemy                      as P import qualified Knit.Effect.Pandoc            as PE import qualified Knit.Effect.PandocMonad       as PM+import qualified Knit.Effect.UnusedId          as KUI   -- TODO: Add some autogenerated unique id support  -- | Add hvega (via html). Requires html since vega-lite renders using javascript. addHvega-  :: (PM.PandocEffects effs, P.Member PE.ToPandoc effs)-  => T.Text+  :: ( PM.PandocEffects effs+     , P.Member PE.ToPandoc effs+     , P.Member KUI.UnusedId effs+     )+  => Maybe T.Text -- ^ figure id, will get next unused with prefix "figure" if Nothing+  -> Maybe T.Text -- ^ figure caption, none if Nothing   -> GV.VegaLite-  -> P.Sem effs ()-addHvega vizId vl = do+  -> P.Sem effs T.Text+addHvega idTextM captionTextM vl = do   PE.require PE.VegaSupport-  addBlaze $ placeVisualization vizId vl-+  idText <- maybe (KUI.getNextUnusedId "figure") return idTextM+  addBlaze $ placeVisualization idText captionTextM vl+  return idText  -- | Build (Blaze) Html for  hvega visualization with the given id-placeVisualization :: T.Text -> GV.VegaLite -> BH.Html-placeVisualization idText vl =+placeVisualization :: T.Text -> Maybe T.Text -> GV.VegaLite -> BH.Html+placeVisualization idText captionTextM vl =   let vegaScript :: T.Text =         T.decodeUtf8 $ BS.toStrict $ A.encodePretty $ GV.fromVL vl       script =@@ -62,12 +68,9 @@           <> "vegaEmbed(\'#"           <> idText           <> "\',vlSpec);"-  in  BH.figure-      BH.! BHA.id (BH.toValue idText)-      $    BH.script-      BH.! BHA.type_ "text/javascript"-      $    BH.preEscapedToHtml script-+  in  BH.figure BH.! BHA.id (BH.toValue idText) $ do+        BH.script BH.! BHA.type_ "text/javascript" $ BH.preEscapedToHtml script+        maybe (return ()) (BH.figcaption . BH.toHtml) captionTextM