{-# LANGUAGE TypeFamilies #-}
{- |
Simplify running the @render@ function by handling passing of parameters.
-}
module Data.Array.Knead.Symbolic.Render (
   run,
   MarshalExp(..),
   MapFilter(..),
   FilterOuter(..),
   Scatter(..),
   ScatterMaybe(..),
   MapAccumLSimple(..),
   MapAccumLSequence(..),
   MapAccumL(..),
   FoldOuterL(..),
   AddDimension(..),
   ) where

import qualified Data.Array.Knead.Parameterized.PhysicalHull as PhysHullP
import qualified Data.Array.Knead.Parameterized.Physical as PhysP
import qualified Data.Array.Knead.Parameterized.Private as Sym
import qualified Data.Array.Knead.Symbolic.Physical as Phys
import qualified Data.Array.Knead.Symbolic.Private as Core
import qualified Data.Array.Knead.Shape as Shape
import Data.Array.Knead.Parameterized.PhysicalHull
         (MapFilter, FilterOuter,
          MapAccumLSimple, MapAccumLSequence, MapAccumL, FoldOuterL,
          Scatter, ScatterMaybe, AddDimension)
import Data.Array.Knead.Expression (Exp, )

import qualified LLVM.DSL.Parameter as Param

import qualified LLVM.Extra.Multi.Value.Storable as Storable
import qualified LLVM.Extra.Multi.Value.Marshal as Marshal
import qualified LLVM.Extra.Multi.Value as MultiValue

import Control.Arrow (arr, )
import Control.Applicative (liftA2, liftA3, pure, (<*>), )

import Data.Tuple.HT (fst3, snd3, thd3, )

import Prelude2010
import Prelude ()



class C f where
   type Plain f
   build :: Sym.Hull p f -> IO (p -> Plain f)

instance
   (Marshal.C sh, Shape.C sh, Storable.C a) =>
      C (Core.Array sh a) where
   type Plain (Core.Array sh a) = IO (Phys.Array sh a)
   build :: forall p. Hull p (Array sh a) -> IO (p -> Plain (Array sh a))
build = Hull p (Array sh a) -> IO (p -> IO (Array sh a))
Hull p (Array sh a) -> IO (p -> Plain (Array sh a))
forall sh ix a p.
(C sh, Index sh ~ ix, C sh, C a) =>
Hull p (Array sh a) -> IO (p -> IO (Array sh a))
PhysHullP.render

instance
   (Shape.Sequence n, Marshal.C n,
    Storable.C b, MultiValue.C b) =>
      C (MapFilter n a b) where
   type Plain (MapFilter n a b) = IO (Phys.Array n b)
   build :: forall p.
Hull p (MapFilter n a b) -> IO (p -> Plain (MapFilter n a b))
build = Hull p (MapFilter n a b) -> IO (p -> IO (Array n b))
Hull p (MapFilter n a b) -> IO (p -> Plain (MapFilter n a b))
forall n b p a.
(Sequence n, C n, C b) =>
Hull p (MapFilter n a b) -> IO (p -> IO (Array n b))
PhysHullP.mapFilter

instance
   (Shape.Sequence n, Marshal.C n,
    Shape.C sh, Marshal.C sh,
    Storable.C a, MultiValue.C a) =>
      C (FilterOuter n sh a) where
   type Plain (FilterOuter n sh a) = IO (Phys.Array (n,sh) a)
   build :: forall p.
Hull p (FilterOuter n sh a) -> IO (p -> Plain (FilterOuter n sh a))
build = Hull p (FilterOuter n sh a) -> IO (p -> IO (Array (n, sh) a))
Hull p (FilterOuter n sh a) -> IO (p -> Plain (FilterOuter n sh a))
forall n sh a p.
(Sequence n, C n, C sh, C sh, C a) =>
Hull p (FilterOuter n sh a) -> IO (p -> IO (Array (n, sh) a))
PhysHullP.filterOuter

instance
   (Shape.C sh0, Marshal.C sh0,
    Shape.C sh1, Marshal.C sh1,
    Storable.C a, MultiValue.C a) =>
      C (Scatter sh0 sh1 a) where
   type Plain (Scatter sh0 sh1 a) = IO (Phys.Array sh1 a)
   build :: forall p.
Hull p (Scatter sh0 sh1 a) -> IO (p -> Plain (Scatter sh0 sh1 a))
build = Hull p (Scatter sh0 sh1 a) -> IO (p -> IO (Array sh1 a))
Hull p (Scatter sh0 sh1 a) -> IO (p -> Plain (Scatter sh0 sh1 a))
forall sh0 ix0 sh1 ix1 a p.
(C sh0, Index sh0 ~ ix0, C sh1, Index sh1 ~ ix1, C sh1, C a) =>
Hull p (Scatter sh0 sh1 a) -> IO (p -> IO (Array sh1 a))
PhysHullP.scatter

instance
   (Shape.C sh0, Marshal.C sh0,
    Shape.C sh1, Marshal.C sh1,
    Storable.C a, MultiValue.C a) =>
      C (ScatterMaybe sh0 sh1 a) where
   type Plain (ScatterMaybe sh0 sh1 a) = IO (Phys.Array sh1 a)
   build :: forall p.
Hull p (ScatterMaybe sh0 sh1 a)
-> IO (p -> Plain (ScatterMaybe sh0 sh1 a))
build = Hull p (ScatterMaybe sh0 sh1 a) -> IO (p -> IO (Array sh1 a))
Hull p (ScatterMaybe sh0 sh1 a)
-> IO (p -> Plain (ScatterMaybe sh0 sh1 a))
forall sh0 ix0 sh1 ix1 a p.
(C sh0, Index sh0 ~ ix0, C sh1, Index sh1 ~ ix1, C sh1, C a) =>
Hull p (ScatterMaybe sh0 sh1 a) -> IO (p -> IO (Array sh1 a))
PhysHullP.scatterMaybe

instance
   (Shape.C sh, Marshal.C sh,
    Shape.C n, Marshal.C n,
    MultiValue.C acc,
    Storable.C a, MultiValue.C a,
    Storable.C b, MultiValue.C b) =>
      C (MapAccumLSimple sh n acc a b) where
   type Plain (MapAccumLSimple sh n acc a b) = IO (Phys.Array (sh,n) b)
   build :: forall p.
Hull p (MapAccumLSimple sh n acc a b)
-> IO (p -> Plain (MapAccumLSimple sh n acc a b))
build = Hull p (MapAccumLSimple sh n acc a b)
-> IO (p -> IO (Array (sh, n) b))
Hull p (MapAccumLSimple sh n acc a b)
-> IO (p -> Plain (MapAccumLSimple sh n acc a b))
forall sh n acc a b p.
(C sh, C sh, C n, C n, C acc, C a, C b) =>
Hull p (MapAccumLSimple sh n acc a b)
-> IO (p -> IO (Array (sh, n) b))
PhysHullP.mapAccumLSimple

instance
   (Shape.C n, Marshal.C n,
    MultiValue.C acc,
    Storable.C final, MultiValue.C final,
    Storable.C a, MultiValue.C a,
    Storable.C b, MultiValue.C b) =>
      C (MapAccumLSequence n acc final a b) where
   type Plain (MapAccumLSequence n acc final a b) = IO (final, Phys.Array n b)
   build :: forall p.
Hull p (MapAccumLSequence n acc final a b)
-> IO (p -> Plain (MapAccumLSequence n acc final a b))
build = Hull p (MapAccumLSequence n acc final a b)
-> IO (p -> IO (final, Array n b))
Hull p (MapAccumLSequence n acc final a b)
-> IO (p -> Plain (MapAccumLSequence n acc final a b))
forall n acc final a b p.
(C n, C n, C acc, C final, C final, C a, C b) =>
Hull p (MapAccumLSequence n acc final a b)
-> IO (p -> IO (final, Array n b))
PhysHullP.mapAccumLSequence

instance
   (Shape.C sh, Marshal.C sh,
    Shape.C n, Marshal.C n,
    MultiValue.C acc,
    Storable.C final, MultiValue.C final,
    Storable.C a, MultiValue.C a,
    Storable.C b, MultiValue.C b) =>
      C (MapAccumL sh n acc final a b) where
   type Plain (MapAccumL sh n acc final a b) =
            IO (Phys.Array sh final, Phys.Array (sh,n) b)
   build :: forall p.
Hull p (MapAccumL sh n acc final a b)
-> IO (p -> Plain (MapAccumL sh n acc final a b))
build = Hull p (MapAccumL sh n acc final a b)
-> IO (p -> IO (Array sh final, Array (sh, n) b))
Hull p (MapAccumL sh n acc final a b)
-> IO (p -> Plain (MapAccumL sh n acc final a b))
forall sh n acc final a b p.
(C sh, C sh, C n, C n, C acc, C final, C final, C a, C b) =>
Hull p (MapAccumL sh n acc final a b)
-> IO (p -> IO (Array sh final, Array (sh, n) b))
PhysHullP.mapAccumL

instance
   (Shape.C n, Marshal.C n,
    Shape.C sh, Marshal.C sh,
    Storable.C a, MultiValue.C a,
    Storable.C b, MultiValue.C b) =>
      C (FoldOuterL n sh a b) where
   type Plain (FoldOuterL n sh a b) = IO (Phys.Array sh a)
   build :: forall p.
Hull p (FoldOuterL n sh a b)
-> IO (p -> Plain (FoldOuterL n sh a b))
build = Hull p (FoldOuterL n sh a b) -> IO (p -> IO (Array sh a))
Hull p (FoldOuterL n sh a b)
-> IO (p -> Plain (FoldOuterL n sh a b))
forall n sh a p b.
(C n, C n, C sh, C sh, C a) =>
Hull p (FoldOuterL n sh a b) -> IO (p -> IO (Array sh a))
PhysHullP.foldOuterL

instance
   (Shape.C sh, Marshal.C sh,
    Shape.C n, Marshal.C n,
    Storable.C b, MultiValue.C b) =>
      C (AddDimension sh n a b) where
   type Plain (AddDimension sh n a b) = IO (Phys.Array (sh,n) b)
   build :: forall p.
Hull p (AddDimension sh n a b)
-> IO (p -> Plain (AddDimension sh n a b))
build = Hull p (AddDimension sh n a b) -> IO (p -> IO (Array (sh, n) b))
Hull p (AddDimension sh n a b)
-> IO (p -> Plain (AddDimension sh n a b))
forall sh n b p a.
(C sh, C sh, C n, C n, C b) =>
Hull p (AddDimension sh n a b) -> IO (p -> IO (Array (sh, n) b))
PhysHullP.addDimension


singleton :: Exp a -> Core.Array () a
singleton :: forall a. Exp a -> Array () a
singleton = Exp a -> Array () a
forall sh a. Scalar sh => Exp a -> Array sh a
Core.fromScalar

instance (Storable.C a, MultiValue.C a) => C (Exp a) where
   type Plain (Exp a) = IO a
   build :: forall p. Hull p (Exp a) -> IO (p -> Plain (Exp a))
build = Array p () a -> IO (p -> IO a)
forall z a p. (Scalar z, C a, C a) => Array p z a -> IO (p -> IO a)
PhysP.the (Array p () a -> IO (p -> IO a))
-> (Hull p (Exp a) -> Array p () a)
-> Hull p (Exp a)
-> IO (p -> IO a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hull p (Array () a) -> Array p () a
forall p sh a. Hull p (Array sh a) -> Array p sh a
Sym.runHull (Hull p (Array () a) -> Array p () a)
-> (Hull p (Exp a) -> Hull p (Array () a))
-> Hull p (Exp a)
-> Array p () a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Exp a -> Array () a) -> Hull p (Exp a) -> Hull p (Array () a)
forall a b. (a -> b) -> Hull p a -> Hull p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp a -> Array () a
forall a. Exp a -> Array () a
singleton

newtype MarshalExp a = MarshalExp {forall a. MarshalExp a -> Exp a
getMarshalExp :: Exp a}

instance (Marshal.C a) => C (MarshalExp a) where
   type Plain (MarshalExp a) = IO a
   build :: forall p. Hull p (MarshalExp a) -> IO (p -> Plain (MarshalExp a))
build = Array p () a -> IO (p -> IO a)
forall z a p. (Scalar z, C a) => Array p z a -> IO (p -> IO a)
PhysP.theMarshal (Array p () a -> IO (p -> IO a))
-> (Hull p (MarshalExp a) -> Array p () a)
-> Hull p (MarshalExp a)
-> IO (p -> IO a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Hull p (Array () a) -> Array p () a
forall p sh a. Hull p (Array sh a) -> Array p sh a
Sym.runHull (Hull p (Array () a) -> Array p () a)
-> (Hull p (MarshalExp a) -> Hull p (Array () a))
-> Hull p (MarshalExp a)
-> Array p () a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MarshalExp a -> Array () a)
-> Hull p (MarshalExp a) -> Hull p (Array () a)
forall a b. (a -> b) -> Hull p a -> Hull p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Exp a -> Array () a
forall a. Exp a -> Array () a
singleton (Exp a -> Array () a)
-> (MarshalExp a -> Exp a) -> MarshalExp a -> Array () a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MarshalExp a -> Exp a
forall a. MarshalExp a -> Exp a
getMarshalExp)

instance (Argument arg, C func) => C (arg -> func) where
   type Plain (arg -> func) = PlainArg arg -> Plain func
   build :: forall p. Hull p (arg -> func) -> IO (p -> Plain (arg -> func))
build Hull p (arg -> func)
f = (((p, PlainArg arg) -> Plain func) -> p -> Plain (arg -> func))
-> IO ((p, PlainArg arg) -> Plain func)
-> IO (p -> Plain (arg -> func))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((p, PlainArg arg) -> Plain func) -> p -> Plain (arg -> func)
((p, PlainArg arg) -> Plain func)
-> p -> PlainArg arg -> Plain func
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (IO ((p, PlainArg arg) -> Plain func)
 -> IO (p -> Plain (arg -> func)))
-> IO ((p, PlainArg arg) -> Plain func)
-> IO (p -> Plain (arg -> func))
forall a b. (a -> b) -> a -> b
$ Hull (p, PlainArg arg) func -> IO ((p, PlainArg arg) -> Plain func)
forall p. Hull p func -> IO (p -> Plain func)
forall f p. C f => Hull p f -> IO (p -> Plain f)
build (Hull (p, PlainArg arg) func
 -> IO ((p, PlainArg arg) -> Plain func))
-> Hull (p, PlainArg arg) func
-> IO ((p, PlainArg arg) -> Plain func)
forall a b. (a -> b) -> a -> b
$ ((p, PlainArg arg) -> p)
-> Hull p (arg -> func) -> Hull (p, PlainArg arg) (arg -> func)
forall q p a. (q -> p) -> Hull p a -> Hull q a
Sym.extendHull (p, PlainArg arg) -> p
forall a b. (a, b) -> a
fst Hull p (arg -> func)
f Hull (p, PlainArg arg) (arg -> func)
-> Hull (p, PlainArg arg) arg -> Hull (p, PlainArg arg) func
forall a b.
Hull (p, PlainArg arg) (a -> b)
-> Hull (p, PlainArg arg) a -> Hull (p, PlainArg arg) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> T (p, PlainArg arg) (PlainArg arg) -> Hull (p, PlainArg arg) arg
forall p. T p (PlainArg arg) -> Hull p arg
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (((p, PlainArg arg) -> PlainArg arg)
-> T (p, PlainArg arg) (PlainArg arg)
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (p, PlainArg arg) -> PlainArg arg
forall a b. (a, b) -> b
snd)


class Argument arg where
   type PlainArg arg
   buildArg :: Param.T p (PlainArg arg) -> Sym.Hull p arg

instance
   (Shape.C sh, Marshal.C sh, Storable.C a) =>
      Argument (Core.Array sh a) where
   type PlainArg (Core.Array sh a) = Phys.Array sh a
   buildArg :: forall p. T p (PlainArg (Array sh a)) -> Hull p (Array sh a)
buildArg = Array p sh a -> Hull p (Array sh a)
forall p sh a. Array p sh a -> Hull p (Array sh a)
Sym.arrayHull (Array p sh a -> Hull p (Array sh a))
-> (T p (Array sh a) -> Array p sh a)
-> T p (Array sh a)
-> Hull p (Array sh a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T p (Array sh a) -> Array p sh a
forall sh a p.
(C sh, C sh, C a) =>
T p (Array sh a) -> Array p sh a
PhysP.feed

instance (Marshal.C a) => Argument (Exp a) where
   type PlainArg (Exp a) = a
   buildArg :: forall p. T p (PlainArg (Exp a)) -> Hull p (Exp a)
buildArg = Tunnel p a -> Hull p (Exp a)
forall p sl. Tunnel p sl -> Hull p (Exp sl)
Sym.expHull (Tunnel p a -> Hull p (Exp a))
-> (T p a -> Tunnel p a) -> T p a -> Hull p (Exp a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T p a -> Tunnel p a
forall a p. C a => T p a -> Tunnel p a
Sym.expParam

instance (Argument a, Argument b) => Argument (a,b) where
   type PlainArg (a,b) = (PlainArg a, PlainArg b)
   buildArg :: forall p. T p (PlainArg (a, b)) -> Hull p (a, b)
buildArg T p (PlainArg (a, b))
p = (a -> b -> (a, b)) -> Hull p a -> Hull p b -> Hull p (a, b)
forall a b c. (a -> b -> c) -> Hull p a -> Hull p b -> Hull p c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,) (T p (PlainArg a) -> Hull p a
forall p. T p (PlainArg a) -> Hull p a
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (T p (PlainArg a) -> Hull p a) -> T p (PlainArg a) -> Hull p a
forall a b. (a -> b) -> a -> b
$ ((PlainArg a, PlainArg b) -> PlainArg a)
-> T p (PlainArg a, PlainArg b) -> T p (PlainArg a)
forall a b. (a -> b) -> T p a -> T p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PlainArg a, PlainArg b) -> PlainArg a
forall a b. (a, b) -> a
fst T p (PlainArg a, PlainArg b)
T p (PlainArg (a, b))
p) (T p (PlainArg b) -> Hull p b
forall p. T p (PlainArg b) -> Hull p b
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (T p (PlainArg b) -> Hull p b) -> T p (PlainArg b) -> Hull p b
forall a b. (a -> b) -> a -> b
$ ((PlainArg a, PlainArg b) -> PlainArg b)
-> T p (PlainArg a, PlainArg b) -> T p (PlainArg b)
forall a b. (a -> b) -> T p a -> T p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PlainArg a, PlainArg b) -> PlainArg b
forall a b. (a, b) -> b
snd T p (PlainArg a, PlainArg b)
T p (PlainArg (a, b))
p)

instance (Argument a, Argument b, Argument c) => Argument (a,b,c) where
   type PlainArg (a,b,c) = (PlainArg a, PlainArg b, PlainArg c)
   buildArg :: forall p. T p (PlainArg (a, b, c)) -> Hull p (a, b, c)
buildArg T p (PlainArg (a, b, c))
p =
      (a -> b -> c -> (a, b, c))
-> Hull p a -> Hull p b -> Hull p c -> Hull p (a, b, c)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (,,)
         (T p (PlainArg a) -> Hull p a
forall p. T p (PlainArg a) -> Hull p a
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (T p (PlainArg a) -> Hull p a) -> T p (PlainArg a) -> Hull p a
forall a b. (a -> b) -> a -> b
$ ((PlainArg a, PlainArg b, PlainArg c) -> PlainArg a)
-> T p (PlainArg a, PlainArg b, PlainArg c) -> T p (PlainArg a)
forall a b. (a -> b) -> T p a -> T p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PlainArg a, PlainArg b, PlainArg c) -> PlainArg a
forall a b c. (a, b, c) -> a
fst3 T p (PlainArg a, PlainArg b, PlainArg c)
T p (PlainArg (a, b, c))
p) (T p (PlainArg b) -> Hull p b
forall p. T p (PlainArg b) -> Hull p b
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (T p (PlainArg b) -> Hull p b) -> T p (PlainArg b) -> Hull p b
forall a b. (a -> b) -> a -> b
$ ((PlainArg a, PlainArg b, PlainArg c) -> PlainArg b)
-> T p (PlainArg a, PlainArg b, PlainArg c) -> T p (PlainArg b)
forall a b. (a -> b) -> T p a -> T p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PlainArg a, PlainArg b, PlainArg c) -> PlainArg b
forall a b c. (a, b, c) -> b
snd3 T p (PlainArg a, PlainArg b, PlainArg c)
T p (PlainArg (a, b, c))
p) (T p (PlainArg c) -> Hull p c
forall p. T p (PlainArg c) -> Hull p c
forall arg p. Argument arg => T p (PlainArg arg) -> Hull p arg
buildArg (T p (PlainArg c) -> Hull p c) -> T p (PlainArg c) -> Hull p c
forall a b. (a -> b) -> a -> b
$ ((PlainArg a, PlainArg b, PlainArg c) -> PlainArg c)
-> T p (PlainArg a, PlainArg b, PlainArg c) -> T p (PlainArg c)
forall a b. (a -> b) -> T p a -> T p b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (PlainArg a, PlainArg b, PlainArg c) -> PlainArg c
forall a b c. (a, b, c) -> c
thd3 T p (PlainArg a, PlainArg b, PlainArg c)
T p (PlainArg (a, b, c))
p)


run :: (C f) => f -> IO (Plain f)
run :: forall f. C f => f -> IO (Plain f)
run f
f = ((() -> Plain f) -> Plain f) -> IO (() -> Plain f) -> IO (Plain f)
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((() -> Plain f) -> () -> Plain f
forall a b. (a -> b) -> a -> b
$ ()) (IO (() -> Plain f) -> IO (Plain f))
-> IO (() -> Plain f) -> IO (Plain f)
forall a b. (a -> b) -> a -> b
$ Hull () f -> IO (() -> Plain f)
forall p. Hull p f -> IO (p -> Plain f)
forall f p. C f => Hull p f -> IO (p -> Plain f)
build (Hull () f -> IO (() -> Plain f))
-> Hull () f -> IO (() -> Plain f)
forall a b. (a -> b) -> a -> b
$ f -> Hull () f
forall a. a -> Hull () a
forall (f :: * -> *) a. Applicative f => a -> f a
pure f
f



_example ::
   (Marshal.C x,
    Shape.C sha, Marshal.C sha, Storable.C a,
    Shape.C shb, Marshal.C shb, Storable.C b,
    Shape.C shc, Marshal.C shc, Storable.C c) =>
   (Exp x -> Core.Array sha a -> Core.Array shb b -> Core.Array shc c) ->
   IO (x -> Phys.Array sha a -> Phys.Array shb b -> IO (Phys.Array shc c))
_example :: forall x sha a shb b shc c.
(C x, C sha, C sha, C a, C shb, C shb, C b, C shc, C shc, C c) =>
(Exp x -> Array sha a -> Array shb b -> Array shc c)
-> IO (x -> Array sha a -> Array shb b -> IO (Array shc c))
_example Exp x -> Array sha a -> Array shb b -> Array shc c
f =
   ((((x, Array sha a), Array shb b) -> IO (Array shc c))
 -> x -> Array sha a -> Array shb b -> IO (Array shc c))
-> IO (((x, Array sha a), Array shb b) -> IO (Array shc c))
-> IO (x -> Array sha a -> Array shb b -> IO (Array shc c))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\((x, Array sha a), Array shb b) -> IO (Array shc c)
g -> ((x, Array sha a) -> Array shb b -> IO (Array shc c))
-> x -> Array sha a -> Array shb b -> IO (Array shc c)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry (((x, Array sha a) -> Array shb b -> IO (Array shc c))
 -> x -> Array sha a -> Array shb b -> IO (Array shc c))
-> ((x, Array sha a) -> Array shb b -> IO (Array shc c))
-> x
-> Array sha a
-> Array shb b
-> IO (Array shc c)
forall a b. (a -> b) -> a -> b
$ (((x, Array sha a), Array shb b) -> IO (Array shc c))
-> (x, Array sha a) -> Array shb b -> IO (Array shc c)
forall a b c. ((a, b) -> c) -> a -> b -> c
curry ((x, Array sha a), Array shb b) -> IO (Array shc c)
g) (IO (((x, Array sha a), Array shb b) -> IO (Array shc c))
 -> IO (x -> Array sha a -> Array shb b -> IO (Array shc c)))
-> IO (((x, Array sha a), Array shb b) -> IO (Array shc c))
-> IO (x -> Array sha a -> Array shb b -> IO (Array shc c))
forall a b. (a -> b) -> a -> b
$
   Array ((x, Array sha a), Array shb b) shc c
-> IO (((x, Array sha a), Array shb b) -> IO (Array shc c))
forall sh a p.
(C sh, C sh, C a) =>
Array p sh a -> IO (p -> IO (Array sh a))
PhysP.render (Array ((x, Array sha a), Array shb b) shc c
 -> IO (((x, Array sha a), Array shb b) -> IO (Array shc c)))
-> Array ((x, Array sha a), Array shb b) shc c
-> IO (((x, Array sha a), Array shb b) -> IO (Array shc c))
forall a b. (a -> b) -> a -> b
$
   Hull ((x, Array sha a), Array shb b) (Array shc c)
-> Array ((x, Array sha a), Array shb b) shc c
forall p sh a. Hull p (Array sh a) -> Array p sh a
Sym.runHull (Hull ((x, Array sha a), Array shb b) (Array shc c)
 -> Array ((x, Array sha a), Array shb b) shc c)
-> Hull ((x, Array sha a), Array shb b) (Array shc c)
-> Array ((x, Array sha a), Array shb b) shc c
forall a b. (a -> b) -> a -> b
$
   (Exp x -> Array sha a -> Array shb b -> Array shc c)
-> Hull
     ((x, Array sha a), Array shb b)
     (Exp x -> Array sha a -> Array shb b -> Array shc c)
forall a. a -> Hull ((x, Array sha a), Array shb b) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Exp x -> Array sha a -> Array shb b -> Array shc c
f
      Hull
  ((x, Array sha a), Array shb b)
  (Exp x -> Array sha a -> Array shb b -> Array shc c)
-> Hull ((x, Array sha a), Array shb b) (Exp x)
-> Hull
     ((x, Array sha a), Array shb b)
     (Array sha a -> Array shb b -> Array shc c)
forall a b.
Hull ((x, Array sha a), Array shb b) (a -> b)
-> Hull ((x, Array sha a), Array shb b) a
-> Hull ((x, Array sha a), Array shb b) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Tunnel ((x, Array sha a), Array shb b) x
-> Hull ((x, Array sha a), Array shb b) (Exp x)
forall p sl. Tunnel p sl -> Hull p (Exp sl)
Sym.expHull (T ((x, Array sha a), Array shb b) x
-> Tunnel ((x, Array sha a), Array shb b) x
forall a p. C a => T p a -> Tunnel p a
Sym.expParam (T ((x, Array sha a), Array shb b) x
 -> Tunnel ((x, Array sha a), Array shb b) x)
-> T ((x, Array sha a), Array shb b) x
-> Tunnel ((x, Array sha a), Array shb b) x
forall a b. (a -> b) -> a -> b
$ (((x, Array sha a), Array shb b) -> x)
-> T ((x, Array sha a), Array shb b) x
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr ((x, Array sha a) -> x
forall a b. (a, b) -> a
fst((x, Array sha a) -> x)
-> (((x, Array sha a), Array shb b) -> (x, Array sha a))
-> ((x, Array sha a), Array shb b)
-> x
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((x, Array sha a), Array shb b) -> (x, Array sha a)
forall a b. (a, b) -> a
fst))
      Hull
  ((x, Array sha a), Array shb b)
  (Array sha a -> Array shb b -> Array shc c)
-> Hull ((x, Array sha a), Array shb b) (Array sha a)
-> Hull
     ((x, Array sha a), Array shb b) (Array shb b -> Array shc c)
forall a b.
Hull ((x, Array sha a), Array shb b) (a -> b)
-> Hull ((x, Array sha a), Array shb b) a
-> Hull ((x, Array sha a), Array shb b) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Array ((x, Array sha a), Array shb b) sha a
-> Hull ((x, Array sha a), Array shb b) (Array sha a)
forall p sh a. Array p sh a -> Hull p (Array sh a)
Sym.arrayHull (T ((x, Array sha a), Array shb b) (Array sha a)
-> Array ((x, Array sha a), Array shb b) sha a
forall sh a p.
(C sh, C sh, C a) =>
T p (Array sh a) -> Array p sh a
PhysP.feed (T ((x, Array sha a), Array shb b) (Array sha a)
 -> Array ((x, Array sha a), Array shb b) sha a)
-> T ((x, Array sha a), Array shb b) (Array sha a)
-> Array ((x, Array sha a), Array shb b) sha a
forall a b. (a -> b) -> a -> b
$ (((x, Array sha a), Array shb b) -> Array sha a)
-> T ((x, Array sha a), Array shb b) (Array sha a)
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr ((x, Array sha a) -> Array sha a
forall a b. (a, b) -> b
snd((x, Array sha a) -> Array sha a)
-> (((x, Array sha a), Array shb b) -> (x, Array sha a))
-> ((x, Array sha a), Array shb b)
-> Array sha a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.((x, Array sha a), Array shb b) -> (x, Array sha a)
forall a b. (a, b) -> a
fst))
      Hull ((x, Array sha a), Array shb b) (Array shb b -> Array shc c)
-> Hull ((x, Array sha a), Array shb b) (Array shb b)
-> Hull ((x, Array sha a), Array shb b) (Array shc c)
forall a b.
Hull ((x, Array sha a), Array shb b) (a -> b)
-> Hull ((x, Array sha a), Array shb b) a
-> Hull ((x, Array sha a), Array shb b) b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Array ((x, Array sha a), Array shb b) shb b
-> Hull ((x, Array sha a), Array shb b) (Array shb b)
forall p sh a. Array p sh a -> Hull p (Array sh a)
Sym.arrayHull (T ((x, Array sha a), Array shb b) (Array shb b)
-> Array ((x, Array sha a), Array shb b) shb b
forall sh a p.
(C sh, C sh, C a) =>
T p (Array sh a) -> Array p sh a
PhysP.feed (T ((x, Array sha a), Array shb b) (Array shb b)
 -> Array ((x, Array sha a), Array shb b) shb b)
-> T ((x, Array sha a), Array shb b) (Array shb b)
-> Array ((x, Array sha a), Array shb b) shb b
forall a b. (a -> b) -> a -> b
$ (((x, Array sha a), Array shb b) -> Array shb b)
-> T ((x, Array sha a), Array shb b) (Array shb b)
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr ((x, Array sha a), Array shb b) -> Array shb b
forall a b. (a, b) -> b
snd)