Data.Unrestricted.Internal.Instances

This module exports instances of Consumable, Dupable and Movable

We export instances in this module to avoid a circular dependence and keep things clean. Movable depends on the defintion of Ur yet many instances of Movable which we might have put in the module with Movable depend on Ur. So, we just put the instances of Movable and the other classes (for cleanness) in this module to avoid this dependence.

Documentation

newtype MovableMonoid a

Constructors

MovableMonoid a

Instances

Semigroup a => Semigroup (MovableMonoid a)

Defined in Data.Unrestricted.Internal.Instances

Methods

(<>) :: MovableMonoid a -> MovableMonoid a -> MovableMonoid a

sconcat :: NonEmpty (MovableMonoid a) -> MovableMonoid a

stimes :: Integral b => b -> MovableMonoid a -> MovableMonoid a

Monoid a => Monoid (MovableMonoid a)

Defined in Data.Unrestricted.Internal.Instances

Methods

mempty :: MovableMonoid a

mappend :: MovableMonoid a -> MovableMonoid a -> MovableMonoid a

mconcat :: [MovableMonoid a] -> MovableMonoid a

(Movable a, Semigroup a) => Semigroup (MovableMonoid a)

Defined in Data.Unrestricted.Internal.Instances

Methods

(<>) :: MovableMonoid a %1 -> MovableMonoid a %1 -> MovableMonoid a

(Movable a, Monoid a) => Monoid (MovableMonoid a)

Defined in Data.Unrestricted.Internal.Instances

Methods

mempty :: MovableMonoid a

Orphan instances

Functor Ur

Methods

fmap :: (a -> b) -> Ur a -> Ur b

(<$) :: a -> Ur b -> Ur a

Applicative Ur

Methods

pure :: a -> Ur a

(<*>) :: Ur (a -> b) -> Ur a -> Ur b

liftA2 :: (a -> b -> c) -> Ur a -> Ur b -> Ur c

(*>) :: Ur a -> Ur b -> Ur b

(<*) :: Ur a -> Ur b -> Ur a

Foldable Ur

Methods

fold :: Monoid m => Ur m -> m

foldMap :: Monoid m => (a -> m) -> Ur a -> m

foldMap' :: Monoid m => (a -> m) -> Ur a -> m

foldr :: (a -> b -> b) -> b -> Ur a -> b

foldr' :: (a -> b -> b) -> b -> Ur a -> b

foldl :: (b -> a -> b) -> b -> Ur a -> b

foldl' :: (b -> a -> b) -> b -> Ur a -> b

foldr1 :: (a -> a -> a) -> Ur a -> a

foldl1 :: (a -> a -> a) -> Ur a -> a

toList :: Ur a -> [a]

null :: Ur a -> Bool

length :: Ur a -> Int

elem :: Eq a => a -> Ur a -> Bool

maximum :: Ord a => Ur a -> a

minimum :: Ord a => Ur a -> a

sum :: Num a => Ur a -> a

product :: Num a => Ur a -> a

Traversable Ur

Methods

traverse :: Applicative f => (a -> f b) -> Ur a -> f (Ur b)

sequenceA :: Applicative f => Ur (f a) -> f (Ur a)

mapM :: Monad m => (a -> m b) -> Ur a -> m (Ur b)

sequence :: Monad m => Ur (m a) -> m (Ur a)

Consumable Bool

Methods

consume :: Bool %1 -> ()

Consumable Char

Methods

consume :: Char %1 -> ()

Consumable Double

Methods

consume :: Double %1 -> ()

Consumable Int

Methods

consume :: Int %1 -> ()

Consumable Ordering

Methods

consume :: Ordering %1 -> ()

Consumable ()

Methods

consume :: () %1 -> ()

Consumable Any

Methods

consume :: Any %1 -> ()

Consumable All

Methods

consume :: All %1 -> ()

Functor Ur

Methods

fmap :: (a %1 -> b) -> Ur a %1 -> Ur b

Applicative Ur

Methods

pure :: a -> Ur a

(<*>) :: Ur (a %1 -> b) %1 -> Ur a %1 -> Ur b

liftA2 :: (a %1 -> b %1 -> c) -> Ur a %1 -> Ur b %1 -> Ur c

Dupable Bool

Methods

dupV :: forall (n :: Nat). KnownNat n => Bool %1 -> V n Bool

dup2 :: Bool %1 -> (Bool, Bool)

Dupable Char

Methods

dupV :: forall (n :: Nat). KnownNat n => Char %1 -> V n Char

dup2 :: Char %1 -> (Char, Char)

Dupable Double

Methods

dupV :: forall (n :: Nat). KnownNat n => Double %1 -> V n Double

dup2 :: Double %1 -> (Double, Double)

Dupable Int

Methods

dupV :: forall (n :: Nat). KnownNat n => Int %1 -> V n Int

dup2 :: Int %1 -> (Int, Int)

Dupable Ordering

Methods

dupV :: forall (n :: Nat). KnownNat n => Ordering %1 -> V n Ordering

dup2 :: Ordering %1 -> (Ordering, Ordering)

Dupable ()

Methods

dupV :: forall (n :: Nat). KnownNat n => () %1 -> V n ()

dup2 :: () %1 -> ((), ())

Dupable Any

Methods

dupV :: forall (n :: Nat). KnownNat n => Any %1 -> V n Any

dup2 :: Any %1 -> (Any, Any)

Dupable All

Methods

dupV :: forall (n :: Nat). KnownNat n => All %1 -> V n All

dup2 :: All %1 -> (All, All)

Movable Bool

Methods

move :: Bool %1 -> Ur Bool

Movable Char

Methods

move :: Char %1 -> Ur Char

Movable Double

Methods

move :: Double %1 -> Ur Double

Movable Int

Methods

move :: Int %1 -> Ur Int

Movable Ordering

Methods

move :: Ordering %1 -> Ur Ordering

Movable ()

Methods

move :: () %1 -> Ur ()

Movable Any

Methods

move :: Any %1 -> Ur Any

Movable All

Methods

move :: All %1 -> Ur All

Consumable a => Consumable [a]

Methods

consume :: [a] %1 -> ()

Consumable a => Consumable (Maybe a)

Methods

consume :: Maybe a %1 -> ()

Consumable a => Consumable (Sum a)

Methods

consume :: Sum a %1 -> ()

Consumable a => Consumable (Product a)

Methods

consume :: Product a %1 -> ()

Consumable a => Consumable (NonEmpty a)

Methods

consume :: NonEmpty a %1 -> ()

Consumable (Ur a)

Methods

consume :: Ur a %1 -> ()

Dupable a => Dupable [a]

Methods

dupV :: forall (n :: Nat). KnownNat n => [a] %1 -> V n [a]

dup2 :: [a] %1 -> ([a], [a])

Dupable a => Dupable (Maybe a)

Methods

dupV :: forall (n :: Nat). KnownNat n => Maybe a %1 -> V n (Maybe a)

dup2 :: Maybe a %1 -> (Maybe a, Maybe a)

Dupable a => Dupable (Sum a)

Methods

dupV :: forall (n :: Nat). KnownNat n => Sum a %1 -> V n (Sum a)

dup2 :: Sum a %1 -> (Sum a, Sum a)

Dupable a => Dupable (Product a)

Methods

dupV :: forall (n :: Nat). KnownNat n => Product a %1 -> V n (Product a)

dup2 :: Product a %1 -> (Product a, Product a)

Dupable a => Dupable (NonEmpty a)

Methods

dupV :: forall (n :: Nat). KnownNat n => NonEmpty a %1 -> V n (NonEmpty a)

dup2 :: NonEmpty a %1 -> (NonEmpty a, NonEmpty a)

Dupable (Ur a)

Methods

dupV :: forall (n :: Nat). KnownNat n => Ur a %1 -> V n (Ur a)

dup2 :: Ur a %1 -> (Ur a, Ur a)

Movable a => Movable [a]

Methods

move :: [a] %1 -> Ur [a]

Movable a => Movable (Maybe a)

Methods

move :: Maybe a %1 -> Ur (Maybe a)

Movable a => Movable (Sum a)

Methods

move :: Sum a %1 -> Ur (Sum a)

Movable a => Movable (Product a)

Methods

move :: Product a %1 -> Ur (Product a)

Movable a => Movable (NonEmpty a)

Methods

move :: NonEmpty a %1 -> Ur (NonEmpty a)

Movable (Ur a)

Methods

move :: Ur a %1 -> Ur (Ur a)

(Consumable a, Consumable b) => Consumable (Either a b)

Methods

consume :: Either a b %1 -> ()

(Consumable a, Consumable b) => Consumable (a, b)

Methods

consume :: (a, b) %1 -> ()

(Dupable a, Dupable b) => Dupable (Either a b)

Methods

dupV :: forall (n :: Nat). KnownNat n => Either a b %1 -> V n (Either a b)

dup2 :: Either a b %1 -> (Either a b, Either a b)

(Dupable a, Dupable b) => Dupable (a, b)

Methods

dupV :: forall (n :: Nat). KnownNat n => (a, b) %1 -> V n (a, b)

dup2 :: (a, b) %1 -> ((a, b), (a, b))

(Movable a, Movable b) => Movable (Either a b)

Methods

move :: Either a b %1 -> Ur (Either a b)

(Movable a, Movable b) => Movable (a, b)

Methods

move :: (a, b) %1 -> Ur (a, b)

(Consumable a, Consumable b, Consumable c) => Consumable (a, b, c)

Methods

consume :: (a, b, c) %1 -> ()

(Dupable a, Dupable b, Dupable c) => Dupable (a, b, c)

Methods

dupV :: forall (n :: Nat). KnownNat n => (a, b, c) %1 -> V n (a, b, c)

dup2 :: (a, b, c) %1 -> ((a, b, c), (a, b, c))

(Movable a, Movable b, Movable c) => Movable (a, b, c)

Methods

move :: (a, b, c) %1 -> Ur (a, b, c)