Torch.HList

Documentation

type family ListLength (xs :: [k]) :: Nat where ...

Equations

ListLength ('[] :: [k]) = 0

ListLength (_h ': t :: [k]) = 1 + ListLength t

data family HList (xs :: [k])

Instances

HasToDevice device' device (HList xs) (HList ys) => ReduceGradients device' '[device] ('[HList xs] :: [Type]) (ys :: [k])

Defined in Torch.Typed.NN.DataParallel

Methods

reduceGradients :: HList '[HList xs] -> HList ys

(HasToDevice device' device (HList xs) (HList ys), ReduceGradients device' devices xxs ys, HZipWith SumF ys ys ys, 1 <= ListLength xxs) => ReduceGradients device' (device ': devices) (HList xs ': xxs :: [Type]) (ys :: [k])

Defined in Torch.Typed.NN.DataParallel

Methods

reduceGradients :: HList (HList xs ': xxs) -> HList ys

(HasToDevice device' device x x', HasToDevice device' device (HList xs) (HList xs')) => HasToDevice device' device (HList (x ': xs)) (HList (x' ': xs'))

Defined in Torch.Typed.Device

Methods

toDevice :: HList (x ': xs) -> HList (x' ': xs')

HasToDevice device' device (HList ('[] :: [Type])) (HList ('[] :: [Type]))

Defined in Torch.Typed.Device

Methods

toDevice :: HList ('[] :: [Type]) -> HList ('[] :: [Type])

(HasGrad (HList parameters) (HList gradients), Castable (HList gradients) [ATenTensor]) => Apply' GradConcurrentlyF (HList parameters, Loss device dtype) (Concurrently (HList gradients))

Defined in Torch.Typed.NN.DataParallel

Methods

apply' :: GradConcurrentlyF -> (HList parameters, Loss device dtype) -> Concurrently (HList gradients)

(HConcatFD as bs, HAppendFD a bs cs) => HConcatFD (HList a ': as :: [Type]) (cs :: [Type])

Defined in Torch.HList

Methods

hconcatFD :: HList (HList a ': as) -> HList cs

(HList (x ': y) ~ z, HZip' xs ys zs) => HZip' (x ': xs :: [Type]) (HList y ': ys :: [Type]) (z ': zs :: [Type])

Defined in Torch.HList

Methods

hzip' :: HList (x ': xs) -> HList (HList y ': ys) -> HList (z ': zs)

(IsList (Maybe (HList (a ': as))), a ~ Item (Maybe (HList (a ': as)))) => IsList (Maybe (HList (a ': (a ': as))))

Defined in Torch.HList

Associated Types

type Item (Maybe (HList (a ': (a ': as))))

Defined in Torch.HList

type Item (Maybe (HList (a ': (a ': as)))) = a

Methods

fromList :: [Item (Maybe (HList (a ': (a ': as))))] -> Maybe (HList (a ': (a ': as)))

fromListN :: Int -> [Item (Maybe (HList (a ': (a ': as))))] -> Maybe (HList (a ': (a ': as)))

toList :: Maybe (HList (a ': (a ': as))) -> [Item (Maybe (HList (a ': (a ': as))))]

IsList (Maybe (HList '[a]))

Defined in Torch.HList

Associated Types

type Item (Maybe (HList '[a]))

Defined in Torch.HList

type Item (Maybe (HList '[a])) = a

Methods

fromList :: [Item (Maybe (HList '[a]))] -> Maybe (HList '[a])

fromListN :: Int -> [Item (Maybe (HList '[a]))] -> Maybe (HList '[a])

toList :: Maybe (HList '[a]) -> [Item (Maybe (HList '[a]))]

(Monoid a, Monoid (HList as)) => Monoid (HList (a ': as))

Defined in Torch.HList

Methods

mempty :: HList (a ': as)

mappend :: HList (a ': as) -> HList (a ': as) -> HList (a ': as)

mconcat :: [HList (a ': as)] -> HList (a ': as)

Monoid (HList ('[] :: [k]))

Defined in Torch.HList

Methods

mempty :: HList ('[] :: [k])

mappend :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

mconcat :: [HList ('[] :: [k])] -> HList ('[] :: [k])

(Semigroup a, Semigroup (HList as)) => Semigroup (HList (a ': as))

Defined in Torch.HList

Methods

(<>) :: HList (a ': as) -> HList (a ': as) -> HList (a ': as)

sconcat :: NonEmpty (HList (a ': as)) -> HList (a ': as)

stimes :: Integral b => b -> HList (a ': as) -> HList (a ': as)

Semigroup (HList ('[] :: [k]))

Defined in Torch.HList

Methods

(<>) :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

sconcat :: NonEmpty (HList ('[] :: [k])) -> HList ('[] :: [k])

stimes :: Integral b => b -> HList ('[] :: [k]) -> HList ('[] :: [k])

(Show e, Show (HList l)) => Show (HList (e ': l))

Defined in Torch.HList

Methods

showsPrec :: Int -> HList (e ': l) -> ShowS

show :: HList (e ': l) -> String

showList :: [HList (e ': l)] -> ShowS

Show (HList ('[] :: [k]))

Defined in Torch.HList

Methods

showsPrec :: Int -> HList ('[] :: [k]) -> ShowS

show :: HList ('[] :: [k]) -> String

showList :: [HList ('[] :: [k])] -> ShowS

(Eq x, Eq (HList xs)) => Eq (HList (x ': xs))

Defined in Torch.HList

Methods

(==) :: HList (x ': xs) -> HList (x ': xs) -> Bool

(/=) :: HList (x ': xs) -> HList (x ': xs) -> Bool

Eq (HList ('[] :: [k]))

Defined in Torch.HList

Methods

(==) :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> Bool

(/=) :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> Bool

(Parameterized f, Parameterized (HList fs), HAppendFD (Parameters f) (Parameters (HList fs)) (Parameters f ++ Parameters (HList fs))) => Parameterized (HList (f ': fs))

Defined in Torch.Typed.Parameter

Associated Types

type Parameters (HList (f ': fs))

Defined in Torch.Typed.Parameter

type Parameters (HList (f ': fs)) = Parameters f ++ Parameters (HList fs)

Methods

flattenParameters :: HList (f ': fs) -> HList (Parameters (HList (f ': fs)))

replaceParameters :: HList (f ': fs) -> HList (Parameters (HList (f ': fs))) -> HList (f ': fs)

Parameterized (HList ('[] :: [k]))

Defined in Torch.Typed.Parameter

Associated Types

type Parameters (HList ('[] :: [k]))

Defined in Torch.Typed.Parameter

type Parameters (HList ('[] :: [k])) = '[] :: [Type]

Methods

flattenParameters :: HList ('[] :: [k]) -> HList (Parameters (HList ('[] :: [k])))

replaceParameters :: HList ('[] :: [k]) -> HList (Parameters (HList ('[] :: [k]))) -> HList ('[] :: [k])

(HFoldrM IO TensorListFold [ATenTensor] l [ATenTensor], Apply TensorListUnfold [ATenTensor] res, HUnfoldM IO TensorListUnfold res l, res ~ HUnfoldMRes IO [ATenTensor] l) => Castable (HList l) [ATenTensor]

Defined in Torch.Typed.Tensor

Methods

cast :: HList l -> ([ATenTensor] -> IO r) -> IO r

uncast :: [ATenTensor] -> (HList l -> IO r) -> IO r

Castable (HList l) [ATenTensor] => Castable (HList l) (ForeignPtr TensorList)

Defined in Torch.Typed.Tensor

Methods

cast :: HList l -> (ForeignPtr TensorList -> IO r) -> IO r

uncast :: ForeignPtr TensorList -> (HList l -> IO r) -> IO r

(Randomizable xSpec x, Randomizable (HList xsSpec) (HList xs)) => Randomizable (HList (xSpec ': xsSpec)) (HList (x ': xs))

Defined in Torch.Typed.Parameter

Methods

sample :: HList (xSpec ': xsSpec) -> IO (HList (x ': xs))

Randomizable (HList ('[] :: [Type])) (HList ('[] :: [Type]))

Defined in Torch.Typed.Parameter

Methods

sample :: HList ('[] :: [Type]) -> IO (HList ('[] :: [Type]))

(HasGrad a b, HasGrad (HList as) (HList bs), Castable (HList (b ': bs)) [ATenTensor]) => HasGrad (HList (a ': as)) (HList (b ': bs))

Defined in Torch.Typed.Autograd

Methods

grad :: forall (dtype :: DType) (device :: (DeviceType, Nat)). Tensor device dtype ('[] :: [Nat]) -> HList (a ': as) -> HList (b ': bs)

toDependent :: HList (a ': as) -> HList (b ': bs)

HasGrad (HList ('[] :: [Type])) (HList ('[] :: [Type]))

Defined in Torch.Typed.Autograd

Methods

grad :: forall (dtype :: DType) (device :: (DeviceType, Nat)). Tensor device dtype ('[] :: [Nat]) -> HList ('[] :: [Type]) -> HList ('[] :: [Type])

toDependent :: HList ('[] :: [Type]) -> HList ('[] :: [Type])

data HList ('[] :: [k])

Defined in Torch.HList

data HList ('[] :: [k]) = HNil

newtype HList (x ': xs :: [Type])

Defined in Torch.HList

newtype HList (x ': xs :: [Type]) = HCons (x, HList xs)

type Item (Maybe (HList (a ': (a ': as))))

Defined in Torch.HList

type Item (Maybe (HList (a ': (a ': as)))) = a

type Item (Maybe (HList '[a]))

Defined in Torch.HList

type Item (Maybe (HList '[a])) = a

type UnHList (HList a)

Defined in Torch.HList

type UnHList (HList a) = a

type Parameters (HList (f ': fs))

Defined in Torch.Typed.Parameter

type Parameters (HList (f ': fs)) = Parameters f ++ Parameters (HList fs)

type Parameters (HList ('[] :: [k]))

Defined in Torch.Typed.Parameter

type Parameters (HList ('[] :: [k])) = '[] :: [Type]

pattern (:.) :: x -> HList xs -> HList (x ': xs) infixr 2

class Apply f a b where

Methods

apply :: f -> a -> b

Instances

Castable x ATenTensor => Apply TensorListUnfold [ATenTensor] (IO (HJust (x, [ATenTensor])))

Defined in Torch.Typed.Tensor

Methods

apply :: TensorListUnfold -> [ATenTensor] -> IO (HJust (x, [ATenTensor]))

Apply TensorListUnfold [ATenTensor] (IO HNothing)

Defined in Torch.Typed.Tensor

Methods

apply :: TensorListUnfold -> [ATenTensor] -> IO HNothing

class Apply' f a b | f a -> b where

Stronger version of Apply that allows for better inference of the return type

Methods

apply' :: f -> a -> b

Instances

(HZip' a b c, x ~ (HList a, HList b), y ~ HList c) => Apply' HZipF x y

Defined in Torch.HList

Methods

apply' :: HZipF -> x -> y

(momentum ~ Tensor device dtype shape, KnownDevice device, KnownDType dtype, shape ~ Reverse (Reverse shape), BasicArithmeticDTypeIsValid device dtype) => Apply' AdamBiasAdjustment momentum momentum

bias adjustment

Defined in Torch.Typed.Optim

Methods

apply' :: AdamBiasAdjustment -> momentum -> momentum

(parameter ~ Parameter device dtype shape, momentum ~ Tensor device dtype shape, TensorOptions shape dtype device) => Apply' ZerosLike parameter momentum

Defined in Torch.Typed.Optim

Methods

apply' :: ZerosLike -> parameter -> momentum

Apply' AFst (a, b) a

Defined in Torch.HList

Methods

apply' :: AFst -> (a, b) -> a

Apply' ASnd (a, b) b

Defined in Torch.HList

Methods

apply' :: ASnd -> (a, b) -> b

Num y => Apply' SumF (y, y) y

Defined in Torch.Typed.NN.DataParallel

Methods

apply' :: SumF -> (y, y) -> y

(gradient ~ Tensor device dtype shape, momentum1 ~ Tensor device dtype shape, KnownDevice device) => Apply' AdamMomentum1Update (momentum1, gradient) momentum1

decaying average of the first momenta

Defined in Torch.Typed.Optim

Methods

apply' :: AdamMomentum1Update -> (momentum1, gradient) -> momentum1

(gradient ~ Tensor device dtype shape, momentum2 ~ Tensor device dtype shape, shape ~ Broadcast shape shape, KnownDevice device, BasicArithmeticDTypeIsValid device dtype) => Apply' AdamMomentum2Update (momentum2, gradient) momentum2

decaying average of the second momenta

Defined in Torch.Typed.Optim

Methods

apply' :: AdamMomentum2Update -> (momentum2, gradient) -> momentum2

HasForward model input output => Apply' ForwardConcurrentlyF (model, input) (Concurrently output)

Defined in Torch.Typed.NN.DataParallel

Methods

apply' :: ForwardConcurrentlyF -> (model, input) -> Concurrently output

(HasGrad (HList parameters) (HList gradients), Castable (HList gradients) [ATenTensor]) => Apply' GradConcurrentlyF (HList parameters, Loss device dtype) (Concurrently (HList gradients))

Defined in Torch.Typed.NN.DataParallel

Methods

apply' :: GradConcurrentlyF -> (HList parameters, Loss device dtype) -> Concurrently (HList gradients)

Castable x ATenTensor => Apply' TensorListFold (x, IO [ATenTensor]) (IO [ATenTensor])

Defined in Torch.Typed.Tensor

Methods

apply' :: TensorListFold -> (x, IO [ATenTensor]) -> IO [ATenTensor]

Apply' MakeIndependent (Tensor device dtype shape) (IO (Parameter device dtype shape))

Defined in Torch.Typed.Parameter

Methods

apply' :: MakeIndependent -> Tensor device dtype shape -> IO (Parameter device dtype shape)

Apply' ToParameter (Tensor dev dtype shape) (Parameter dev dtype shape)

Defined in Torch.Typed.Optim.CppOptim

Methods

apply' :: ToParameter -> Tensor dev dtype shape -> Parameter dev dtype shape

Apply' ToDependent (Parameter device dtype shape) (Tensor device dtype shape)

Defined in Torch.Typed.Parameter

Methods

apply' :: ToDependent -> Parameter device dtype shape -> Tensor device dtype shape

(parameter ~ Tensor device dtype shape, gradient ~ Tensor device dtype shape, shape ~ Broadcast ('[] :: [Nat]) shape, BasicArithmeticDTypeIsValid device dtype, KnownDevice device) => Apply' (GDStep device dtype) (parameter, gradient) parameter

Defined in Torch.Typed.Optim

Methods

apply' :: GDStep device dtype -> (parameter, gradient) -> parameter

(parameter ~ Tensor device dtype shape, momentum ~ Tensor device dtype shape, shape ~ Broadcast ('[] :: [Nat]) shape, KnownDevice device, BasicArithmeticDTypeIsValid device dtype, StandardFloatingPointDTypeValidation device dtype) => Apply' (AdamParameterUpdate device dtype) (parameter, momentum, momentum) parameter

parameter update

Defined in Torch.Typed.Optim

Methods

apply' :: AdamParameterUpdate device dtype -> (parameter, momentum, momentum) -> parameter

(parameter ~ Tensor device dtype shape, gradient ~ Tensor device dtype shape, momentum ~ Tensor device dtype shape, shape ~ Broadcast ('[] :: [Nat]) shape, KnownDevice device, BasicArithmeticDTypeIsValid device dtype) => Apply' (GDMStep device dtype) (parameter, gradient, momentum) (parameter, momentum)

Defined in Torch.Typed.Optim

Methods

apply' :: GDMStep device dtype -> (parameter, gradient, momentum) -> (parameter, momentum)

(1 <= numHeads, embedDim ~ (headDim * numHeads), All KnownNat '[embedDim, numHeads, seqLen, batchSize, headDim], IsSuffixOf '[embedDim] '[batchSize, seqLen, embedDim], KnownDType dtype, StandardFloatingPointDTypeValidation device dtype, MatMulDTypeIsValid device dtype, BasicArithmeticDTypeIsValid device dtype, dtype ~ SumDType dtype, SumDTypeIsValid device dtype, KnownDevice device) => Apply' (FoldLayers batchSize seqLen dtype device) (TransformerLayer embedDim embedDim embedDim numHeads ffnDim dtype device, IO (Tensor device dtype '[batchSize, seqLen, embedDim])) (IO (Tensor device dtype '[batchSize, seqLen, embedDim]))

Defined in Torch.Typed.NN.Transformer

Methods

apply' :: FoldLayers batchSize seqLen dtype device -> (TransformerLayer embedDim embedDim embedDim numHeads ffnDim dtype device, IO (Tensor device dtype '[batchSize, seqLen, embedDim])) -> IO (Tensor device dtype '[batchSize, seqLen, embedDim])

data AFst

Constructors

AFst

Instances

Apply' AFst (a, b) a

Defined in Torch.HList

Methods

apply' :: AFst -> (a, b) -> a

data ASnd

Constructors

ASnd

Instances

Apply' ASnd (a, b) b

Defined in Torch.HList

Methods

apply' :: ASnd -> (a, b) -> b

class HMap f (xs :: [k]) (ys :: [k]) where

Methods

hmap :: f -> HList xs -> HList ys

Instances

HMap f ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hmap :: f -> HList ('[] :: [k]) -> HList ('[] :: [k])

(Apply f x y, HMap f xs ys) => HMap f (x ': xs :: [Type]) (y ': ys :: [Type])

Defined in Torch.HList

Methods

hmap :: f -> HList (x ': xs) -> HList (y ': ys)

class HMap' f (xs :: [k]) (ys :: [k]) | f xs -> ys where

Alternative version of HMap with better type inference based on Apply'

Methods

hmap' :: f -> HList xs -> HList ys

Instances

HMap' f ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hmap' :: f -> HList ('[] :: [k]) -> HList ('[] :: [k])

(Apply' f x y, HMap' f xs ys) => HMap' f (x ': xs :: [Type]) (y ': ys :: [Type])

Defined in Torch.HList

Methods

hmap' :: f -> HList (x ': xs) -> HList (y ': ys)

class HMapM (m :: Type -> Type) f (xs :: [k]) (ys :: [k]) where

Methods

hmapM :: f -> HList xs -> m (HList ys)

Instances

Monad m => HMapM m f ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hmapM :: f -> HList ('[] :: [k]) -> m (HList ('[] :: [k]))

(Monad m, Apply f x (m y), HMapM m f xs ys) => HMapM m f (x ': xs :: [Type]) (y ': ys :: [Type])

Defined in Torch.HList

Methods

hmapM :: f -> HList (x ': xs) -> m (HList (y ': ys))

class HMapM' (m :: Type -> Type) f (xs :: [k]) (ys :: [k]) | f xs -> ys where

Methods

hmapM' :: f -> HList xs -> m (HList ys)

Instances

Applicative m => HMapM' m f ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hmapM' :: f -> HList ('[] :: [k]) -> m (HList ('[] :: [k]))

(Applicative m, Apply' f x (m y), HMapM' m f xs ys) => HMapM' m f (x ': xs :: [Type]) (y ': ys :: [Type])

Defined in Torch.HList

Methods

hmapM' :: f -> HList (x ': xs) -> m (HList (y ': ys))

class Applicative f => HSequence (f :: Type -> Type) (xs :: [k]) (ys :: [k]) | xs -> ys, ys f -> xs where

Methods

hsequence :: HList xs -> f (HList ys)

Instances

Applicative f => HSequence f ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hsequence :: HList ('[] :: [k]) -> f (HList ('[] :: [k]))

(Applicative g, HSequence f xs ys, y ~ x, f ~ g) => HSequence g (f x ': xs :: [Type]) (y ': ys :: [Type])

Defined in Torch.HList

Methods

hsequence :: HList (f x ': xs) -> g (HList (y ': ys))

class HFoldr f acc (xs :: [k]) res | f acc xs -> res where

Methods

hfoldr :: f -> acc -> HList xs -> res

Instances

acc ~ res => HFoldr f acc ('[] :: [k]) res

Defined in Torch.HList

Methods

hfoldr :: f -> acc -> HList ('[] :: [k]) -> res

(Apply' f (x, res) res', HFoldr f acc xs res) => HFoldr f acc (x ': xs :: [Type]) res'

Defined in Torch.HList

Methods

hfoldr :: f -> acc -> HList (x ': xs) -> res'

class HFoldrM (m :: k -> Type) f acc (xs :: [k1]) (res :: k) | m f acc xs -> res where

Methods

hfoldrM :: f -> acc -> HList xs -> m res

Instances

(Monad m, acc ~ res) => HFoldrM (m :: Type -> Type) f acc ('[] :: [k]) (res :: Type)

Defined in Torch.HList

Methods

hfoldrM :: f -> acc -> HList ('[] :: [k]) -> m res

(Monad m, Apply' f (x, m res) (m res'), HFoldrM m f acc xs res) => HFoldrM (m :: Type -> Type) f acc (x ': xs :: [Type]) (res' :: Type)

Defined in Torch.HList

Methods

hfoldrM :: f -> acc -> HList (x ': xs) -> m res'

data HNothing

Constructors

HNothing

Instances

HUnfold f HNothing ('[] :: [k])

Defined in Torch.HList

Methods

hunfoldr' :: f -> HNothing -> HList ('[] :: [k])

Monad m => HUnfoldM m f (m HNothing) ('[] :: [k])

Defined in Torch.HList

Methods

hunfoldrM' :: f -> m HNothing -> m (HList ('[] :: [k]))

Apply TensorListUnfold [ATenTensor] (IO HNothing)

Defined in Torch.Typed.Tensor

Methods

apply :: TensorListUnfold -> [ATenTensor] -> IO HNothing

newtype HJust x

Constructors

HJust x

Instances

(Monad m, HUnfoldM m f res xs, Apply f s res, res ~ HUnfoldMRes m s xs) => HUnfoldM m f (m (HJust (x, s))) (x ': xs :: [Type])

Defined in Torch.HList

Methods

hunfoldrM' :: f -> m (HJust (x, s)) -> m (HList (x ': xs))

(Apply f s res, HUnfold f res xs, res ~ HUnfoldRes s xs) => HUnfold f (HJust (x, s)) (x ': xs :: [Type])

Defined in Torch.HList

Methods

hunfoldr' :: f -> HJust (x, s) -> HList (x ': xs)

Castable x ATenTensor => Apply TensorListUnfold [ATenTensor] (IO (HJust (x, [ATenTensor])))

Defined in Torch.Typed.Tensor

Methods

apply :: TensorListUnfold -> [ATenTensor] -> IO (HJust (x, [ATenTensor]))

class HUnfold f res (xs :: [k]) where

Methods

hunfoldr' :: f -> res -> HList xs

Instances

HUnfold f HNothing ('[] :: [k])

Defined in Torch.HList

Methods

hunfoldr' :: f -> HNothing -> HList ('[] :: [k])

(Apply f s res, HUnfold f res xs, res ~ HUnfoldRes s xs) => HUnfold f (HJust (x, s)) (x ': xs :: [Type])

Defined in Torch.HList

Methods

hunfoldr' :: f -> HJust (x, s) -> HList (x ': xs)

type family HUnfoldRes s (xs :: [Type]) where ...

Equations

HUnfoldRes _1 ('[] :: [Type]) = HNothing

HUnfoldRes s (x ': _1) = HJust (x, s)

hunfoldr :: forall f res (xs :: [Type]) a. (Apply f a res, HUnfold f res xs, res ~ HUnfoldRes a xs) => f -> a -> HList xs

class HUnfoldM (m :: Type -> Type) f res (xs :: [k]) where

Methods

hunfoldrM' :: f -> res -> m (HList xs)

Instances

Monad m => HUnfoldM m f (m HNothing) ('[] :: [k])

Defined in Torch.HList

Methods

hunfoldrM' :: f -> m HNothing -> m (HList ('[] :: [k]))

(Monad m, HUnfoldM m f res xs, Apply f s res, res ~ HUnfoldMRes m s xs) => HUnfoldM m f (m (HJust (x, s))) (x ': xs :: [Type])

Defined in Torch.HList

Methods

hunfoldrM' :: f -> m (HJust (x, s)) -> m (HList (x ': xs))

type family HUnfoldMRes (m :: Type -> k) s (xs :: [Type]) :: k where ...

Equations

HUnfoldMRes (m :: Type -> k) _1 ('[] :: [Type]) = m HNothing

HUnfoldMRes (m :: Type -> k) s (x ': _1) = m (HJust (x, s))

hunfoldrM :: forall m f res (xs :: [Type]) a. (HUnfoldM m f res xs, Apply f a res, res ~ HUnfoldMRes m a xs) => f -> a -> m (HList xs)

type HReplicate (n :: Nat) e = HReplicateFD n e (HReplicateR n e)

hreplicate :: forall (n :: Nat) e. HReplicate n e => e -> HList (HReplicateR n e)

class HReplicateFD (n :: Nat) e (es :: [Type]) | n e -> es where

Methods

hreplicateFD :: e -> HList es

Instances

(HReplicateFD (n - 1) e es, es' ~ (e ': es), 1 <= n) => HReplicateFD n e es'

Defined in Torch.HList

Methods

hreplicateFD :: e -> HList es'

HReplicateFD 0 e ('[] :: [Type])

Defined in Torch.HList

Methods

hreplicateFD :: e -> HList ('[] :: [Type])

type family HReplicateR (n :: Nat) (e :: a) :: [a] where ...

Equations

HReplicateR 0 (_1 :: a) = '[] :: [a]

HReplicateR n (e :: a) = e ': HReplicateR (n - 1) e

type HConcat (xs :: [Type]) = HConcatFD xs (HConcatR xs)

hconcat :: forall (xs :: [Type]). HConcat xs => HList xs -> HList (HConcatR xs)

type family HConcatR (a :: [Type]) :: [Type]

Instances

type HConcatR ('[] :: [Type])

Defined in Torch.HList

type HConcatR ('[] :: [Type]) = '[] :: [Type]

type HConcatR (x ': xs)

Defined in Torch.HList

type HConcatR (x ': xs) = UnHList x ++ HConcatR xs

type family UnHList a :: [Type]

Instances

type UnHList (HList a)

Defined in Torch.HList

type UnHList (HList a) = a

class HConcatFD (xxs :: [k]) (xs :: [k]) | xxs -> xs where

Methods

hconcatFD :: HList xxs -> HList xs

Instances

HConcatFD ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hconcatFD :: HList ('[] :: [k]) -> HList ('[] :: [k])

(HConcatFD as bs, HAppendFD a bs cs) => HConcatFD (HList a ': as :: [Type]) (cs :: [Type])

Defined in Torch.HList

Methods

hconcatFD :: HList (HList a ': as) -> HList cs

type HAppend (as :: [k]) (bs :: [k]) = HAppendFD as bs (as ++ bs)

happend :: forall {k} (as :: [k]) (bs :: [k]). HAppend as bs => HList as -> HList bs -> HList (as ++ bs)

hunappend :: forall {k} (cs :: [k]) (as :: [k]) (bs :: [k]). (cs ~ (as ++ bs), HAppend as bs) => HList cs -> (HList as, HList bs)

class HAppendFD (a :: [k]) (b :: [k]) (ab :: [k]) | a b -> ab, a ab -> b where

Methods

happendFD :: HList a -> HList b -> HList ab

hunappendFD :: HList ab -> (HList a, HList b)

Instances

HAppendFD ('[] :: [k]) (b :: [k]) (b :: [k])

Defined in Torch.HList

Methods

happendFD :: HList ('[] :: [k]) -> HList b -> HList b

hunappendFD :: HList b -> (HList ('[] :: [k]), HList b)

HAppendFD as bs cs => HAppendFD (a ': as :: [Type]) (bs :: [Type]) (a ': cs :: [Type])

Defined in Torch.HList

Methods

happendFD :: HList (a ': as) -> HList bs -> HList (a ': cs)

hunappendFD :: HList (a ': cs) -> (HList (a ': as), HList bs)

type family (as :: [k]) ++ (bs :: [k]) :: [k] where ...

Equations

('[] :: [k]) ++ (bs :: [k]) = bs

(a ': as :: [k]) ++ (bs :: [k]) = a ': (as ++ bs)

class HZip (xs :: [k]) (ys :: [k]) (zs :: [k]) | xs ys -> zs, zs -> xs ys where

Methods

hzip :: HList xs -> HList ys -> HList zs

hunzip :: HList zs -> (HList xs, HList ys)

Instances

HZip ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzip :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

hunzip :: HList ('[] :: [k]) -> (HList ('[] :: [k]), HList ('[] :: [k]))

((x, y) ~ z, HZip xs ys zs) => HZip (x ': xs :: [Type]) (y ': ys :: [Type]) (z ': zs :: [Type])

Defined in Torch.HList

Methods

hzip :: HList (x ': xs) -> HList (y ': ys) -> HList (z ': zs)

hunzip :: HList (z ': zs) -> (HList (x ': xs), HList (y ': ys))

class HZip' (xs :: [k]) (ys :: [k]) (zs :: [k]) | xs ys -> zs where

Methods

hzip' :: HList xs -> HList ys -> HList zs

Instances

HZip' ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzip' :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

(HList (x ': y) ~ z, HZip' xs ys zs) => HZip' (x ': xs :: [Type]) (HList y ': ys :: [Type]) (z ': zs :: [Type])

Defined in Torch.HList

Methods

hzip' :: HList (x ': xs) -> HList (HList y ': ys) -> HList (z ': zs)

data HZipF

Constructors

HZipF

Instances

(HZip' a b c, x ~ (HList a, HList b), y ~ HList c) => Apply' HZipF x y

Defined in Torch.HList

Methods

apply' :: HZipF -> x -> y

htranspose :: forall (acc :: [Type]) (xs :: [Type]) (xxs :: [Type]) res. (HReplicateFD (ListLength xs) (HList ('[] :: [Type])) acc, HFoldr HZipF (HList acc) (HList xs ': xxs) res) => HList (HList xs ': xxs) -> res

class HZipWith f (xs :: [k]) (ys :: [k]) (zs :: [k]) | f xs ys -> zs where

Methods

hzipWith :: f -> HList xs -> HList ys -> HList zs

Instances

HZipWith f ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzipWith :: f -> HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

(Apply' f (x, y) z, HZipWith f xs ys zs) => HZipWith f (x ': xs :: [Type]) (y ': ys :: [Type]) (z ': zs :: [Type])

Defined in Torch.HList

Methods

hzipWith :: f -> HList (x ': xs) -> HList (y ': ys) -> HList (z ': zs)

class HZipWithM (m :: Type -> Type) f (xs :: [k]) (ys :: [k]) (zs :: [k]) | f xs ys -> zs where

Methods

hzipWithM :: f -> HList xs -> HList ys -> m (HList zs)

Instances

Applicative m => HZipWithM m f ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzipWithM :: f -> HList ('[] :: [k]) -> HList ('[] :: [k]) -> m (HList ('[] :: [k]))

(Applicative m, Apply' f (x, y) (m z), HZipWithM m f xs ys zs) => HZipWithM m f (x ': xs :: [Type]) (y ': ys :: [Type]) (z ': zs :: [Type])

Defined in Torch.HList

Methods

hzipWithM :: f -> HList (x ': xs) -> HList (y ': ys) -> m (HList (z ': zs))

class HZip3 (as :: [k]) (bs :: [k]) (cs :: [k]) (ds :: [k]) | as bs cs -> ds, ds -> as bs cs where

Methods

hzip3 :: HList as -> HList bs -> HList cs -> HList ds

hunzip3 :: HList ds -> (HList as, HList bs, HList cs)

Instances

HZip3 ('[] :: [k]) ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzip3 :: HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

hunzip3 :: HList ('[] :: [k]) -> (HList ('[] :: [k]), HList ('[] :: [k]), HList ('[] :: [k]))

((a, b, c) ~ d, HZip3 as bs cs ds) => HZip3 (a ': as :: [Type]) (b ': bs :: [Type]) (c ': cs :: [Type]) (d ': ds :: [Type])

Defined in Torch.HList

Methods

hzip3 :: HList (a ': as) -> HList (b ': bs) -> HList (c ': cs) -> HList (d ': ds)

hunzip3 :: HList (d ': ds) -> (HList (a ': as), HList (b ': bs), HList (c ': cs))

class HZipWith3 f (as :: [k]) (bs :: [k]) (cs :: [k]) (ds :: [k]) | f as bs cs -> ds where

Methods

hzipWith3 :: f -> HList as -> HList bs -> HList cs -> HList ds

Instances

HZipWith3 f ('[] :: [k]) ('[] :: [k]) ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hzipWith3 :: f -> HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k]) -> HList ('[] :: [k])

(Apply' f (a, b, c) d, HZipWith3 f as bs cs ds) => HZipWith3 f (a ': as :: [Type]) (b ': bs :: [Type]) (c ': cs :: [Type]) (d ': ds :: [Type])

Defined in Torch.HList

Methods

hzipWith3 :: f -> HList (a ': as) -> HList (b ': bs) -> HList (c ': cs) -> HList (d ': ds)

class HCartesianProduct (xs :: [k]) (ys :: [k]) (zs :: [k]) | xs ys -> zs where

Methods

hproduct :: HList xs -> HList ys -> HList zs

Instances

HCartesianProduct ('[] :: [k]) (ys :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hproduct :: HList ('[] :: [k]) -> HList ys -> HList ('[] :: [k])

(HCartesianProduct xs ys zs, HAttach x ys xys, HAppendFD xys zs zs') => HCartesianProduct (x ': xs :: [Type]) (ys :: [Type]) (zs' :: [Type])

Defined in Torch.HList

Methods

hproduct :: HList (x ': xs) -> HList ys -> HList zs'

class HAttach x (ys :: [k]) (zs :: [k]) | x ys -> zs where

Methods

hattach :: x -> HList ys -> HList zs

Instances

HAttach x ('[] :: [k]) ('[] :: [k])

Defined in Torch.HList

Methods

hattach :: x -> HList ('[] :: [k]) -> HList ('[] :: [k])

HAttach x ys xys => HAttach x (y ': ys :: [Type]) ((x, y) ': xys :: [Type])

Defined in Torch.HList

Methods

hattach :: x -> HList (y ': ys) -> HList ((x, y) ': xys)