    ------------------------------------------------------------------------
    -- |
    -- Module           : Data.Parameterized.TraversableFC
    -- Copyright        : (c) Galois, Inc 2014-2015
    -- Maintainer       : Joe Hendrix <jhendrix@galois.com>
    -- Description      : Traversing structures having a single parametric type followed by a fixed kind.
    --
    -- This module declares classes for working with structures that accept
    -- a parametric type parameter followed by some fixed kind.
    ------------------------------------------------------------------------
    {-# LANGUAGE PolyKinds #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE TypeOperators #-}
    module Data.Parameterized.TraversableFC
      ( TestEqualityFC(..)
      , OrdFC(..)
      , ShowFC(..)
      , HashableFC(..)
      , FunctorFC(..)
      , FoldableFC(..)
      , foldlMFC
      , foldlMFC'
      , foldrMFC
      , foldrMFC'
      , TraversableFC(..)
      , traverseFC_
      , forMFC_
      , forFC_
      , forFC
      , fmapFCDefault
      , foldMapFCDefault
      , allFC
      , anyFC
      , lengthFC
      ) where

    import Control.Applicative (Const(..) )
    import Control.Monad.Identity ( Identity (..) )
    import Data.Coerce
    import Data.Kind
    import Data.Monoid
    import GHC.Exts (build)
    import Data.Type.Equality

    import Data.Parameterized.Classes

    -- | A parameterized type that is a functor on all instances.
    --
    -- Laws:
    --
    -- [Identity]    @'fmapFC' 'id' == 'id'@
    -- [Composition] @'fmapFC' (f . g) == 'fmapFC' f . 'fmapFC' g@
    class FunctorFC (t :: (k -> Type) -> l -> Type) where
      fmapFC :: forall f g. (forall x. f x -> g x) ->
                            (forall x. t f x -> t g x)

    instance FunctorFC Alt where
      fmapFC :: forall (f :: l -> *) (g :: l -> *).
    (forall (x :: l). f x -> g x)
    -> forall (x :: l). Alt f x -> Alt g x
    fmapFC forall (x :: l). f x -> g x
    f (Alt f x
    a) = g x -> Alt g x
    forall {k} (f :: k -> *) (a :: k). f a -> Alt f a
    Alt (f x -> g x
    forall (x :: l). f x -> g x
    f f x
    a)

    instance FunctorFC Ap where
      fmapFC :: forall (f :: l -> *) (g :: l -> *).
    (forall (x :: l). f x -> g x) -> forall (x :: l). Ap f x -> Ap g x
    fmapFC forall (x :: l). f x -> g x
    f (Ap f x
    a) = g x -> Ap g x
    forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
    Ap (f x -> g x
    forall (x :: l). f x -> g x
    f f x
    a)

    instance FunctorFC TypeAp where
      fmapFC :: forall (f :: l -> *) (g :: l -> *).
    (forall (x :: l). f x -> g x)
    -> forall (x :: l). TypeAp f x -> TypeAp g x
    fmapFC forall (x :: l). f x -> g x
    f (TypeAp f x
    a) = g x -> TypeAp g x
    forall k (f :: k -> *) (tp :: k). f tp -> TypeAp f tp
    TypeAp (f x -> g x
    forall (x :: l). f x -> g x
    f f x
    a)

    -- | A parameterized class for types which can be shown, when given
    --   functions to show parameterized subterms.
    class ShowFC (t :: (k -> Type) -> l -> Type) where
      {-# MINIMAL showFC | showsPrecFC #-}

      showFC :: forall f. (forall x. f x -> String)
             -> (forall x. t f x -> String)
      showFC forall (x :: k). f x -> String
    sh t f x
    x = (forall (x :: k). Int -> f x -> ShowS)
    -> forall (x :: l). Int -> t f x -> ShowS
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *).
    ShowFC t =>
    (forall (x :: k). Int -> f x -> ShowS)
    -> forall (x :: l). Int -> t f x -> ShowS
    forall (f :: k -> *).
    (forall (x :: k). Int -> f x -> ShowS)
    -> forall (x :: l). Int -> t f x -> ShowS
    showsPrecFC (\Int
    _prec f x
    z String
    rest -> f x -> String
    forall (x :: k). f x -> String
    sh f x
    z String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    rest) Int
    0 t f x
    x []

      showsPrecFC :: forall f. (forall x. Int -> f x -> ShowS) ->
                               (forall x. Int -> t f x -> ShowS)
      showsPrecFC forall (x :: k). Int -> f x -> ShowS
    sh Int
    _prec t f x
    x String
    rest = (forall (x :: k). f x -> String)
    -> forall (x :: l). t f x -> String
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *).
    ShowFC t =>
    (forall (x :: k). f x -> String)
    -> forall (x :: l). t f x -> String
    forall (f :: k -> *).
    (forall (x :: k). f x -> String)
    -> forall (x :: l). t f x -> String
    showFC (\f x
    z -> Int -> f x -> ShowS
    forall (x :: k). Int -> f x -> ShowS
    sh Int
    0 f x
    z []) t f x
    x String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    rest

    -- | A parameterized class for types which can be hashed, when given
    --   functions to hash parameterized subterms.
    class HashableFC (t :: (k -> Type) -> l -> Type) where
      hashWithSaltFC :: forall f. (forall x. Int -> f x -> Int) ->
                                  (forall x. Int -> t f x -> Int)

    -- | A parameterized class for types which can be tested for parameterized equality,
    --   when given an equality test for subterms.
    class TestEqualityFC (t :: (k -> Type) -> l -> Type) where
      testEqualityFC :: forall f. (forall x y. f x -> f y -> (Maybe (x :~: y))) ->
                                  (forall x y. t f x -> t f y -> (Maybe (x :~: y)))

    -- | A parameterized class for types which can be tested for parameterized ordering,
    --   when given an comparison test for subterms.
    class TestEqualityFC t => OrdFC (t :: (k -> Type) -> l -> Type) where
      compareFC :: forall f. (forall x y. f x -> f y -> OrderingF x y) ->
                             (forall x y. t f x -> t f y -> OrderingF x y)

    ------------------------------------------------------------------------
    -- FoldableF

    -- | This is a coercion used to avoid overhead associated
    -- with function composition.
    (#.) :: Coercible b c => (b -> c) -> (a -> b) -> (a -> c)
    #. :: forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    (#.) b -> c
    _f = (a -> b) -> a -> c
    forall a b. Coercible a b => a -> b
    coerce

    -- | This is a generalization of the 'Foldable' class to
    -- structures over parameterized terms.
    class FoldableFC (t :: (k -> Type) -> l -> Type) where
      {-# MINIMAL foldMapFC | foldrFC #-}

      -- | Map each element of the structure to a monoid,
      -- and combine the results.
      foldMapFC :: forall f m. Monoid m => (forall x. f x -> m) -> (forall x. t f x -> m)
      foldMapFC forall (x :: k). f x -> m
    f = (forall (x :: k). f x -> m -> m)
    -> forall (x :: l). m -> t f x -> m
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC (m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend (m -> m -> m) -> (f x -> m) -> f x -> m -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f x -> m
    forall (x :: k). f x -> m
    f) m
    forall a. Monoid a => a
    mempty

      -- | Right-associative fold of a structure.
      foldrFC :: forall f b. (forall x. f x -> b -> b) -> (forall x. b -> t f x -> b)
      foldrFC forall (x :: k). f x -> b -> b
    f b
    z t f x
    t = Endo b -> b -> b
    forall a. Endo a -> a -> a
    appEndo ((forall (x :: k). f x -> Endo b)
    -> forall (x :: l). t f x -> Endo b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) m.
    (FoldableFC t, Monoid m) =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    forall (f :: k -> *) m.
    Monoid m =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    foldMapFC ((b -> b) -> Endo b
    forall a. (a -> a) -> Endo a
    Endo ((b -> b) -> Endo b) -> (f x -> b -> b) -> f x -> Endo b
    forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    #. f x -> b -> b
    forall (x :: k). f x -> b -> b
    f) t f x
    t) b
    z

      -- | Left-associative fold of a structure.
      foldlFC :: forall f b. (forall x. b -> f x -> b) -> (forall x. b -> t f x -> b)
      foldlFC forall (x :: k). b -> f x -> b
    f b
    z t f x
    t = Endo b -> b -> b
    forall a. Endo a -> a -> a
    appEndo (Dual (Endo b) -> Endo b
    forall a. Dual a -> a
    getDual ((forall (x :: k). f x -> Dual (Endo b))
    -> forall (x :: l). t f x -> Dual (Endo b)
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) m.
    (FoldableFC t, Monoid m) =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    forall (f :: k -> *) m.
    Monoid m =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    foldMapFC (\f x
    e -> Endo b -> Dual (Endo b)
    forall a. a -> Dual a
    Dual ((b -> b) -> Endo b
    forall a. (a -> a) -> Endo a
    Endo (\b
    r -> b -> f x -> b
    forall (x :: k). b -> f x -> b
    f b
    r f x
    e))) t f x
    t)) b
    z

      -- | Right-associative fold of a structure,
      -- but with strict application of the operator.
      foldrFC' :: forall f b. (forall x. f x -> b -> b) -> (forall x. b -> t f x -> b)
      foldrFC' forall (x :: k). f x -> b -> b
    f0 b
    z0 t f x
    xs = (forall (x :: k). (b -> b) -> f x -> b -> b)
    -> forall (x :: l). (b -> b) -> t f x -> b -> b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    foldlFC ((f x -> b -> b) -> (b -> b) -> f x -> b -> b
    forall {t} {t} {a} {b}. (t -> t -> a) -> (a -> b) -> t -> t -> b
    f' f x -> b -> b
    forall (x :: k). f x -> b -> b
    f0) b -> b
    forall a. a -> a
    id t f x
    xs b
    z0
        where f' :: (t -> t -> a) -> (a -> b) -> t -> t -> b
    f' t -> t -> a
    f a -> b
    k t
    x t
    z = a -> b
    k (a -> b) -> a -> b
    forall a b. (a -> b) -> a -> b
    $! t -> t -> a
    f t
    x t
    z

      -- | Left-associative fold of a parameterized structure
      -- with a strict accumulator.
      foldlFC' :: forall f b. (forall x. b -> f x -> b) -> (forall x. b -> t f x -> b)
      foldlFC' forall (x :: k). b -> f x -> b
    f0 b
    z0 t f x
    xs = (forall (x :: k). f x -> (b -> b) -> b -> b)
    -> forall (x :: l). (b -> b) -> t f x -> b -> b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC ((b -> f x -> b) -> f x -> (b -> b) -> b -> b
    forall {t} {t} {a} {b}. (t -> t -> a) -> t -> (a -> b) -> t -> b
    f' b -> f x -> b
    forall (x :: k). b -> f x -> b
    f0) b -> b
    forall a. a -> a
    id t f x
    xs b
    z0
        where f' :: (t -> t -> a) -> t -> (a -> b) -> t -> b
    f' t -> t -> a
    f t
    x a -> b
    k t
    z = a -> b
    k (a -> b) -> a -> b
    forall a b. (a -> b) -> a -> b
    $! t -> t -> a
    f t
    z t
    x

      -- | Convert structure to list.
      toListFC :: forall f a. (forall x. f x -> a) -> (forall x. t f x -> [a])
      toListFC forall (x :: k). f x -> a
    f t f x
    t = (forall b. (a -> b -> b) -> b -> b) -> [a]
    forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
    build (\a -> b -> b
    c b
    n -> (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC (\f x
    e b
    v -> a -> b -> b
    c (f x -> a
    forall (x :: k). f x -> a
    f f x
    e) b
    v) b
    n t f x
    t)

    -- | Monadic fold over the elements of a structure from left to right.
    foldlMFC :: (FoldableFC t, Monad m) => (forall x . b -> f x -> m b) -> b -> t f c -> m b
    foldlMFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *) b
           (f :: k -> *) (c :: l).
    (FoldableFC t, Monad m) =>
    (forall (x :: k). b -> f x -> m b) -> b -> t f c -> m b
    foldlMFC forall (x :: k). b -> f x -> m b
    f b
    z0 t f c
    xs = (forall (x :: k). f x -> (b -> m b) -> b -> m b)
    -> forall (x :: l). (b -> m b) -> t f x -> b -> m b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC f x -> (b -> m b) -> b -> m b
    forall (x :: k). f x -> (b -> m b) -> b -> m b
    forall {x :: k} {b}. f x -> (b -> m b) -> b -> m b
    f' b -> m b
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return t f c
    xs b
    z0
      where f' :: f x -> (b -> m b) -> b -> m b
    f' f x
    x b -> m b
    k b
    z = b -> f x -> m b
    forall (x :: k). b -> f x -> m b
    f b
    z f x
    x m b -> (b -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= b -> m b
    k

    -- | Monadic strict fold over the elements of a structure from left to right.
    foldlMFC' :: (FoldableFC t, Monad m) => (forall x . b -> f x -> m b) -> b -> t f c -> m b
    foldlMFC' :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *) b
           (f :: k -> *) (c :: l).
    (FoldableFC t, Monad m) =>
    (forall (x :: k). b -> f x -> m b) -> b -> t f c -> m b
    foldlMFC' forall (x :: k). b -> f x -> m b
    f b
    z0 t f c
    xs = b -> m b -> m b
    forall a b. a -> b -> b
    seq b
    z0 (m b -> m b) -> m b -> m b
    forall a b. (a -> b) -> a -> b
    $ (forall (x :: k). f x -> (b -> m b) -> b -> m b)
    -> forall (x :: l). (b -> m b) -> t f x -> b -> m b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC f x -> (b -> m b) -> b -> m b
    forall (x :: k). f x -> (b -> m b) -> b -> m b
    forall {x :: k} {b}. f x -> (b -> m b) -> b -> m b
    f' b -> m b
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return t f c
    xs b
    z0
      where f' :: f x -> (b -> m b) -> b -> m b
    f' f x
    x b -> m b
    k b
    z = b -> f x -> m b
    forall (x :: k). b -> f x -> m b
    f b
    z f x
    x m b -> (b -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \b
    r -> b -> m b -> m b
    forall a b. a -> b -> b
    seq b
    r (b -> m b
    k b
    r)

    -- | Monadic fold over the elements of a structure from right to left.
    foldrMFC :: (FoldableFC t, Monad m) => (forall x . f x -> b -> m b) -> b -> t f c -> m b
    foldrMFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) b (c :: l).
    (FoldableFC t, Monad m) =>
    (forall (x :: k). f x -> b -> m b) -> b -> t f c -> m b
    foldrMFC forall (x :: k). f x -> b -> m b
    f b
    z0 t f c
    xs = (forall (x :: k). (b -> m b) -> f x -> b -> m b)
    -> forall (x :: l). (b -> m b) -> t f x -> b -> m b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    foldlFC (b -> m b) -> f x -> b -> m b
    forall (x :: k). (b -> m b) -> f x -> b -> m b
    forall {b} {x :: k}. (b -> m b) -> f x -> b -> m b
    f' b -> m b
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return t f c
    xs b
    z0
      where f' :: (b -> m b) -> f x -> b -> m b
    f' b -> m b
    k f x
    x b
    z = f x -> b -> m b
    forall (x :: k). f x -> b -> m b
    f f x
    x b
    z m b -> (b -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= b -> m b
    k

    -- | Monadic strict fold over the elements of a structure from right to left.
    foldrMFC' :: (FoldableFC t, Monad m) => (forall x . f x -> b -> m b) -> b -> t f c -> m b
    foldrMFC' :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) b (c :: l).
    (FoldableFC t, Monad m) =>
    (forall (x :: k). f x -> b -> m b) -> b -> t f c -> m b
    foldrMFC' forall (x :: k). f x -> b -> m b
    f b
    z0 t f c
    xs = b -> m b -> m b
    forall a b. a -> b -> b
    seq b
    z0 ((forall (x :: k). (b -> m b) -> f x -> b -> m b)
    -> forall (x :: l). (b -> m b) -> t f x -> b -> m b
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). b -> f x -> b)
    -> forall (x :: l). b -> t f x -> b
    foldlFC (b -> m b) -> f x -> b -> m b
    forall (x :: k). (b -> m b) -> f x -> b -> m b
    forall {b} {x :: k}. (b -> m b) -> f x -> b -> m b
    f' b -> m b
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return t f c
    xs b
    z0)
      where f' :: (b -> m b) -> f x -> b -> m b
    f' b -> m b
    k f x
    x b
    z = f x -> b -> m b
    forall (x :: k). f x -> b -> m b
    f f x
    x b
    z m b -> (b -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \b
    r -> b -> m b -> m b
    forall a b. a -> b -> b
    seq b
    r (b -> m b
    k b
    r)

    -- | Return 'True' if all values satisfy predicate.
    allFC :: FoldableFC t => (forall x. f x -> Bool) -> (forall x. t f x -> Bool)
    allFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (f :: k -> *).
    FoldableFC t =>
    (forall (x :: k). f x -> Bool) -> forall (x :: l). t f x -> Bool
    allFC forall (x :: k). f x -> Bool
    p = All -> Bool
    getAll (All -> Bool) -> (t f x -> All) -> t f x -> Bool
    forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    #. (forall (x :: k). f x -> All) -> forall (x :: l). t f x -> All
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) m.
    (FoldableFC t, Monoid m) =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    forall (f :: k -> *) m.
    Monoid m =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    foldMapFC (Bool -> All
    All (Bool -> All) -> (f x -> Bool) -> f x -> All
    forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    #. f x -> Bool
    forall (x :: k). f x -> Bool
    p)

    -- | Return 'True' if any values satisfy predicate.
    anyFC :: FoldableFC t => (forall x. f x -> Bool) -> (forall x. t f x -> Bool)
    anyFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (f :: k -> *).
    FoldableFC t =>
    (forall (x :: k). f x -> Bool) -> forall (x :: l). t f x -> Bool
    anyFC forall (x :: k). f x -> Bool
    p = Any -> Bool
    getAny (Any -> Bool) -> (t f x -> Any) -> t f x -> Bool
    forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    #. (forall (x :: k). f x -> Any) -> forall (x :: l). t f x -> Any
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) m.
    (FoldableFC t, Monoid m) =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    forall (f :: k -> *) m.
    Monoid m =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    foldMapFC (Bool -> Any
    Any (Bool -> Any) -> (f x -> Bool) -> f x -> Any
    forall b c a. Coercible b c => (b -> c) -> (a -> b) -> a -> c
    #. f x -> Bool
    forall (x :: k). f x -> Bool
    p)

    -- | Return number of elements that we fold over.
    lengthFC :: FoldableFC t => t f x -> Int
    lengthFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (f :: k -> *) (x :: l).
    FoldableFC t =>
    t f x -> Int
    lengthFC = (forall (x :: k). f x -> Int -> Int)
    -> forall (x :: l). Int -> t f x -> Int
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC ((Int -> Int) -> f x -> Int -> Int
    forall a b. a -> b -> a
    const (Int -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) Int
    0

    instance FoldableFC Alt where
      foldMapFC :: forall (f :: l -> *) m.
    Monoid m =>
    (forall (x :: l). f x -> m) -> forall (x :: l). Alt f x -> m
    foldMapFC forall (x :: l). f x -> m
    toMonoid (Alt f x
    x) = f x -> m
    forall (x :: l). f x -> m
    toMonoid f x
    x

    instance FoldableFC Ap where
      foldMapFC :: forall (f :: l -> *) m.
    Monoid m =>
    (forall (x :: l). f x -> m) -> forall (x :: l). Ap f x -> m
    foldMapFC forall (x :: l). f x -> m
    toMonoid (Ap f x
    x) = f x -> m
    forall (x :: l). f x -> m
    toMonoid f x
    x

    instance FoldableFC TypeAp where
      foldMapFC :: forall (f :: l -> *) m.
    Monoid m =>
    (forall (x :: l). f x -> m) -> forall (x :: l). TypeAp f x -> m
    foldMapFC forall (x :: l). f x -> m
    toMonoid (TypeAp f x
    x) = f x -> m
    forall (x :: l). f x -> m
    toMonoid f x
    x

    ------------------------------------------------------------------------
    -- TraversableF

    class (FunctorFC t, FoldableFC t) => TraversableFC (t :: (k -> Type) -> l -> Type) where
      traverseFC :: forall f g m. Applicative m
                 => (forall x. f x -> m (g x))
                 -> (forall x. t f x -> m (t g x))

    -- | This function may be used as a value for `fmapF` in a `FunctorF`
    -- instance.
    fmapFCDefault :: TraversableFC t => forall f g. (forall x. f x -> g x) -> (forall x. t f x -> t g x)
    fmapFCDefault :: forall {k} {l} (t :: (k -> *) -> l -> *) (f :: k -> *)
           (g :: k -> *).
    TraversableFC t =>
    (forall (x :: k). f x -> g x) -> forall (x :: l). t f x -> t g x
    fmapFCDefault = \forall (x :: k). f x -> g x
    f -> Identity (t g x) -> t g x
    forall a. Identity a -> a
    runIdentity (Identity (t g x) -> t g x)
    -> (t f x -> Identity (t g x)) -> t f x -> t g x
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (x :: k). f x -> Identity (g x))
    -> forall (x :: l). t f x -> Identity (t g x)
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) (g :: k -> *)
           (m :: * -> *).
    (TraversableFC t, Applicative m) =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    forall (f :: k -> *) (g :: k -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    traverseFC (g x -> Identity (g x)
    forall a. a -> Identity a
    Identity (g x -> Identity (g x)) -> (f x -> g x) -> f x -> Identity (g x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f x -> g x
    forall (x :: k). f x -> g x
    f)
    {-# INLINE fmapFCDefault #-}

    -- | This function may be used as a value for `Data.Foldable.foldMap`
    -- in a `Foldable` instance.
    foldMapFCDefault :: (TraversableFC t, Monoid m) => (forall x. f x -> m) -> (forall x. t f x -> m)
    foldMapFCDefault :: forall {k} {l} (t :: (k -> *) -> l -> *) m (f :: k -> *).
    (TraversableFC t, Monoid m) =>
    (forall (x :: k). f x -> m) -> forall (x :: l). t f x -> m
    foldMapFCDefault = \forall (x :: k). f x -> m
    f -> Const m (t (ZonkAny 0) x) -> m
    forall {k} a (b :: k). Const a b -> a
    getConst (Const m (t (ZonkAny 0) x) -> m)
    -> (t f x -> Const m (t (ZonkAny 0) x)) -> t f x -> m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (forall (x :: k). f x -> Const m (ZonkAny 0 x))
    -> forall (x :: l). t f x -> Const m (t (ZonkAny 0) x)
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) (g :: k -> *)
           (m :: * -> *).
    (TraversableFC t, Applicative m) =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    forall (f :: k -> *) (g :: k -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    traverseFC (m -> Const m (ZonkAny 0 x)
    forall {k} a (b :: k). a -> Const a b
    Const (m -> Const m (ZonkAny 0 x))
    -> (f x -> m) -> f x -> Const m (ZonkAny 0 x)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . f x -> m
    forall (x :: k). f x -> m
    f)
    {-# INLINE foldMapFCDefault #-}

    -- | Map each element of a structure to an action, evaluate
    -- these actions from left to right, and ignore the results.
    traverseFC_ :: (FoldableFC t, Applicative m) => (forall x. f x -> m a) -> (forall x. t f x -> m ())
    traverseFC_ :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) a.
    (FoldableFC t, Applicative m) =>
    (forall (x :: k). f x -> m a) -> forall (x :: l). t f x -> m ()
    traverseFC_ forall (x :: k). f x -> m a
    f = (forall (x :: k). f x -> m () -> m ())
    -> forall (x :: l). m () -> t f x -> m ()
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) b.
    FoldableFC t =>
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    forall (f :: k -> *) b.
    (forall (x :: k). f x -> b -> b)
    -> forall (x :: l). b -> t f x -> b
    foldrFC (\f x
    e m ()
    r -> f x -> m a
    forall (x :: k). f x -> m a
    f f x
    e m a -> m () -> m ()
    forall a b. m a -> m b -> m b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> m ()
    r) (() -> m ()
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ())
    {-# INLINE traverseFC_ #-}

    -- | Map each element of a structure to an action, evaluate
    -- these actions from left to right, and ignore the results.
    forMFC_ :: (FoldableFC t, Applicative m) => t f c -> (forall x. f x -> m a) -> m ()
    forMFC_ :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) (c :: l) a.
    (FoldableFC t, Applicative m) =>
    t f c -> (forall (x :: k). f x -> m a) -> m ()
    forMFC_ t f c
    v forall (x :: k). f x -> m a
    f = (forall (x :: k). f x -> m a) -> forall (x :: l). t f x -> m ()
    forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) a.
    (FoldableFC t, Applicative m) =>
    (forall (x :: k). f x -> m a) -> forall (x :: l). t f x -> m ()
    traverseFC_ f x -> m a
    forall (x :: k). f x -> m a
    f t f c
    v
    {-# INLINE forMFC_ #-}
    {-# DEPRECATED forMFC_ "Use forFC_" #-}

    -- | Map each element of a structure to an action, evaluate
    -- these actions from left to right, and ignore the results.
    forFC_ :: (FoldableFC t, Applicative m) => t f c -> (forall x. f x -> m a) -> m ()
    forFC_ :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) (c :: l) a.
    (FoldableFC t, Applicative m) =>
    t f c -> (forall (x :: k). f x -> m a) -> m ()
    forFC_ t f c
    v forall (x :: k). f x -> m a
    f = (forall (x :: k). f x -> m a) -> forall (x :: l). t f x -> m ()
    forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) a.
    (FoldableFC t, Applicative m) =>
    (forall (x :: k). f x -> m a) -> forall (x :: l). t f x -> m ()
    traverseFC_ f x -> m a
    forall (x :: k). f x -> m a
    f t f c
    v
    {-# INLINE forFC_ #-}

    -- | Flipped 'traverseFC'
    forFC ::
      (TraversableFC t, Applicative m) =>
      t f x -> (forall y. f y -> m (g y)) -> m (t g x)
    forFC :: forall {k} {l} (t :: (k -> *) -> l -> *) (m :: * -> *)
           (f :: k -> *) (x :: l) (g :: k -> *).
    (TraversableFC t, Applicative m) =>
    t f x -> (forall (y :: k). f y -> m (g y)) -> m (t g x)
    forFC t f x
    v forall (y :: k). f y -> m (g y)
    f = (forall (y :: k). f y -> m (g y))
    -> forall (x :: l). t f x -> m (t g x)
    forall k l (t :: (k -> *) -> l -> *) (f :: k -> *) (g :: k -> *)
           (m :: * -> *).
    (TraversableFC t, Applicative m) =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    forall (f :: k -> *) (g :: k -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: k). f x -> m (g x))
    -> forall (x :: l). t f x -> m (t g x)
    traverseFC f x -> m (g x)
    forall (y :: k). f y -> m (g y)
    f t f x
    v
    {-# INLINE forFC #-}

    instance TraversableFC Alt where
      traverseFC :: forall (f :: l -> *) (g :: l -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: l). f x -> m (g x))
    -> forall (x :: l). Alt f x -> m (Alt g x)
    traverseFC forall (x :: l). f x -> m (g x)
    f (Alt f x
    x) = g x -> Alt g x
    forall {k} (f :: k -> *) (a :: k). f a -> Alt f a
    Alt (g x -> Alt g x) -> m (g x) -> m (Alt g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> m (g x)
    forall (x :: l). f x -> m (g x)
    f f x
    x

    instance TraversableFC Ap where
      traverseFC :: forall (f :: l -> *) (g :: l -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: l). f x -> m (g x))
    -> forall (x :: l). Ap f x -> m (Ap g x)
    traverseFC forall (x :: l). f x -> m (g x)
    f (Ap f x
    x) = g x -> Ap g x
    forall {k} (f :: k -> *) (a :: k). f a -> Ap f a
    Ap (g x -> Ap g x) -> m (g x) -> m (Ap g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> m (g x)
    forall (x :: l). f x -> m (g x)
    f f x
    x

    instance TraversableFC TypeAp where
      traverseFC :: forall (f :: l -> *) (g :: l -> *) (m :: * -> *).
    Applicative m =>
    (forall (x :: l). f x -> m (g x))
    -> forall (x :: l). TypeAp f x -> m (TypeAp g x)
    traverseFC forall (x :: l). f x -> m (g x)
    f (TypeAp f x
    x) = g x -> TypeAp g x
    forall k (f :: k -> *) (tp :: k). f tp -> TypeAp f tp
    TypeAp (g x -> TypeAp g x) -> m (g x) -> m (TypeAp g x)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f x -> m (g x)
    forall (x :: l). f x -> m (g x)
    f f x
    x