{-# LANGUAGE CPP #-}

-- __NB__: base-4.17 moves `IsList` to its own module, which avoids the unsafety
--         of importing "GHC.Exts". With prior versions of base, we at least
--         mark the module @Trustworthy@.
#if MIN_VERSION_base(4, 17, 0)
{-# LANGUAGE Safe #-}
#else
{-# LANGUAGE Trustworthy #-}
#endif
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Yaya.Applied
  ( Void,
    absurd,
    append,
    at,
    atMay,
    constantly,
    drop',
    drop,
    fibonacci,
    fibonacciPolynomials,
    fromList,
    fromListN,
    fromMaybe,
    height,
    jacobsthal,
    length,
    lucas,
    lucasSequenceU,
    lucasSequenceV,
    maybeReify,
    mersenne,
    naturals,
    now,
    pell,
    reifyUpTo,
    reverse',
    reverse,
    runToEnd,
    succN,
    tail,
    take,
    takeUpTo,
    toList,
    truncate,
    vacuous,
    zeroN,
  )
where

import safe "base" Control.Category (Category (id, (.)))
import safe "base" Data.Foldable (Foldable (foldr))
import safe "base" Data.Function (flip)
import safe "base" Data.Functor (Functor (fmap))
import safe "base" Data.Functor.Identity (Identity (runIdentity))
import safe "base" Data.Int (Int)
import safe "base" Data.Monoid (Monoid (mempty))
import safe "base" Data.Ord (Ord (max))
import safe "base" Data.Semigroup (Semigroup ((<>)))

-- See comment on @{-# LANGUAGE Safe #-}@ above.
#if MIN_VERSION_base(4, 17, 0)
import "base" GHC.IsList (IsList)
import qualified "base" GHC.IsList as IsList
#else
import "base" GHC.Exts (IsList)
import qualified "base" GHC.Exts as IsList
#endif
import safe "base" Numeric.Natural (Natural)
import safe "free" Control.Monad.Trans.Free (FreeF (Free, Pure))
import safe "this" Yaya.Fold
  ( Algebra,
    Corecursive (ana),
    Mu,
    Nu,
    Projectable (project),
    Recursive (cata),
    Steppable (embed),
    cata2,
  )
import safe "this" Yaya.Fold.Common
  ( diagonal,
    fromEither,
    lucasSequence',
    maybeTakeNext,
    never,
    replaceNeither,
    takeAnother,
    takeAvailable,
    takeNext,
    toRight,
    truncate',
    unarySequence,
  )
import safe "this" Yaya.Fold.Native (Fix)
import safe "this" Yaya.Pattern
  ( Either (Left),
    Maybe (Just, Nothing),
    Pair,
    XNor (Both, Neither),
    maybe,
  )
import safe "base" Prelude (Integral, fromIntegral)

now :: (Steppable (->) t (Either a)) => a -> t
now :: forall t a. Steppable (->) t (Either a) => a -> t
now = Algebra (->) (Either a) t
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (Either a) t -> (a -> Either a t) -> a -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> Either a t
forall a b. a -> Either a b
Left

-- | This will collapse all the intermediate steps to get to the value that must
--   exist at the end.
runToEnd :: (Recursive (->) t (Either a)) => t -> a
runToEnd :: forall t a. Recursive (->) t (Either a) => t -> a
runToEnd = Algebra (->) (Either a) a -> t -> a
forall a. Algebra (->) (Either a) a -> t -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) (Either a) a
forall a. Either a a -> a
fromEither

-- | Converts exceptional divergence to non-termination.
fromMaybe :: (Steppable (->) t (Either a), Corecursive (->) t (Either a)) => Maybe a -> t
fromMaybe :: forall t a.
(Steppable (->) t (Either a), Corecursive (->) t (Either a)) =>
Maybe a -> t
fromMaybe = t -> (a -> t) -> Maybe a -> t
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Coalgebra (->) (Either a) () -> () -> t
forall a. Coalgebra (->) (Either a) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
ana (Identity () -> Either a ()
forall b a. Identity b -> Either a b
toRight (Identity () -> Either a ())
-> (() -> Identity ()) -> Coalgebra (->) (Either a) ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. () -> Identity ()
forall a. a -> Identity a
never) ()) a -> t
forall t a. Steppable (->) t (Either a) => a -> t
now

type Void = Mu Identity

absurd :: (Recursive (->) t Identity) => t -> a
absurd :: forall t a. Recursive (->) t Identity => t -> a
absurd = Algebra (->) Identity a -> t -> a
forall a. Algebra (->) Identity a -> t -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) Identity a
forall a. Identity a -> a
runIdentity

vacuous :: (Functor f, Recursive (->) t Identity) => f t -> f a
vacuous :: forall (f :: * -> *) t a.
(Functor f, Recursive (->) t Identity) =>
f t -> f a
vacuous = (t -> a) -> f t -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap t -> a
forall t a. Recursive (->) t Identity => t -> a
absurd

zeroN :: (Steppable (->) t Maybe) => t
zeroN :: forall t. Steppable (->) t Maybe => t
zeroN = Algebra (->) Maybe t
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Maybe t
forall a. Maybe a
Nothing

succN :: (Steppable (->) t Maybe) => t -> t
succN :: forall t. Steppable (->) t Maybe => t -> t
succN = Algebra (->) Maybe t
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) Maybe t -> (t -> Maybe t) -> t -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. t -> Maybe t
forall a. a -> Maybe a
Just

height :: (Foldable f, Steppable (->) n Maybe, Ord n) => f n -> n
height :: forall (f :: * -> *) n.
(Foldable f, Steppable (->) n Maybe, Ord n) =>
f n -> n
height = (n -> n -> n) -> n -> f n -> n
forall a b. (a -> b -> b) -> b -> f a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (n -> n -> n
forall a. Ord a => a -> a -> a
max (n -> n -> n) -> (n -> n) -> n -> n -> n
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. n -> n
forall t. Steppable (->) t Maybe => t -> t
succN) n
forall t. Steppable (->) t Maybe => t
zeroN

naturals :: (Steppable (->) n Maybe, Corecursive (->) t ((,) n)) => t
naturals :: forall n t.
(Steppable (->) n Maybe, Corecursive (->) t ((,) n)) =>
t
naturals = Coalgebra (->) ((,) n) n -> n -> t
forall a. Coalgebra (->) ((,) n) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
ana ((n -> n) -> Coalgebra (->) ((,) n) n
forall a b. (a -> b) -> a -> (a, b)
unarySequence n -> n
forall t. Steppable (->) t Maybe => t -> t
succN) n
forall t. Steppable (->) t Maybe => t
zeroN

length :: (Recursive (->) t (XNor a), Steppable (->) n Maybe, Ord n) => t -> n
length :: forall t a n.
(Recursive (->) t (XNor a), Steppable (->) n Maybe, Ord n) =>
t -> n
length = Algebra (->) (XNor a) n -> t -> n
forall a. Algebra (->) (XNor a) a -> t -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) (XNor a) n
forall (f :: * -> *) n.
(Foldable f, Steppable (->) n Maybe, Ord n) =>
f n -> n
height

append :: (Recursive (->) t (XNor a), Steppable (->) u (XNor a)) => t -> u -> u
append :: forall t a u.
(Recursive (->) t (XNor a), Steppable (->) u (XNor a)) =>
t -> u -> u
append t
front u
back = Algebra (->) (XNor a) u -> t -> u
forall a. Algebra (->) (XNor a) a -> t -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata (Algebra (->) (XNor a) u
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (XNor a) u
-> (XNor a u -> XNor a u) -> Algebra (->) (XNor a) u
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. XNor a u -> XNor a u -> XNor a u
forall a b. XNor a b -> XNor a b -> XNor a b
replaceNeither (Coalgebra (->) (XNor a) u
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project u
back)) t
front

instance Semigroup (Fix (XNor a)) where
  <> :: Fix (XNor a) -> Fix (XNor a) -> Fix (XNor a)
(<>) = Fix (XNor a) -> Fix (XNor a) -> Fix (XNor a)
forall t a u.
(Recursive (->) t (XNor a), Steppable (->) u (XNor a)) =>
t -> u -> u
append

instance Monoid (Fix (XNor a)) where
  mempty :: Fix (XNor a)
mempty = Algebra (->) (XNor a) (Fix (XNor a))
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed XNor a (Fix (XNor a))
forall a b. XNor a b
Neither

instance Semigroup (Mu (XNor a)) where
  <> :: Mu (XNor a) -> Mu (XNor a) -> Mu (XNor a)
(<>) = Mu (XNor a) -> Mu (XNor a) -> Mu (XNor a)
forall t a u.
(Recursive (->) t (XNor a), Steppable (->) u (XNor a)) =>
t -> u -> u
append

instance Monoid (Mu (XNor a)) where
  mempty :: Mu (XNor a)
mempty = Algebra (->) (XNor a) (Mu (XNor a))
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed XNor a (Mu (XNor a))
forall a b. XNor a b
Neither

drop' :: (Projectable (->) t (XNor a)) => Maybe (t -> t) -> t -> t
drop' :: forall t a. Projectable (->) t (XNor a) => Maybe (t -> t) -> t -> t
drop' (Just t -> t
fn) (Coalgebra (->) (XNor a) t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project -> Both a
_ t
t) = t -> t
fn t
t
drop' Maybe (t -> t)
_ t
t = t
t

drop :: (Recursive (->) n Maybe, Projectable (->) t (XNor a)) => n -> t -> t
drop :: forall n t a.
(Recursive (->) n Maybe, Projectable (->) t (XNor a)) =>
n -> t -> t
drop = Algebra (->) Maybe (t -> t) -> n -> t -> t
forall a. Algebra (->) Maybe a -> n -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) Maybe (t -> t)
forall t a. Projectable (->) t (XNor a) => Maybe (t -> t) -> t -> t
drop'

tail :: (Projectable (->) t (XNor a)) => t -> t
tail :: forall t a. Projectable (->) t (XNor a) => t -> t
tail = Natural -> t -> t
forall n t a.
(Recursive (->) n Maybe, Projectable (->) t (XNor a)) =>
n -> t -> t
drop (Natural
1 :: Natural)

reverse' ::
  (Steppable (->) t (XNor a)) =>
  XNor a (XNor a t -> XNor a t) ->
  XNor a t ->
  XNor a t
reverse' :: forall t a.
Steppable (->) t (XNor a) =>
XNor a (XNor a t -> XNor a t) -> XNor a t -> XNor a t
reverse' XNor a (XNor a t -> XNor a t)
Neither = XNor a t -> XNor a t
forall a. a -> a
forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id
reverse' (Both a
a XNor a t -> XNor a t
fn) = XNor a t -> XNor a t
fn (XNor a t -> XNor a t)
-> (XNor a t -> XNor a t) -> XNor a t -> XNor a t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. a -> t -> XNor a t
forall a b. a -> b -> XNor a b
Both a
a (t -> XNor a t) -> (XNor a t -> t) -> XNor a t -> XNor a t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. XNor a t -> t
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed

reverse :: (Recursive (->) t (XNor a), Steppable (->) u (XNor a)) => t -> u
reverse :: forall t a u.
(Recursive (->) t (XNor a), Steppable (->) u (XNor a)) =>
t -> u
reverse = Algebra (->) (XNor a) u
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (XNor a) u -> (t -> XNor a u) -> t -> u
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. (t -> XNor a u -> XNor a u) -> XNor a u -> t -> XNor a u
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Algebra (->) (XNor a) (XNor a u -> XNor a u)
-> t -> XNor a u -> XNor a u
forall a. Algebra (->) (XNor a) a -> t -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) (XNor a) (XNor a u -> XNor a u)
forall t a.
Steppable (->) t (XNor a) =>
XNor a (XNor a t -> XNor a t) -> XNor a t -> XNor a t
reverse') XNor a u
forall a b. XNor a b
Neither

-- | Extracts _no more than_ @n@ elements from the possibly-infinite sequence
--  @s@.
takeUpTo ::
  ( Recursive (->) n Maybe,
    Projectable (->) s (XNor a),
    Steppable (->) l (XNor a)
  ) =>
  n ->
  s ->
  l
takeUpTo :: forall n s a l.
(Recursive (->) n Maybe, Projectable (->) s (XNor a),
 Steppable (->) l (XNor a)) =>
n -> s -> l
takeUpTo = Algebra (->) (Day Maybe (XNor a)) l -> n -> s -> l
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 (Algebra (->) (XNor a) l
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (XNor a) l
-> (Day Maybe (XNor a) l -> XNor a l)
-> Algebra (->) (Day Maybe (XNor a)) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Day Maybe (XNor a) l -> XNor a l
forall a b. Day Maybe (XNor a) b -> XNor a b
takeAvailable)

-- | Extracts _exactly_ @n@ elements from the infinite stream @s@.
take ::
  ( Recursive (->) n Maybe,
    Projectable (->) s ((,) a),
    Steppable (->) l (XNor a)
  ) =>
  n ->
  s ->
  l
take :: forall n s a l.
(Recursive (->) n Maybe, Projectable (->) s ((,) a),
 Steppable (->) l (XNor a)) =>
n -> s -> l
take = Algebra (->) (Day Maybe ((,) a)) l -> n -> s -> l
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 (Algebra (->) (XNor a) l
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (XNor a) l
-> (Day Maybe ((,) a) l -> XNor a l)
-> Algebra (->) (Day Maybe ((,) a)) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Day Maybe ((,) a) l -> XNor a l
forall a b. Day Maybe ((,) a) b -> XNor a b
takeAnother)

-- | Extracts the element at a finite index of an infinite sequence (a
--  `Data.List.!!` that can't fail).
at :: (Recursive (->) n Maybe, Projectable (->) s ((,) a)) => n -> s -> a
at :: forall n s a.
(Recursive (->) n Maybe, Projectable (->) s ((,) a)) =>
n -> s -> a
at = Algebra (->) (Day Maybe ((,) a)) a -> n -> s -> a
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 Algebra (->) (Day Maybe ((,) a)) a
forall a. Day Maybe ((,) a) a -> a
takeNext

-- | Extracts the element at a finite index of a (co)list (a `Data.List.!!` that
--   fails with `Nothing`).
atMay ::
  (Recursive (->) n Maybe, Projectable (->) s (XNor a)) => n -> s -> Maybe a
atMay :: forall n s a.
(Recursive (->) n Maybe, Projectable (->) s (XNor a)) =>
n -> s -> Maybe a
atMay = Algebra (->) (Day Maybe (XNor a)) (Maybe a) -> n -> s -> Maybe a
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 Algebra (->) (Day Maybe (XNor a)) (Maybe a)
forall a. Day Maybe (XNor a) (Maybe a) -> Maybe a
maybeTakeNext

-- | Turns part of a structure inductive, so it can be analyzed, without forcing
--   the entire tree.
maybeReify ::
  (Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) =>
  Algebra (->) Maybe (s -> l)
maybeReify :: forall s (f :: * -> *) l.
(Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) =>
Algebra (->) Maybe (s -> l)
maybeReify Maybe (s -> l)
Nothing = Algebra (->) (FreeF f s) l
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (FreeF f s) l -> (s -> FreeF f s l) -> s -> l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. s -> FreeF f s l
forall (f :: * -> *) a b. a -> FreeF f a b
Pure
maybeReify (Just s -> l
f) = Algebra (->) (FreeF f s) l
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (FreeF f s) l -> (s -> FreeF f s l) -> s -> l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. f l -> FreeF f s l
forall (f :: * -> *) a b. f b -> FreeF f a b
Free (f l -> FreeF f s l) -> (s -> f l) -> s -> FreeF f s l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. (s -> l) -> f s -> f l
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap s -> l
f (f s -> f l) -> (s -> f s) -> s -> f l
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. s -> f s
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project

reifyUpTo ::
  ( Recursive (->) n Maybe,
    Projectable (->) s f,
    Steppable (->) l (FreeF f s),
    Functor f
  ) =>
  n ->
  s ->
  l
reifyUpTo :: forall n s (f :: * -> *) l.
(Recursive (->) n Maybe, Projectable (->) s f,
 Steppable (->) l (FreeF f s), Functor f) =>
n -> s -> l
reifyUpTo = Algebra (->) Maybe (s -> l) -> n -> s -> l
forall a. Algebra (->) Maybe a -> n -> a
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k1 -> k)
       (a :: k1).
Recursive c t f =>
Algebra c f a -> c t a
cata Algebra (->) Maybe (s -> l)
forall s (f :: * -> *) l.
(Projectable (->) s f, Steppable (->) l (FreeF f s), Functor f) =>
Algebra (->) Maybe (s -> l)
maybeReify

fibonacciPolynomials :: (Integral i, Corecursive (->) t ((,) i)) => i -> t
fibonacciPolynomials :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> t
fibonacciPolynomials i
x = i -> i -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU i
x (i
-1)

fibonacci :: (Corecursive (->) t ((,) Int)) => t
fibonacci :: forall t. Corecursive (->) t ((,) Int) => t
fibonacci = Int -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> t
fibonacciPolynomials Int
1

lucasSequenceU :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU i
p i
q = i -> i -> (i, i) -> (i, (i, i))
forall n. Num n => n -> n -> (n, n) -> (n, (n, n))
lucasSequence' i
p i
q ((i, i) -> (i, (i, i))) -> (i, i) -> t
forall a. Coalgebra (->) ((,) i) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
`ana` (i
0, i
1)

lucasSequenceV :: (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceV :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceV i
p i
q = i -> i -> (i, i) -> (i, (i, i))
forall n. Num n => n -> n -> (n, n) -> (n, (n, n))
lucasSequence' i
p i
q ((i, i) -> (i, (i, i))) -> (i, i) -> t
forall a. Coalgebra (->) ((,) i) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
`ana` (i
2, i
p)

lucas :: (Integral i) => (Corecursive (->) t ((,) i)) => t
lucas :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => t
lucas = i -> i -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceV i
1 (i
-1)

pell :: (Integral i, Corecursive (->) t ((,) i)) => t
pell :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => t
pell = i -> i -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU i
2 (i
-1)

jacobsthal :: (Integral i, Corecursive (->) t ((,) i)) => t
jacobsthal :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => t
jacobsthal = i -> i -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU i
1 (i
-2)

mersenne :: (Integral i, Corecursive (->) t ((,) i)) => t
mersenne :: forall i t. (Integral i, Corecursive (->) t ((,) i)) => t
mersenne = i -> i -> t
forall i t. (Integral i, Corecursive (->) t ((,) i)) => i -> i -> t
lucasSequenceU i
3 i
2

-- | Creates an infinite stream of the provided value.
constantly :: (Corecursive (->) t (Pair a)) => a -> t
constantly :: forall t a. Corecursive (->) t (Pair a) => a -> t
constantly = Coalgebra (->) (Pair a) a -> a -> t
forall a. Coalgebra (->) (Pair a) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
ana Coalgebra (->) (Pair a) a
forall a. a -> Pair a a
diagonal

-- | Lops off the branches of the tree below a certain depth, turning a
--   potentially-infinite structure into a finite one. Like a generalized
--  `Yaya.Applied.take`.
truncate ::
  ( Recursive (->) n Maybe,
    Projectable (->) t f,
    Steppable (->) u (FreeF f ()),
    Functor f
  ) =>
  n ->
  t ->
  u
truncate :: forall n t (f :: * -> *) u.
(Recursive (->) n Maybe, Projectable (->) t f,
 Steppable (->) u (FreeF f ()), Functor f) =>
n -> t -> u
truncate = Algebra (->) (Day Maybe f) u -> n -> t -> u
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 (Algebra (->) (FreeF f ()) u
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (FreeF f ()) u
-> (Day Maybe f u -> FreeF f () u) -> Algebra (->) (Day Maybe f) u
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Day Maybe f u -> FreeF f () u
forall (f :: * -> *) a. Functor f => Day Maybe f a -> FreeF f () a
truncate')

-- | An implementation of `IsList.toList` for `Corecursive` fixed-points of
--  `XNor`.
fromList :: (Corecursive (->) t (XNor a)) => [a] -> t
fromList :: forall t a. Corecursive (->) t (XNor a) => [a] -> t
fromList = Coalgebra (->) (XNor a) [a] -> [a] -> t
forall a. Coalgebra (->) (XNor a) a -> a -> t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
ana Coalgebra (->) (XNor a) [a]
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project

-- | An implementation of `IsList.fromListN` for `Steppable` fixed-points of
--  `XNor`.
--
--   This should return an empty structure if the `Int` is negative.
--
--   If the target structure isn’t `Steppable` or the target structure is
--  `Corecursive` (i.e., `Yaya.Unsafe.Fold.Applied.unsafeFromList` isn’t used),
--   then the default definition for `fromListN` should suffice.
fromListN :: (Steppable (->) t (XNor a)) => Int -> [a] -> t
fromListN :: forall t a. Steppable (->) t (XNor a) => Int -> [a] -> t
fromListN = Algebra (->) (Day Maybe (XNor a)) t -> Natural -> [a] -> t
forall t (f :: * -> *) u (g :: * -> *) a.
(Recursive (->) t f, Projectable (->) u g) =>
Algebra (->) (Day f g) a -> t -> u -> a
cata2 (Algebra (->) (XNor a) t
forall {k} (c :: k -> k -> *) (t :: k) (f :: k -> k).
Steppable c t f =>
Algebra c f t
embed Algebra (->) (XNor a) t
-> (Day Maybe (XNor a) t -> XNor a t)
-> Algebra (->) (Day Maybe (XNor a)) t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. Day Maybe (XNor a) t -> XNor a t
forall a b. Day Maybe (XNor a) b -> XNor a b
takeAvailable) (Natural -> [a] -> t) -> (Int -> Natural) -> Int -> [a] -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral @_ @Natural

-- | An implementation of `IsList.toList` for `Projectable` fixed-points of
--  `XNor`.
toList :: (Projectable (->) t (XNor a)) => t -> [a]
toList :: forall t a. Projectable (->) t (XNor a) => t -> [a]
toList = Coalgebra (->) (XNor a) t -> t -> [a]
forall a. Coalgebra (->) (XNor a) a -> a -> [a]
forall {k} {k1} (c :: k -> k1 -> *) (t :: k1) (f :: k -> k1)
       (a :: k).
Corecursive c t f =>
Coalgebra c f a -> c a t
ana Coalgebra (->) (XNor a) t
forall {k} {k1} (c :: k -> k1 -> *) (t :: k) (f :: k -> k1).
Projectable c t f =>
Coalgebra c f t
project

-- | This instance is safe, since both structures are lazy.
instance IsList (Nu (XNor a)) where
  type Item (Nu (XNor a)) = a
  fromList :: [Item (Nu (XNor a))] -> Nu (XNor a)
fromList = [a] -> Nu (XNor a)
[Item (Nu (XNor a))] -> Nu (XNor a)
forall t a. Corecursive (->) t (XNor a) => [a] -> t
fromList
  toList :: Nu (XNor a) -> [Item (Nu (XNor a))]
toList = Nu (XNor a) -> [a]
Nu (XNor a) -> [Item (Nu (XNor a))]
forall t a. Projectable (->) t (XNor a) => t -> [a]
toList