{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Data.Array.Knead.Shape.Orphan where

import qualified Data.Array.Knead.Expression as Expr

import qualified Data.Array.Comfort.Shape as Shape
import Data.Array.Comfort.Shape
         (ZeroBased(ZeroBased), Range(Range), Shifted(Shifted),
          Cyclic(Cyclic),
          Enumeration(Enumeration))

import qualified LLVM.Extra.Multi.Value.Marshal as Marshal
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Tuple as Tuple

import qualified Control.Monad.HT as Monad
import Control.Applicative ((<$>))

import Prelude2010
import Prelude ()



unzipZeroBased :: MultiValue.T (ZeroBased n) -> ZeroBased (MultiValue.T n)
unzipZeroBased :: forall n. T (ZeroBased n) -> ZeroBased (T n)
unzipZeroBased (MultiValue.Cons (ZeroBased Repr n
n)) = T n -> ZeroBased (T n)
forall n. n -> ZeroBased n
ZeroBased (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
n)

zeroBasedSize :: (Expr.Value val) => val (ZeroBased n) -> val n
zeroBasedSize :: forall (val :: * -> *) n. Value val => val (ZeroBased n) -> val n
zeroBasedSize = (T (ZeroBased n) -> T n) -> val (ZeroBased n) -> val n
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((T (ZeroBased n) -> T n) -> val (ZeroBased n) -> val n)
-> (T (ZeroBased n) -> T n) -> val (ZeroBased n) -> val n
forall a b. (a -> b) -> a -> b
$ ZeroBased (T n) -> T n
forall n. ZeroBased n -> n
Shape.zeroBasedSize (ZeroBased (T n) -> T n)
-> (T (ZeroBased n) -> ZeroBased (T n)) -> T (ZeroBased n) -> T n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (ZeroBased n) -> ZeroBased (T n)
forall n. T (ZeroBased n) -> ZeroBased (T n)
unzipZeroBased

zeroBased :: (Expr.Value val) => val n -> val (ZeroBased n)
zeroBased :: forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased = (T n -> T (ZeroBased n)) -> val n -> val (ZeroBased n)
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((T n -> T (ZeroBased n)) -> val n -> val (ZeroBased n))
-> (T n -> T (ZeroBased n)) -> val n -> val (ZeroBased n)
forall a b. (a -> b) -> a -> b
$ \(MultiValue.Cons Repr n
n) -> Repr (ZeroBased n) -> T (ZeroBased n)
forall a. Repr a -> T a
MultiValue.Cons (Repr n -> ZeroBased (Repr n)
forall n. n -> ZeroBased n
ZeroBased Repr n
n)

instance (Tuple.Undefined n) => Tuple.Undefined (ZeroBased n) where
   undef :: ZeroBased n
undef = n -> ZeroBased n
forall n. n -> ZeroBased n
ZeroBased n
forall a. Undefined a => a
Tuple.undef

instance (Tuple.Phi n) => Tuple.Phi (ZeroBased n) where
   phi :: forall r.
BasicBlock -> ZeroBased n -> CodeGenFunction r (ZeroBased n)
phi BasicBlock
bb = (n -> ZeroBased n)
-> CodeGenFunction r n -> CodeGenFunction r (ZeroBased n)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap n -> ZeroBased n
forall n. n -> ZeroBased n
ZeroBased (CodeGenFunction r n -> CodeGenFunction r (ZeroBased n))
-> (ZeroBased n -> CodeGenFunction r n)
-> ZeroBased n
-> CodeGenFunction r (ZeroBased n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BasicBlock -> n -> CodeGenFunction r n
forall a r. Phi a => BasicBlock -> a -> CodeGenFunction r a
forall r. BasicBlock -> n -> CodeGenFunction r n
Tuple.phi BasicBlock
bb (n -> CodeGenFunction r n)
-> (ZeroBased n -> n) -> ZeroBased n -> CodeGenFunction r n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZeroBased n -> n
forall n. ZeroBased n -> n
Shape.zeroBasedSize
   addPhi :: forall r.
BasicBlock -> ZeroBased n -> ZeroBased n -> CodeGenFunction r ()
addPhi BasicBlock
bb (Shape.ZeroBased n
a) (Shape.ZeroBased n
b) = BasicBlock -> n -> n -> CodeGenFunction r ()
forall a r. Phi a => BasicBlock -> a -> a -> CodeGenFunction r ()
forall r. BasicBlock -> n -> n -> CodeGenFunction r ()
Tuple.addPhi BasicBlock
bb n
a n
b

instance (Tuple.Value n) => Tuple.Value (ZeroBased n) where
   type ValueOf (ZeroBased n) = ZeroBased (Tuple.ValueOf n)
   valueOf :: ZeroBased n -> ValueOf (ZeroBased n)
valueOf (ZeroBased n
n) = ValueOf n -> ZeroBased (ValueOf n)
forall n. n -> ZeroBased n
ZeroBased (ValueOf n -> ZeroBased (ValueOf n))
-> ValueOf n -> ZeroBased (ValueOf n)
forall a b. (a -> b) -> a -> b
$ n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
n

instance (MultiValue.C n) => MultiValue.C (ZeroBased n) where
   type Repr (ZeroBased n) = ZeroBased (MultiValue.Repr n)
   cons :: ZeroBased n -> T (ZeroBased n)
cons (ZeroBased n
n) = T n -> T (ZeroBased n)
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
n)
   undef :: T (ZeroBased n)
undef = T n -> T (ZeroBased n)
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased T n
forall a. C a => T a
MultiValue.undef
   zero :: T (ZeroBased n)
zero = T n -> T (ZeroBased n)
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased T n
forall a. C a => T a
MultiValue.zero
   phi :: forall r.
BasicBlock
-> T (ZeroBased n) -> CodeGenFunction r (T (ZeroBased n))
phi BasicBlock
bb = (T n -> T (ZeroBased n))
-> CodeGenFunction r (T n) -> CodeGenFunction r (T (ZeroBased n))
forall (m :: * -> *) a r. Monad m => (a -> r) -> m a -> m r
Monad.lift T n -> T (ZeroBased n)
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased (CodeGenFunction r (T n) -> CodeGenFunction r (T (ZeroBased n)))
-> (T (ZeroBased n) -> CodeGenFunction r (T n))
-> T (ZeroBased n)
-> CodeGenFunction r (T (ZeroBased n))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb (T n -> CodeGenFunction r (T n))
-> (T (ZeroBased n) -> T n)
-> T (ZeroBased n)
-> CodeGenFunction r (T n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (ZeroBased n) -> T n
forall (val :: * -> *) n. Value val => val (ZeroBased n) -> val n
zeroBasedSize
   addPhi :: forall r.
BasicBlock
-> T (ZeroBased n) -> T (ZeroBased n) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (ZeroBased n)
a T (ZeroBased n)
b = BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb (T (ZeroBased n) -> T n
forall (val :: * -> *) n. Value val => val (ZeroBased n) -> val n
zeroBasedSize T (ZeroBased n)
a) (T (ZeroBased n) -> T n
forall (val :: * -> *) n. Value val => val (ZeroBased n) -> val n
zeroBasedSize T (ZeroBased n)
b)

type instance
   MultiValue.Decomposed f (ZeroBased pn) =
      ZeroBased (MultiValue.Decomposed f pn)
type instance
   MultiValue.PatternTuple (ZeroBased pn) =
      ZeroBased (MultiValue.PatternTuple pn)

instance (MultiValue.Compose n) => MultiValue.Compose (ZeroBased n) where
   type Composed (ZeroBased n) = ZeroBased (MultiValue.Composed n)
   compose :: ZeroBased n -> T (Composed (ZeroBased n))
compose (ZeroBased n
n) = T (Composed n) -> T (ZeroBased (Composed n))
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
n)

instance (MultiValue.Decompose pn) => MultiValue.Decompose (ZeroBased pn) where
   decompose :: ZeroBased pn
-> T (PatternTuple (ZeroBased pn)) -> Decomposed T (ZeroBased pn)
decompose (ZeroBased pn
p) T (PatternTuple (ZeroBased pn))
sh =
      pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
p (T (PatternTuple pn) -> Decomposed T pn)
-> ZeroBased (T (PatternTuple pn)) -> ZeroBased (Decomposed T pn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T (ZeroBased (PatternTuple pn)) -> ZeroBased (T (PatternTuple pn))
forall n. T (ZeroBased n) -> ZeroBased (T n)
unzipZeroBased T (ZeroBased (PatternTuple pn))
T (PatternTuple (ZeroBased pn))
sh

instance (Expr.Compose n) => Expr.Compose (ZeroBased n) where
   type Composed (ZeroBased n) = ZeroBased (Expr.Composed n)
   compose :: ZeroBased n -> Exp (Composed (ZeroBased n))
compose (ZeroBased n
n) = (T (Composed n) -> T (ZeroBased (Composed n)))
-> Exp (Composed n) -> Exp (ZeroBased (Composed n))
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 T (Composed n) -> T (ZeroBased (Composed n))
forall (val :: * -> *) n. Value val => val n -> val (ZeroBased n)
zeroBased (n -> Exp (Composed n)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
Expr.compose n
n)

instance (Expr.Decompose pn) => Expr.Decompose (ZeroBased pn) where
   decompose :: ZeroBased pn
-> Exp (PatternTuple (ZeroBased pn))
-> Decomposed Exp (ZeroBased pn)
decompose (ZeroBased pn
p) = Decomposed Exp pn -> ZeroBased (Decomposed Exp pn)
forall n. n -> ZeroBased n
ZeroBased (Decomposed Exp pn -> ZeroBased (Decomposed Exp pn))
-> (Exp (ZeroBased (PatternTuple pn)) -> Decomposed Exp pn)
-> Exp (ZeroBased (PatternTuple pn))
-> ZeroBased (Decomposed Exp pn)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. pn -> Exp (PatternTuple pn) -> Decomposed Exp pn
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
Expr.decompose pn
p (Exp (PatternTuple pn) -> Decomposed Exp pn)
-> (Exp (ZeroBased (PatternTuple pn)) -> Exp (PatternTuple pn))
-> Exp (ZeroBased (PatternTuple pn))
-> Decomposed Exp pn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (ZeroBased (PatternTuple pn)) -> Exp (PatternTuple pn)
forall (val :: * -> *) n. Value val => val (ZeroBased n) -> val n
zeroBasedSize

instance (Memory.C n) => Memory.C (ZeroBased n) where
   type Struct (ZeroBased n) = Memory.Struct n
   compose :: forall r.
ZeroBased n -> CodeGenFunction r (Value (Struct (ZeroBased n)))
compose = n -> CodeGenFunction r (Value (Struct n))
forall r. n -> CodeGenFunction r (Value (Struct n))
forall llvmValue r.
C llvmValue =>
llvmValue -> CodeGenFunction r (Value (Struct llvmValue))
Memory.compose (n -> CodeGenFunction r (Value (Struct n)))
-> (ZeroBased n -> n)
-> ZeroBased n
-> CodeGenFunction r (Value (Struct n))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZeroBased n -> n
forall n. ZeroBased n -> n
Shape.zeroBasedSize
   decompose :: forall r.
Value (Struct (ZeroBased n)) -> CodeGenFunction r (ZeroBased n)
decompose = (n -> ZeroBased n)
-> CodeGenFunction r n -> CodeGenFunction r (ZeroBased n)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap n -> ZeroBased n
forall n. n -> ZeroBased n
ZeroBased (CodeGenFunction r n -> CodeGenFunction r (ZeroBased n))
-> (Value (Struct n) -> CodeGenFunction r n)
-> Value (Struct n)
-> CodeGenFunction r (ZeroBased n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Struct n) -> CodeGenFunction r n
forall llvmValue r.
C llvmValue =>
Value (Struct llvmValue) -> CodeGenFunction r llvmValue
forall r. Value (Struct n) -> CodeGenFunction r n
Memory.decompose

instance (Marshal.C n) => Marshal.C (ZeroBased n) where
   pack :: ZeroBased n -> Struct (ZeroBased n)
pack = n -> Struct n
forall a. C a => a -> Struct a
Marshal.pack (n -> Struct n) -> (ZeroBased n -> n) -> ZeroBased n -> Struct n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZeroBased n -> n
forall n. ZeroBased n -> n
Shape.zeroBasedSize
   unpack :: Struct (ZeroBased n) -> ZeroBased n
unpack = n -> ZeroBased n
forall n. n -> ZeroBased n
Shape.ZeroBased (n -> ZeroBased n) -> (Struct n -> n) -> Struct n -> ZeroBased n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct n -> n
forall a. C a => Struct a -> a
Marshal.unpack



singletonRange :: n -> Range n
singletonRange :: forall n. n -> Range n
singletonRange n
n = n -> n -> Range n
forall n. n -> n -> Range n
Range n
n n
n

unzipRange :: MultiValue.T (Range n) -> Range (MultiValue.T n)
unzipRange :: forall n. T (Range n) -> Range (T n)
unzipRange (MultiValue.Cons (Range Repr n
from Repr n
to)) =
   T n -> T n -> Range (T n)
forall n. n -> n -> Range n
Range (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
from) (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
to)

zipRange :: MultiValue.T n -> MultiValue.T n -> MultiValue.T (Range n)
zipRange :: forall n. T n -> T n -> T (Range n)
zipRange (MultiValue.Cons Repr n
from) (MultiValue.Cons Repr n
to) =
   Repr (Range n) -> T (Range n)
forall a. Repr a -> T a
MultiValue.Cons (Repr n -> Repr n -> Range (Repr n)
forall n. n -> n -> Range n
Range Repr n
from Repr n
to)

instance (Tuple.Undefined n) => Tuple.Undefined (Range n) where
   undef :: Range n
undef = n -> n -> Range n
forall n. n -> n -> Range n
Range n
forall a. Undefined a => a
Tuple.undef n
forall a. Undefined a => a
Tuple.undef

instance (Tuple.Value n) => Tuple.Value (Range n) where
   type ValueOf (Range n) = Range (Tuple.ValueOf n)
   valueOf :: Range n -> ValueOf (Range n)
valueOf (Range n
from n
to) = ValueOf n -> ValueOf n -> Range (ValueOf n)
forall n. n -> n -> Range n
Range (n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
from) (n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
to)

instance (MultiValue.C n) => MultiValue.C (Range n) where
   type Repr (Range n) = Range (MultiValue.Repr n)
   cons :: Range n -> T (Range n)
cons (Range n
from n
to) = T n -> T n -> T (Range n)
forall n. T n -> T n -> T (Range n)
zipRange (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
from) (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
to)
   undef :: T (Range n)
undef = Range (T n) -> T (Composed (Range (T n)))
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose (Range (T n) -> T (Composed (Range (T n))))
-> Range (T n) -> T (Composed (Range (T n)))
forall a b. (a -> b) -> a -> b
$ T n -> Range (T n)
forall n. n -> Range n
singletonRange T n
forall a. C a => T a
MultiValue.undef
   zero :: T (Range n)
zero = Range (T n) -> T (Composed (Range (T n)))
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose (Range (T n) -> T (Composed (Range (T n))))
-> Range (T n) -> T (Composed (Range (T n)))
forall a b. (a -> b) -> a -> b
$ T n -> Range (T n)
forall n. n -> Range n
singletonRange T n
forall a. C a => T a
MultiValue.zero
   phi :: forall r.
BasicBlock -> T (Range n) -> CodeGenFunction r (T (Range n))
phi BasicBlock
bb T (Range n)
a =
      case T (Range n) -> Range (T n)
forall n. T (Range n) -> Range (T n)
unzipRange T (Range n)
a of
         Range T n
a0 T n
a1 ->
            (T n -> T n -> T (Range n))
-> CodeGenFunction r (T n)
-> CodeGenFunction r (T n)
-> CodeGenFunction r (T (Range n))
forall (m :: * -> *) a b r.
Monad m =>
(a -> b -> r) -> m a -> m b -> m r
Monad.lift2 T n -> T n -> T (Range n)
forall n. T n -> T n -> T (Range n)
zipRange (BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb T n
a0) (BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb T n
a1)
   addPhi :: forall r.
BasicBlock -> T (Range n) -> T (Range n) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Range n)
a T (Range n)
b =
      case (T (Range n) -> Range (T n)
forall n. T (Range n) -> Range (T n)
unzipRange T (Range n)
a, T (Range n) -> Range (T n)
forall n. T (Range n) -> Range (T n)
unzipRange T (Range n)
b) of
         (Range T n
a0 T n
a1, Range T n
b0 T n
b1) ->
            BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb T n
a0 T n
b0 CodeGenFunction r ()
-> CodeGenFunction r () -> CodeGenFunction r ()
forall a b.
CodeGenFunction r a -> CodeGenFunction r b -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb T n
a1 T n
b1

type instance
   MultiValue.Decomposed f (Range pn) = Range (MultiValue.Decomposed f pn)
type instance
   MultiValue.PatternTuple (Range pn) = Range (MultiValue.PatternTuple pn)

instance (MultiValue.Compose n) => MultiValue.Compose (Range n) where
   type Composed (Range n) = Range (MultiValue.Composed n)
   compose :: Range n -> T (Composed (Range n))
compose (Range n
from n
to) =
      T (Composed n) -> T (Composed n) -> T (Range (Composed n))
forall n. T n -> T n -> T (Range n)
zipRange (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
from) (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
to)

instance (MultiValue.Decompose pn) => MultiValue.Decompose (Range pn) where
   decompose :: Range pn -> T (PatternTuple (Range pn)) -> Decomposed T (Range pn)
decompose (Range pn
pfrom pn
pto) T (PatternTuple (Range pn))
rng =
      case T (Range (PatternTuple pn)) -> Range (T (PatternTuple pn))
forall n. T (Range n) -> Range (T n)
unzipRange T (Range (PatternTuple pn))
T (PatternTuple (Range pn))
rng of
         Range T (PatternTuple pn)
from T (PatternTuple pn)
to ->
            Decomposed T pn -> Decomposed T pn -> Range (Decomposed T pn)
forall n. n -> n -> Range n
Range
               (pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
pfrom T (PatternTuple pn)
from)
               (pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
pto T (PatternTuple pn)
to)



singletonShifted :: n -> Shifted n
singletonShifted :: forall n. n -> Shifted n
singletonShifted n
n = n -> n -> Shifted n
forall n. n -> n -> Shifted n
Shifted n
n n
n

unzipShifted :: MultiValue.T (Shifted n) -> Shifted (MultiValue.T n)
unzipShifted :: forall n. T (Shifted n) -> Shifted (T n)
unzipShifted (MultiValue.Cons (Shifted Repr n
from Repr n
to)) =
   T n -> T n -> Shifted (T n)
forall n. n -> n -> Shifted n
Shifted (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
from) (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
to)

zipShifted :: MultiValue.T n -> MultiValue.T n -> MultiValue.T (Shifted n)
zipShifted :: forall n. T n -> T n -> T (Shifted n)
zipShifted (MultiValue.Cons Repr n
from) (MultiValue.Cons Repr n
to) =
   Repr (Shifted n) -> T (Shifted n)
forall a. Repr a -> T a
MultiValue.Cons (Repr n -> Repr n -> Shifted (Repr n)
forall n. n -> n -> Shifted n
Shifted Repr n
from Repr n
to)

instance (Tuple.Undefined n) => Tuple.Undefined (Shifted n) where
   undef :: Shifted n
undef = n -> n -> Shifted n
forall n. n -> n -> Shifted n
Shifted n
forall a. Undefined a => a
Tuple.undef n
forall a. Undefined a => a
Tuple.undef

instance (Tuple.Value n) => Tuple.Value (Shifted n) where
   type ValueOf (Shifted n) = Shifted (Tuple.ValueOf n)
   valueOf :: Shifted n -> ValueOf (Shifted n)
valueOf (Shifted n
start n
len) =
      ValueOf n -> ValueOf n -> Shifted (ValueOf n)
forall n. n -> n -> Shifted n
Shifted (n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
start) (n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
len)

instance (MultiValue.C n) => MultiValue.C (Shifted n) where
   type Repr (Shifted n) = Shifted (MultiValue.Repr n)
   cons :: Shifted n -> T (Shifted n)
cons (Shifted n
start n
len) =
      T n -> T n -> T (Shifted n)
forall n. T n -> T n -> T (Shifted n)
zipShifted (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
start) (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
len)
   undef :: T (Shifted n)
undef = Shifted (T n) -> T (Composed (Shifted (T n)))
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose (Shifted (T n) -> T (Composed (Shifted (T n))))
-> Shifted (T n) -> T (Composed (Shifted (T n)))
forall a b. (a -> b) -> a -> b
$ T n -> Shifted (T n)
forall n. n -> Shifted n
singletonShifted T n
forall a. C a => T a
MultiValue.undef
   zero :: T (Shifted n)
zero = Shifted (T n) -> T (Composed (Shifted (T n)))
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose (Shifted (T n) -> T (Composed (Shifted (T n))))
-> Shifted (T n) -> T (Composed (Shifted (T n)))
forall a b. (a -> b) -> a -> b
$ T n -> Shifted (T n)
forall n. n -> Shifted n
singletonShifted T n
forall a. C a => T a
MultiValue.zero
   phi :: forall r.
BasicBlock -> T (Shifted n) -> CodeGenFunction r (T (Shifted n))
phi BasicBlock
bb T (Shifted n)
a =
      case T (Shifted n) -> Shifted (T n)
forall n. T (Shifted n) -> Shifted (T n)
unzipShifted T (Shifted n)
a of
         Shifted T n
a0 T n
a1 ->
            (T n -> T n -> T (Shifted n))
-> CodeGenFunction r (T n)
-> CodeGenFunction r (T n)
-> CodeGenFunction r (T (Shifted n))
forall (m :: * -> *) a b r.
Monad m =>
(a -> b -> r) -> m a -> m b -> m r
Monad.lift2 T n -> T n -> T (Shifted n)
forall n. T n -> T n -> T (Shifted n)
zipShifted
               (BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb T n
a0) (BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb T n
a1)
   addPhi :: forall r.
BasicBlock
-> T (Shifted n) -> T (Shifted n) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Shifted n)
a T (Shifted n)
b =
      case (T (Shifted n) -> Shifted (T n)
forall n. T (Shifted n) -> Shifted (T n)
unzipShifted T (Shifted n)
a, T (Shifted n) -> Shifted (T n)
forall n. T (Shifted n) -> Shifted (T n)
unzipShifted T (Shifted n)
b) of
         (Shifted T n
a0 T n
a1, Shifted T n
b0 T n
b1) ->
            BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb T n
a0 T n
b0 CodeGenFunction r ()
-> CodeGenFunction r () -> CodeGenFunction r ()
forall a b.
CodeGenFunction r a -> CodeGenFunction r b -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
            BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb T n
a1 T n
b1

type instance
   MultiValue.Decomposed f (Shifted pn) =
      Shifted (MultiValue.Decomposed f pn)
type instance
   MultiValue.PatternTuple (Shifted pn) =
      Shifted (MultiValue.PatternTuple pn)

instance (MultiValue.Compose n) => MultiValue.Compose (Shifted n) where
   type Composed (Shifted n) = Shifted (MultiValue.Composed n)
   compose :: Shifted n -> T (Composed (Shifted n))
compose (Shifted n
start n
len) =
      T (Composed n) -> T (Composed n) -> T (Shifted (Composed n))
forall n. T n -> T n -> T (Shifted n)
zipShifted (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
start) (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
len)

instance (MultiValue.Decompose pn) => MultiValue.Decompose (Shifted pn) where
   decompose :: Shifted pn
-> T (PatternTuple (Shifted pn)) -> Decomposed T (Shifted pn)
decompose (Shifted pn
pstart pn
plen) T (PatternTuple (Shifted pn))
rng =
      case T (Shifted (PatternTuple pn)) -> Shifted (T (PatternTuple pn))
forall n. T (Shifted n) -> Shifted (T n)
unzipShifted T (Shifted (PatternTuple pn))
T (PatternTuple (Shifted pn))
rng of
         Shifted T (PatternTuple pn)
start T (PatternTuple pn)
len ->
            Decomposed T pn -> Decomposed T pn -> Shifted (Decomposed T pn)
forall n. n -> n -> Shifted n
Shifted
               (pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
pstart T (PatternTuple pn)
start)
               (pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
plen T (PatternTuple pn)
len)



unzipCyclic :: MultiValue.T (Cyclic n) -> Cyclic (MultiValue.T n)
unzipCyclic :: forall n. T (Cyclic n) -> Cyclic (T n)
unzipCyclic (MultiValue.Cons (Cyclic Repr n
n)) = T n -> Cyclic (T n)
forall n. n -> Cyclic n
Cyclic (Repr n -> T n
forall a. Repr a -> T a
MultiValue.Cons Repr n
n)

cyclicSize :: (Expr.Value val) => val (Cyclic n) -> val n
cyclicSize :: forall (val :: * -> *) n. Value val => val (Cyclic n) -> val n
cyclicSize = (T (Cyclic n) -> T n) -> val (Cyclic n) -> val n
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((T (Cyclic n) -> T n) -> val (Cyclic n) -> val n)
-> (T (Cyclic n) -> T n) -> val (Cyclic n) -> val n
forall a b. (a -> b) -> a -> b
$ Cyclic (T n) -> T n
forall n. Cyclic n -> n
Shape.cyclicSize (Cyclic (T n) -> T n)
-> (T (Cyclic n) -> Cyclic (T n)) -> T (Cyclic n) -> T n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Cyclic n) -> Cyclic (T n)
forall n. T (Cyclic n) -> Cyclic (T n)
unzipCyclic

cyclic :: (Expr.Value val) => val n -> val (Cyclic n)
cyclic :: forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic = (T n -> T (Cyclic n)) -> val n -> val (Cyclic n)
forall a b. (T a -> T b) -> val a -> val b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((T n -> T (Cyclic n)) -> val n -> val (Cyclic n))
-> (T n -> T (Cyclic n)) -> val n -> val (Cyclic n)
forall a b. (a -> b) -> a -> b
$ \(MultiValue.Cons Repr n
n) -> Repr (Cyclic n) -> T (Cyclic n)
forall a. Repr a -> T a
MultiValue.Cons (Repr n -> Cyclic (Repr n)
forall n. n -> Cyclic n
Cyclic Repr n
n)

instance (Tuple.Undefined n) => Tuple.Undefined (Cyclic n) where
   undef :: Cyclic n
undef = n -> Cyclic n
forall n. n -> Cyclic n
Cyclic n
forall a. Undefined a => a
Tuple.undef

instance (Tuple.Phi n) => Tuple.Phi (Cyclic n) where
   phi :: forall r. BasicBlock -> Cyclic n -> CodeGenFunction r (Cyclic n)
phi BasicBlock
bb = (n -> Cyclic n)
-> CodeGenFunction r n -> CodeGenFunction r (Cyclic n)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap n -> Cyclic n
forall n. n -> Cyclic n
Cyclic (CodeGenFunction r n -> CodeGenFunction r (Cyclic n))
-> (Cyclic n -> CodeGenFunction r n)
-> Cyclic n
-> CodeGenFunction r (Cyclic n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BasicBlock -> n -> CodeGenFunction r n
forall a r. Phi a => BasicBlock -> a -> CodeGenFunction r a
forall r. BasicBlock -> n -> CodeGenFunction r n
Tuple.phi BasicBlock
bb (n -> CodeGenFunction r n)
-> (Cyclic n -> n) -> Cyclic n -> CodeGenFunction r n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cyclic n -> n
forall n. Cyclic n -> n
Shape.cyclicSize
   addPhi :: forall r.
BasicBlock -> Cyclic n -> Cyclic n -> CodeGenFunction r ()
addPhi BasicBlock
bb (Shape.Cyclic n
a) (Shape.Cyclic n
b) = BasicBlock -> n -> n -> CodeGenFunction r ()
forall a r. Phi a => BasicBlock -> a -> a -> CodeGenFunction r ()
forall r. BasicBlock -> n -> n -> CodeGenFunction r ()
Tuple.addPhi BasicBlock
bb n
a n
b

instance (Tuple.Value n) => Tuple.Value (Cyclic n) where
   type ValueOf (Cyclic n) = Cyclic (Tuple.ValueOf n)
   valueOf :: Cyclic n -> ValueOf (Cyclic n)
valueOf (Cyclic n
n) = ValueOf n -> Cyclic (ValueOf n)
forall n. n -> Cyclic n
Cyclic (ValueOf n -> Cyclic (ValueOf n))
-> ValueOf n -> Cyclic (ValueOf n)
forall a b. (a -> b) -> a -> b
$ n -> ValueOf n
forall a. Value a => a -> ValueOf a
Tuple.valueOf n
n

instance (MultiValue.C n) => MultiValue.C (Cyclic n) where
   type Repr (Cyclic n) = Cyclic (MultiValue.Repr n)
   cons :: Cyclic n -> T (Cyclic n)
cons (Cyclic n
n) = T n -> T (Cyclic n)
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic (n -> T n
forall a. C a => a -> T a
MultiValue.cons n
n)
   undef :: T (Cyclic n)
undef = T n -> T (Cyclic n)
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic T n
forall a. C a => T a
MultiValue.undef
   zero :: T (Cyclic n)
zero = T n -> T (Cyclic n)
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic T n
forall a. C a => T a
MultiValue.zero
   phi :: forall r.
BasicBlock -> T (Cyclic n) -> CodeGenFunction r (T (Cyclic n))
phi BasicBlock
bb = (T n -> T (Cyclic n))
-> CodeGenFunction r (T n) -> CodeGenFunction r (T (Cyclic n))
forall (m :: * -> *) a r. Monad m => (a -> r) -> m a -> m r
Monad.lift T n -> T (Cyclic n)
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic (CodeGenFunction r (T n) -> CodeGenFunction r (T (Cyclic n)))
-> (T (Cyclic n) -> CodeGenFunction r (T n))
-> T (Cyclic n)
-> CodeGenFunction r (T (Cyclic n))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BasicBlock -> T n -> CodeGenFunction r (T n)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T n -> CodeGenFunction r (T n)
MultiValue.phi BasicBlock
bb (T n -> CodeGenFunction r (T n))
-> (T (Cyclic n) -> T n) -> T (Cyclic n) -> CodeGenFunction r (T n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Cyclic n) -> T n
forall (val :: * -> *) n. Value val => val (Cyclic n) -> val n
cyclicSize
   addPhi :: forall r.
BasicBlock -> T (Cyclic n) -> T (Cyclic n) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Cyclic n)
a T (Cyclic n)
b = BasicBlock -> T n -> T n -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T n -> T n -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb (T (Cyclic n) -> T n
forall (val :: * -> *) n. Value val => val (Cyclic n) -> val n
cyclicSize T (Cyclic n)
a) (T (Cyclic n) -> T n
forall (val :: * -> *) n. Value val => val (Cyclic n) -> val n
cyclicSize T (Cyclic n)
b)

type instance
   MultiValue.Decomposed f (Cyclic pn) = Cyclic (MultiValue.Decomposed f pn)
type instance
   MultiValue.PatternTuple (Cyclic pn) = Cyclic (MultiValue.PatternTuple pn)

instance (MultiValue.Compose n) => MultiValue.Compose (Cyclic n) where
   type Composed (Cyclic n) = Cyclic (MultiValue.Composed n)
   compose :: Cyclic n -> T (Composed (Cyclic n))
compose (Cyclic n
n) = T (Composed n) -> T (Cyclic (Composed n))
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic (n -> T (Composed n)
forall multituple.
Compose multituple =>
multituple -> T (Composed multituple)
MultiValue.compose n
n)

instance (MultiValue.Decompose pn) => MultiValue.Decompose (Cyclic pn) where
   decompose :: Cyclic pn
-> T (PatternTuple (Cyclic pn)) -> Decomposed T (Cyclic pn)
decompose (Cyclic pn
p) T (PatternTuple (Cyclic pn))
sh = pn -> T (PatternTuple pn) -> Decomposed T pn
forall pattern.
Decompose pattern =>
pattern -> T (PatternTuple pattern) -> Decomposed T pattern
MultiValue.decompose pn
p (T (PatternTuple pn) -> Decomposed T pn)
-> Cyclic (T (PatternTuple pn)) -> Cyclic (Decomposed T pn)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> T (Cyclic (PatternTuple pn)) -> Cyclic (T (PatternTuple pn))
forall n. T (Cyclic n) -> Cyclic (T n)
unzipCyclic T (Cyclic (PatternTuple pn))
T (PatternTuple (Cyclic pn))
sh

instance (Expr.Compose n) => Expr.Compose (Cyclic n) where
   type Composed (Cyclic n) = Cyclic (Expr.Composed n)
   compose :: Cyclic n -> Exp (Composed (Cyclic n))
compose (Cyclic n
n) = (T (Composed n) -> T (Cyclic (Composed n)))
-> Exp (Composed n) -> Exp (Cyclic (Composed n))
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 T (Composed n) -> T (Cyclic (Composed n))
forall (val :: * -> *) n. Value val => val n -> val (Cyclic n)
cyclic (n -> Exp (Composed n)
forall multituple.
Compose multituple =>
multituple -> Exp (Composed multituple)
Expr.compose n
n)

instance (Expr.Decompose pn) => Expr.Decompose (Cyclic pn) where
   decompose :: Cyclic pn
-> Exp (PatternTuple (Cyclic pn)) -> Decomposed Exp (Cyclic pn)
decompose (Cyclic pn
p) = Decomposed Exp pn -> Cyclic (Decomposed Exp pn)
forall n. n -> Cyclic n
Cyclic (Decomposed Exp pn -> Cyclic (Decomposed Exp pn))
-> (Exp (Cyclic (PatternTuple pn)) -> Decomposed Exp pn)
-> Exp (Cyclic (PatternTuple pn))
-> Cyclic (Decomposed Exp pn)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. pn -> Exp (PatternTuple pn) -> Decomposed Exp pn
forall pattern.
Decompose pattern =>
pattern -> Exp (PatternTuple pattern) -> Decomposed Exp pattern
Expr.decompose pn
p (Exp (PatternTuple pn) -> Decomposed Exp pn)
-> (Exp (Cyclic (PatternTuple pn)) -> Exp (PatternTuple pn))
-> Exp (Cyclic (PatternTuple pn))
-> Decomposed Exp pn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp (Cyclic (PatternTuple pn)) -> Exp (PatternTuple pn)
forall (val :: * -> *) n. Value val => val (Cyclic n) -> val n
cyclicSize

instance (Memory.C n) => Memory.C (Cyclic n) where
   type Struct (Cyclic n) = Memory.Struct n
   compose :: forall r. Cyclic n -> CodeGenFunction r (Value (Struct (Cyclic n)))
compose = n -> CodeGenFunction r (Value (Struct n))
forall r. n -> CodeGenFunction r (Value (Struct n))
forall llvmValue r.
C llvmValue =>
llvmValue -> CodeGenFunction r (Value (Struct llvmValue))
Memory.compose (n -> CodeGenFunction r (Value (Struct n)))
-> (Cyclic n -> n)
-> Cyclic n
-> CodeGenFunction r (Value (Struct n))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cyclic n -> n
forall n. Cyclic n -> n
Shape.cyclicSize
   decompose :: forall r. Value (Struct (Cyclic n)) -> CodeGenFunction r (Cyclic n)
decompose = (n -> Cyclic n)
-> CodeGenFunction r n -> CodeGenFunction r (Cyclic n)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap n -> Cyclic n
forall n. n -> Cyclic n
Cyclic (CodeGenFunction r n -> CodeGenFunction r (Cyclic n))
-> (Value (Struct n) -> CodeGenFunction r n)
-> Value (Struct n)
-> CodeGenFunction r (Cyclic n)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Value (Struct n) -> CodeGenFunction r n
forall llvmValue r.
C llvmValue =>
Value (Struct llvmValue) -> CodeGenFunction r llvmValue
forall r. Value (Struct n) -> CodeGenFunction r n
Memory.decompose

instance (Marshal.C n) => Marshal.C (Cyclic n) where
   pack :: Cyclic n -> Struct (Cyclic n)
pack = n -> Struct n
forall a. C a => a -> Struct a
Marshal.pack (n -> Struct n) -> (Cyclic n -> n) -> Cyclic n -> Struct n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cyclic n -> n
forall n. Cyclic n -> n
Shape.cyclicSize
   unpack :: Struct (Cyclic n) -> Cyclic n
unpack = n -> Cyclic n
forall n. n -> Cyclic n
Shape.Cyclic (n -> Cyclic n) -> (Struct n -> n) -> Struct n -> Cyclic n
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct n -> n
forall a. C a => Struct a -> a
Marshal.unpack



instance (Enum enum, Bounded enum) => MultiValue.C (Enumeration enum) where
   type Repr (Enumeration enum) = ()
   cons :: Enumeration enum -> T (Enumeration enum)
cons = Enumeration enum -> T (Enumeration enum)
forall a. (Repr a ~ ()) => a -> T a
MultiValue.consUnit
   undef :: T (Enumeration enum)
undef = T (Enumeration enum)
forall a. (Repr a ~ ()) => T a
MultiValue.undefUnit
   zero :: T (Enumeration enum)
zero = T (Enumeration enum)
forall a. (Repr a ~ ()) => T a
MultiValue.zeroUnit
   phi :: forall r.
BasicBlock
-> T (Enumeration enum) -> CodeGenFunction r (T (Enumeration enum))
phi = BasicBlock
-> T (Enumeration enum) -> CodeGenFunction r (T (Enumeration enum))
forall a r.
(Repr a ~ ()) =>
BasicBlock -> T a -> CodeGenFunction r (T a)
MultiValue.phiUnit
   addPhi :: forall r.
BasicBlock
-> T (Enumeration enum)
-> T (Enumeration enum)
-> CodeGenFunction r ()
addPhi = BasicBlock
-> T (Enumeration enum)
-> T (Enumeration enum)
-> CodeGenFunction r ()
forall a r.
(Repr a ~ ()) =>
BasicBlock -> T a -> T a -> CodeGenFunction r ()
MultiValue.addPhiUnit

type instance MultiValue.Decomposed f (Enumeration enum) = Enumeration enum
type instance MultiValue.PatternTuple (Enumeration enum) = Enumeration enum

instance
      (Enum enum, Bounded enum) => MultiValue.Compose (Enumeration enum) where
   type Composed (Enumeration enum) = Enumeration enum
   compose :: Enumeration enum -> T (Composed (Enumeration enum))
compose = Enumeration enum -> T (Enumeration enum)
Enumeration enum -> T (Composed (Enumeration enum))
forall a. C a => a -> T a
MultiValue.cons

instance MultiValue.Decompose (Enumeration enum) where
   decompose :: Enumeration enum
-> T (PatternTuple (Enumeration enum))
-> Decomposed T (Enumeration enum)
decompose Enumeration enum
Enumeration T (PatternTuple (Enumeration enum))
_ = Enumeration enum
Decomposed T (Enumeration enum)
forall n. Enumeration n
Enumeration


instance (Enum enum, Bounded enum) => Expr.Compose (Enumeration enum) where
   type Composed (Enumeration enum) = Enumeration enum
   compose :: Enumeration enum -> Exp (Composed (Enumeration enum))
compose = Enumeration enum -> Exp (Enumeration enum)
Enumeration enum -> Exp (Composed (Enumeration enum))
forall a. C a => a -> Exp a
Expr.cons

instance Expr.Decompose (Enumeration enum) where
   decompose :: Enumeration enum
-> Exp (PatternTuple (Enumeration enum))
-> Decomposed Exp (Enumeration enum)
decompose Enumeration enum
Enumeration Exp (PatternTuple (Enumeration enum))
_ = Enumeration enum
Decomposed Exp (Enumeration enum)
forall n. Enumeration n
Enumeration