{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE NoStarIsType #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE DerivingVia #-}
module Data.Functor.Polynomial.Finitary.Class(
    FinitaryPolynomial(..)
) where

import Data.Functor.Identity
import GHC.Generics hiding (S,C,D)

import Data.Singletons
import Data.Polynomial
import Data.Functor.Polynomial.Finitary

-- | Non-zero polynomial functor
class Functor f => FinitaryPolynomial f where
    type PolyRep f :: P

    sPolyRep :: Sing (PolyRep f)
    toPoly :: f x -> Ev (PolyRep f) x
    fromPoly :: Ev (PolyRep f) x -> f x

instance SingI p => FinitaryPolynomial (Ev p) where
    type PolyRep (Ev p) = p
    sPolyRep :: Sing (PolyRep (Ev p))
sPolyRep = Sing p
Sing (PolyRep (Ev p))
forall {k} (a :: k). SingI a => Sing a
sing
    toPoly :: forall x. Ev p x -> Ev (PolyRep (Ev p)) x
toPoly = Ev p x -> Ev p x
Ev p x -> Ev (PolyRep (Ev p)) x
forall a. a -> a
id
    fromPoly :: forall x. Ev (PolyRep (Ev p)) x -> Ev p x
fromPoly = Ev p x -> Ev p x
Ev (PolyRep (Ev p)) x -> Ev p x
forall a. a -> a
id

instance FinitaryPolynomial Proxy where
    type PolyRep Proxy = U
    sPolyRep :: Sing (PolyRep Proxy)
sPolyRep = Sing (PolyRep Proxy)
SingP 'U
SingU
    toPoly :: forall x. Proxy x -> Ev (PolyRep Proxy) x
toPoly Proxy x
_ = Ev 'U x
Ev (PolyRep Proxy) x
forall x. Ev 'U x
End
    fromPoly :: forall x. Ev (PolyRep Proxy) x -> Proxy x
fromPoly Ev (PolyRep Proxy) x
_ = Proxy x
forall {k} (t :: k). Proxy t
Proxy
 
instance FinitaryPolynomial Identity where
    type PolyRep Identity = T U

    sPolyRep :: Sing (PolyRep Identity)
sPolyRep = SingP 'U -> SingP ('T 'U)
forall (p :: P). SingP p -> SingP ('T p)
SingT SingP 'U
SingU
    toPoly :: forall x. Identity x -> Ev (PolyRep Identity) x
toPoly (Identity x
x) = x
x x -> Ev 'U x -> Ev ('T 'U) x
forall x (p1 :: P). x -> Ev p1 x -> Ev ('T p1) x
::: Ev 'U x
forall x. Ev 'U x
End
    fromPoly :: forall x. Ev (PolyRep Identity) x -> Identity x
fromPoly (x
x ::: Ev p1 x
End) = x -> Identity x
forall a. a -> Identity a
Identity x
x

instance FinitaryPolynomial U1 where
    type PolyRep U1 = U
    sPolyRep :: Sing (PolyRep U1)
sPolyRep = Sing (PolyRep U1)
SingP 'U
SingU
    toPoly :: forall x. U1 x -> Ev (PolyRep U1) x
toPoly U1 x
_ = Ev 'U x
Ev (PolyRep U1) x
forall x. Ev 'U x
End
    fromPoly :: forall x. Ev (PolyRep U1) x -> U1 x
fromPoly Ev (PolyRep U1) x
_ = U1 x
forall k (p :: k). U1 p
U1

-- | Quick&dirty alternative to @Finitary c => FinitaryPolynomial (K1 i c)@
instance FinitaryPolynomial (K1 i ()) where
    type PolyRep (K1 i ()) = U
    sPolyRep :: Sing (PolyRep (K1 i ()))
sPolyRep = Sing (PolyRep (K1 i ()))
SingP 'U
SingU
    toPoly :: forall x. K1 i () x -> Ev (PolyRep (K1 i ())) x
toPoly K1 i () x
_ = Ev 'U x
Ev (PolyRep (K1 i ())) x
forall x. Ev 'U x
End
    fromPoly :: forall x. Ev (PolyRep (K1 i ())) x -> K1 i () x
fromPoly Ev (PolyRep (K1 i ())) x
_ = () -> K1 i () x
forall k i c (p :: k). c -> K1 i c p
K1 ()

-- | Quick&dirty alternative to @Finitary c => FinitaryPolynomial (K1 i c)@
instance FinitaryPolynomial (K1 i Bool) where
    type PolyRep (K1 i Bool) = S U
    sPolyRep :: Sing (PolyRep (K1 i Bool))
sPolyRep = Sing ('S 'U)
Sing (PolyRep (K1 i Bool))
forall {k} (a :: k). SingI a => Sing a
sing

    toPoly :: forall x. K1 i Bool x -> Ev (PolyRep (K1 i Bool)) x
toPoly (K1 Bool
b) = if Bool
b then Ev 'U x -> Ev ('S 'U) x
forall (p1 :: P) x. Ev p1 x -> Ev ('S p1) x
Go Ev 'U x
forall x. Ev 'U x
End else Ev ('S 'U) x
Ev (PolyRep (K1 i Bool)) x
forall (p1 :: P) x. Ev ('S p1) x
Stop
    fromPoly :: forall x. Ev (PolyRep (K1 i Bool)) x -> K1 i Bool x
fromPoly Ev (PolyRep (K1 i Bool)) x
Stop = Bool -> K1 i Bool x
forall k i c (p :: k). c -> K1 i c p
K1 Bool
False
    fromPoly (Go Ev p1 x
_) = Bool -> K1 i Bool x
forall k i c (p :: k). c -> K1 i c p
K1 Bool
True

instance FinitaryPolynomial f => FinitaryPolynomial (M1 i m f) where
    type PolyRep (M1 _ _ f) = PolyRep f
    sPolyRep :: Sing (PolyRep (M1 i m f))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f
    toPoly :: forall x. M1 i m f x -> Ev (PolyRep (M1 i m f)) x
toPoly = f x -> Ev (PolyRep f) x
forall x. f x -> Ev (PolyRep f) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly (f x -> Ev (PolyRep f) x)
-> (M1 i m f x -> f x) -> M1 i m f x -> Ev (PolyRep f) x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. M1 i m f x -> f x
forall k i (c :: Meta) (f :: k -> Type) (p :: k). M1 i c f p -> f p
unM1
    fromPoly :: forall x. Ev (PolyRep (M1 i m f)) x -> M1 i m f x
fromPoly = f x -> M1 i m f x
forall k i (c :: Meta) (f :: k -> Type) (p :: k). f p -> M1 i c f p
M1 (f x -> M1 i m f x)
-> (Ev (PolyRep f) x -> f x) -> Ev (PolyRep f) x -> M1 i m f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ev (PolyRep f) x -> f x
forall x. Ev (PolyRep f) x -> f x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly

instance FinitaryPolynomial f => FinitaryPolynomial (Rec1 f) where
    type PolyRep (Rec1 f) = PolyRep f
    sPolyRep :: Sing (PolyRep (Rec1 f))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f
    toPoly :: forall x. Rec1 f x -> Ev (PolyRep (Rec1 f)) x
toPoly = f x -> Ev (PolyRep f) x
forall x. f x -> Ev (PolyRep f) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly (f x -> Ev (PolyRep f) x)
-> (Rec1 f x -> f x) -> Rec1 f x -> Ev (PolyRep f) x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rec1 f x -> f x
forall k (f :: k -> Type) (p :: k). Rec1 f p -> f p
unRec1
    fromPoly :: forall x. Ev (PolyRep (Rec1 f)) x -> Rec1 f x
fromPoly = f x -> Rec1 f x
forall k (f :: k -> Type) (p :: k). f p -> Rec1 f p
Rec1 (f x -> Rec1 f x)
-> (Ev (PolyRep f) x -> f x) -> Ev (PolyRep f) x -> Rec1 f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ev (PolyRep f) x -> f x
forall x. Ev (PolyRep f) x -> f x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly

instance (FinitaryPolynomial f, FinitaryPolynomial g) => FinitaryPolynomial (f :+: g) where
    type PolyRep (f :+: g) = PolyRep f + PolyRep g

    sPolyRep :: Sing (PolyRep (f :+: g))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f Sing (PolyRep f)
-> Sing (PolyRep g) -> Sing (PolyRep f + PolyRep g)
forall k (x :: k) (y :: k).
SPlus k =>
Sing x -> Sing y -> Sing (x + y)
forall (x :: P) (y :: P). Sing x -> Sing y -> Sing (x + y)
%+ forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g

    toPoly :: forall x. (:+:) f g x -> Ev (PolyRep (f :+: g)) x
toPoly (L1 f x
fx) = Sing (PolyRep f)
-> Sing (PolyRep g)
-> (:+:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
-> Ev (PolyRep f + PolyRep g) x
forall (p :: P) (q :: P) x.
Sing p -> Sing q -> (:+:) (Ev p) (Ev q) x -> Ev (p + q) x
fromSum (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) (Ev (PolyRep f) x -> (:+:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
f p -> (:+:) f g p
L1 (f x -> Ev (PolyRep f) x
forall x. f x -> Ev (PolyRep f) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly f x
fx))
    toPoly (R1 g x
gx) = Sing (PolyRep f)
-> Sing (PolyRep g)
-> (:+:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
-> Ev (PolyRep f + PolyRep g) x
forall (p :: P) (q :: P) x.
Sing p -> Sing q -> (:+:) (Ev p) (Ev q) x -> Ev (p + q) x
fromSum (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) (Ev (PolyRep g) x -> (:+:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
g p -> (:+:) f g p
R1 (g x -> Ev (PolyRep g) x
forall x. g x -> Ev (PolyRep g) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly g x
gx))

    fromPoly :: forall x. Ev (PolyRep (f :+: g)) x -> (:+:) f g x
fromPoly Ev (PolyRep (f :+: g)) x
hx = case Sing (PolyRep f)
-> Sing (PolyRep g)
-> Ev (PolyRep f + PolyRep g) x
-> (:+:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
forall (p :: P) (q :: P) x.
Sing p -> Sing q -> Ev (p + q) x -> (:+:) (Ev p) (Ev q) x
toSum (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) Ev (PolyRep f + PolyRep g) x
Ev (PolyRep (f :+: g)) x
hx of
        L1 Ev (PolyRep f) x
fx -> f x -> (:+:) f g x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
f p -> (:+:) f g p
L1 (Ev (PolyRep f) x -> f x
forall x. Ev (PolyRep f) x -> f x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly Ev (PolyRep f) x
fx)
        R1 Ev (PolyRep g) x
gx -> g x -> (:+:) f g x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
g p -> (:+:) f g p
R1 (Ev (PolyRep g) x -> g x
forall x. Ev (PolyRep g) x -> g x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly Ev (PolyRep g) x
gx)

instance (FinitaryPolynomial f, FinitaryPolynomial g) => FinitaryPolynomial (f :*: g) where
    type PolyRep (f :*: g) = PolyRep f * PolyRep g
    
    sPolyRep :: Sing (PolyRep (f :*: g))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f Sing (PolyRep f)
-> Sing (PolyRep g) -> Sing (PolyRep f * PolyRep g)
forall k (x :: k) (y :: k).
STimes k =>
Sing x -> Sing y -> Sing (x * y)
forall (x :: P) (y :: P). Sing x -> Sing y -> Sing (x * y)
%* forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g
    toPoly :: forall x. (:*:) f g x -> Ev (PolyRep (f :*: g)) x
toPoly (f x
fx :*: g x
gx) = Sing (PolyRep f)
-> Sing (PolyRep g)
-> (:*:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
-> Ev (PolyRep f * PolyRep g) x
forall (p :: P) (q :: P) x.
Sing p -> Sing q -> (:*:) (Ev p) (Ev q) x -> Ev (p * q) x
fromProduct (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) (f x -> Ev (PolyRep f) x
forall x. f x -> Ev (PolyRep f) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly f x
fx Ev (PolyRep f) x
-> Ev (PolyRep g) x -> (:*:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
f p -> g p -> (:*:) f g p
:*: g x -> Ev (PolyRep g) x
forall x. g x -> Ev (PolyRep g) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly g x
gx)
    fromPoly :: forall x. Ev (PolyRep (f :*: g)) x -> (:*:) f g x
fromPoly Ev (PolyRep (f :*: g)) x
hx = case Sing (PolyRep f)
-> Sing (PolyRep g)
-> Ev (PolyRep f * PolyRep g) x
-> (:*:) (Ev (PolyRep f)) (Ev (PolyRep g)) x
forall (p :: P) (q :: P) x.
Sing p -> Sing q -> Ev (p * q) x -> (:*:) (Ev p) (Ev q) x
toProduct (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) Ev (PolyRep f * PolyRep g) x
Ev (PolyRep (f :*: g)) x
hx of
        (Ev (PolyRep f) x
fx :*: Ev (PolyRep g) x
gx) -> Ev (PolyRep f) x -> f x
forall x. Ev (PolyRep f) x -> f x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly Ev (PolyRep f) x
fx f x -> g x -> (:*:) f g x
forall k (f :: k -> Type) (g :: k -> Type) (p :: k).
f p -> g p -> (:*:) f g p
:*: Ev (PolyRep g) x -> g x
forall x. Ev (PolyRep g) x -> g x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly Ev (PolyRep g) x
gx

instance FinitaryPolynomial Par1 where
    type PolyRep Par1 = T U
    sPolyRep :: Sing (PolyRep Par1)
sPolyRep = SingP 'U -> SingP ('T 'U)
forall (p :: P). SingP p -> SingP ('T p)
SingT SingP 'U
SingU

    toPoly :: forall x. Par1 x -> Ev (PolyRep Par1) x
toPoly (Par1 x
x) = x
x x -> Ev 'U x -> Ev ('T 'U) x
forall x (p1 :: P). x -> Ev p1 x -> Ev ('T p1) x
::: Ev 'U x
forall x. Ev 'U x
End
    fromPoly :: forall x. Ev (PolyRep Par1) x -> Par1 x
fromPoly (x
x ::: Ev p1 x
End) = x -> Par1 x
forall p. p -> Par1 p
Par1 x
x

instance (FinitaryPolynomial f, FinitaryPolynomial g) => FinitaryPolynomial (f :.: g) where
    type PolyRep (f :.: g) = PolyRep f << PolyRep g
    sPolyRep :: Sing (PolyRep (f :.: g))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f Sing (PolyRep f)
-> Sing (PolyRep g) -> Sing (PolyRep f << PolyRep g)
forall k (x :: k) (y :: k).
SCompose k =>
Sing x -> Sing y -> Sing (x << y)
forall (x :: P) (y :: P). Sing x -> Sing y -> Sing (x << y)
%<< forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g

    toPoly :: forall x. (:.:) f g x -> Ev (PolyRep (f :.: g)) x
toPoly (Comp1 f (g x)
fgx) = SingP (PolyRep f)
-> SingP (PolyRep g)
-> Ev (PolyRep f) (Ev (PolyRep g) x)
-> Ev (PolyRep f << PolyRep g) x
forall (p :: P) (q :: P) x.
SingP p -> SingP q -> Ev p (Ev q x) -> Ev (p << q) x
fromComp (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) (f (Ev (PolyRep g) x) -> Ev (PolyRep f) (Ev (PolyRep g) x)
forall x. f x -> Ev (PolyRep f) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly ((g x -> Ev (PolyRep g) x) -> f (g x) -> f (Ev (PolyRep g) x)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap g x -> Ev (PolyRep g) x
forall x. g x -> Ev (PolyRep g) x
forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly f (g x)
fgx))
    fromPoly :: forall x. Ev (PolyRep (f :.: g)) x -> (:.:) f g x
fromPoly Ev (PolyRep (f :.: g)) x
hx = f (g x) -> (:.:) f g x
forall k2 k1 (f :: k2 -> Type) (g :: k1 -> k2) (p :: k1).
f (g p) -> (:.:) f g p
Comp1 (f (g x) -> (:.:) f g x) -> f (g x) -> (:.:) f g x
forall a b. (a -> b) -> a -> b
$ (Ev (PolyRep g) x -> g x) -> f (Ev (PolyRep g) x) -> f (g x)
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly @g) (f (Ev (PolyRep g) x) -> f (g x))
-> f (Ev (PolyRep g) x) -> f (g x)
forall a b. (a -> b) -> a -> b
$ forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly @f (Ev (PolyRep f) (Ev (PolyRep g) x) -> f (Ev (PolyRep g) x))
-> Ev (PolyRep f) (Ev (PolyRep g) x) -> f (Ev (PolyRep g) x)
forall a b. (a -> b) -> a -> b
$ SingP (PolyRep f)
-> SingP (PolyRep g)
-> Ev (PolyRep f << PolyRep g) x
-> Ev (PolyRep f) (Ev (PolyRep g) x)
forall (p :: P) (q :: P) x.
SingP p -> SingP q -> Ev (p << q) x -> Ev p (Ev q x)
toComp (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @f) (forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @g) Ev (PolyRep f << PolyRep g) x
Ev (PolyRep (f :.: g)) x
hx

-- via Generically1
instance (Generic1 f, FinitaryPolynomial (Rep1 f)) => FinitaryPolynomial (Generically1 f) where
    type PolyRep (Generically1 f) = PolyRep (Rep1 f)
    sPolyRep :: Sing (PolyRep (Generically1 f))
sPolyRep = forall (f :: Type -> Type).
FinitaryPolynomial f =>
Sing (PolyRep f)
sPolyRep @(Rep1 f)
    toPoly :: forall x. Generically1 f x -> Ev (PolyRep (Generically1 f)) x
toPoly (Generically1 f x
fx) = forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
f x -> Ev (PolyRep f) x
toPoly @(Rep1 f) (Rep1 f x -> Ev (PolyRep (Generically1 f)) x)
-> (f x -> Rep1 f x) -> f x -> Ev (PolyRep (Generically1 f)) x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f x -> Rep1 f x
forall a. f a -> Rep1 f a
forall k (f :: k -> Type) (a :: k). Generic1 f => f a -> Rep1 f a
from1 (f x -> Ev (PolyRep (Generically1 f)) x)
-> f x -> Ev (PolyRep (Generically1 f)) x
forall a b. (a -> b) -> a -> b
$ f x
fx
    fromPoly :: forall x. Ev (PolyRep (Generically1 f)) x -> Generically1 f x
fromPoly = f x -> Generically1 f x
forall {k} (f :: k -> Type) (a :: k). f a -> Generically1 f a
Generically1 (f x -> Generically1 f x)
-> (Ev (PolyRep (Rep1 f)) x -> f x)
-> Ev (PolyRep (Rep1 f)) x
-> Generically1 f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep1 f x -> f x
forall a. Rep1 f a -> f a
forall k (f :: k -> Type) (a :: k). Generic1 f => Rep1 f a -> f a
to1 (Rep1 f x -> f x)
-> (Ev (PolyRep (Rep1 f)) x -> Rep1 f x)
-> Ev (PolyRep (Rep1 f)) x
-> f x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Type -> Type) x.
FinitaryPolynomial f =>
Ev (PolyRep f) x -> f x
fromPoly @(Rep1 f)

deriving
  via Generically1 Maybe
  instance FinitaryPolynomial Maybe