papa-include-0.1.0: Third party libraries

Papa.Include.Data.List

Synopsis

# Documentation

maximum :: Ord a => NonEmpty a -> a Source #

minimum :: Ord a => NonEmpty a -> a Source #

(++) :: Semigroup a => a -> a -> a Source #

mappend :: Semigroup a => a -> a -> a Source #

foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source #

foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source #

foldl1' :: (a -> a -> a) -> NonEmpty a -> a Source #

scanr :: Foldable f => (a -> b -> b) -> b -> f a -> NonEmpty b #

scanr is the right-to-left dual of scanl. Note that

head (scanr f z xs) == foldr f z xs.

scanl :: Foldable f => (b -> a -> b) -> b -> f a -> NonEmpty b #

scanl is similar to foldl, but returns a stream of successive reduced values from the left:

scanl f z [x1, x2, ...] == z :| [z f x1, (z f x1) f x2, ...]

Note that

last (scanl f z xs) == foldl f z xs.

class Semigroup a #

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Instances

 Methodsstimes :: Integral b => b -> Ordering -> Ordering # Methods(<>) :: () -> () -> () #sconcat :: NonEmpty () -> () #stimes :: Integral b => b -> () -> () # Methods(<>) :: Void -> Void -> Void #stimes :: Integral b => b -> Void -> Void # Methods(<>) :: All -> All -> All #stimes :: Integral b => b -> All -> All # Methods(<>) :: Any -> Any -> Any #stimes :: Integral b => b -> Any -> Any # Semigroup [a] Methods(<>) :: [a] -> [a] -> [a] #sconcat :: NonEmpty [a] -> [a] #stimes :: Integral b => b -> [a] -> [a] # Semigroup a => Semigroup (Maybe a) Methods(<>) :: Maybe a -> Maybe a -> Maybe a #sconcat :: NonEmpty (Maybe a) -> Maybe a #stimes :: Integral b => b -> Maybe a -> Maybe a # Ord a => Semigroup (Min a) Methods(<>) :: Min a -> Min a -> Min a #sconcat :: NonEmpty (Min a) -> Min a #stimes :: Integral b => b -> Min a -> Min a # Ord a => Semigroup (Max a) Methods(<>) :: Max a -> Max a -> Max a #sconcat :: NonEmpty (Max a) -> Max a #stimes :: Integral b => b -> Max a -> Max a # Methods(<>) :: First a -> First a -> First a #sconcat :: NonEmpty (First a) -> First a #stimes :: Integral b => b -> First a -> First a # Methods(<>) :: Last a -> Last a -> Last a #sconcat :: NonEmpty (Last a) -> Last a #stimes :: Integral b => b -> Last a -> Last a # Monoid m => Semigroup (WrappedMonoid m) Methods(<>) :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #stimes :: Integral b => b -> WrappedMonoid m -> WrappedMonoid m # Semigroup a => Semigroup (Option a) Methods(<>) :: Option a -> Option a -> Option a #sconcat :: NonEmpty (Option a) -> Option a #stimes :: Integral b => b -> Option a -> Option a # Methods(<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a #sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a #stimes :: Integral b => b -> NonEmpty a -> NonEmpty a # Semigroup a => Semigroup (Dual a) Methods(<>) :: Dual a -> Dual a -> Dual a #sconcat :: NonEmpty (Dual a) -> Dual a #stimes :: Integral b => b -> Dual a -> Dual a # Methods(<>) :: Endo a -> Endo a -> Endo a #sconcat :: NonEmpty (Endo a) -> Endo a #stimes :: Integral b => b -> Endo a -> Endo a # Num a => Semigroup (Sum a) Methods(<>) :: Sum a -> Sum a -> Sum a #sconcat :: NonEmpty (Sum a) -> Sum a #stimes :: Integral b => b -> Sum a -> Sum a # Num a => Semigroup (Product a) Methods(<>) :: Product a -> Product a -> Product a #sconcat :: NonEmpty (Product a) -> Product a #stimes :: Integral b => b -> Product a -> Product a # Methods(<>) :: First a -> First a -> First a #sconcat :: NonEmpty (First a) -> First a #stimes :: Integral b => b -> First a -> First a # Methods(<>) :: Last a -> Last a -> Last a #sconcat :: NonEmpty (Last a) -> Last a #stimes :: Integral b => b -> Last a -> Last a # Semigroup b => Semigroup (a -> b) Methods(<>) :: (a -> b) -> (a -> b) -> a -> b #sconcat :: NonEmpty (a -> b) -> a -> b #stimes :: Integral b => b -> (a -> b) -> a -> b # Semigroup (Either a b) Methods(<>) :: Either a b -> Either a b -> Either a b #sconcat :: NonEmpty (Either a b) -> Either a b #stimes :: Integral b => b -> Either a b -> Either a b # (Semigroup a, Semigroup b) => Semigroup (a, b) Methods(<>) :: (a, b) -> (a, b) -> (a, b) #sconcat :: NonEmpty (a, b) -> (a, b) #stimes :: Integral b => b -> (a, b) -> (a, b) # Semigroup (Proxy k s) Methods(<>) :: Proxy k s -> Proxy k s -> Proxy k s #sconcat :: NonEmpty (Proxy k s) -> Proxy k s #stimes :: Integral b => b -> Proxy k s -> Proxy k s # (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) Methods(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) #sconcat :: NonEmpty (a, b, c) -> (a, b, c) #stimes :: Integral b => b -> (a, b, c) -> (a, b, c) # Semigroup a => Semigroup (Const k a b) Methods(<>) :: Const k a b -> Const k a b -> Const k a b #sconcat :: NonEmpty (Const k a b) -> Const k a b #stimes :: Integral b => b -> Const k a b -> Const k a b # Alternative f => Semigroup (Alt * f a) Methods(<>) :: Alt * f a -> Alt * f a -> Alt * f a #sconcat :: NonEmpty (Alt * f a) -> Alt * f a #stimes :: Integral b => b -> Alt * f a -> Alt * f a # (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) Methods(<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) #stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) # (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) Methods(<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) #stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) #

class Eq a => Ord a #

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

Instances

 Methodscompare :: Bool -> Bool -> Ordering #(<) :: Bool -> Bool -> Bool #(<=) :: Bool -> Bool -> Bool #(>) :: Bool -> Bool -> Bool #(>=) :: Bool -> Bool -> Bool #max :: Bool -> Bool -> Bool #min :: Bool -> Bool -> Bool # Methodscompare :: Char -> Char -> Ordering #(<) :: Char -> Char -> Bool #(<=) :: Char -> Char -> Bool #(>) :: Char -> Char -> Bool #(>=) :: Char -> Char -> Bool #max :: Char -> Char -> Char #min :: Char -> Char -> Char # Methods(<) :: Double -> Double -> Bool #(<=) :: Double -> Double -> Bool #(>) :: Double -> Double -> Bool #(>=) :: Double -> Double -> Bool #max :: Double -> Double -> Double #min :: Double -> Double -> Double # Methods(<) :: Float -> Float -> Bool #(<=) :: Float -> Float -> Bool #(>) :: Float -> Float -> Bool #(>=) :: Float -> Float -> Bool #max :: Float -> Float -> Float #min :: Float -> Float -> Float # Methodscompare :: Int -> Int -> Ordering #(<) :: Int -> Int -> Bool #(<=) :: Int -> Int -> Bool #(>) :: Int -> Int -> Bool #(>=) :: Int -> Int -> Bool #max :: Int -> Int -> Int #min :: Int -> Int -> Int # Methodscompare :: Int8 -> Int8 -> Ordering #(<) :: Int8 -> Int8 -> Bool #(<=) :: Int8 -> Int8 -> Bool #(>) :: Int8 -> Int8 -> Bool #(>=) :: Int8 -> Int8 -> Bool #max :: Int8 -> Int8 -> Int8 #min :: Int8 -> Int8 -> Int8 # Methods(<) :: Int16 -> Int16 -> Bool #(<=) :: Int16 -> Int16 -> Bool #(>) :: Int16 -> Int16 -> Bool #(>=) :: Int16 -> Int16 -> Bool #max :: Int16 -> Int16 -> Int16 #min :: Int16 -> Int16 -> Int16 # Methods(<) :: Int32 -> Int32 -> Bool #(<=) :: Int32 -> Int32 -> Bool #(>) :: Int32 -> Int32 -> Bool #(>=) :: Int32 -> Int32 -> Bool #max :: Int32 -> Int32 -> Int32 #min :: Int32 -> Int32 -> Int32 # Methods(<) :: Int64 -> Int64 -> Bool #(<=) :: Int64 -> Int64 -> Bool #(>) :: Int64 -> Int64 -> Bool #(>=) :: Int64 -> Int64 -> Bool #max :: Int64 -> Int64 -> Int64 #min :: Int64 -> Int64 -> Int64 # Methods(<) :: Ordering -> Ordering -> Bool #(>) :: Ordering -> Ordering -> Bool # Methodscompare :: Word -> Word -> Ordering #(<) :: Word -> Word -> Bool #(<=) :: Word -> Word -> Bool #(>) :: Word -> Word -> Bool #(>=) :: Word -> Word -> Bool #max :: Word -> Word -> Word #min :: Word -> Word -> Word # Methods(<) :: Word8 -> Word8 -> Bool #(<=) :: Word8 -> Word8 -> Bool #(>) :: Word8 -> Word8 -> Bool #(>=) :: Word8 -> Word8 -> Bool #max :: Word8 -> Word8 -> Word8 #min :: Word8 -> Word8 -> Word8 # Methods(<) :: Word16 -> Word16 -> Bool #(<=) :: Word16 -> Word16 -> Bool #(>) :: Word16 -> Word16 -> Bool #(>=) :: Word16 -> Word16 -> Bool #max :: Word16 -> Word16 -> Word16 #min :: Word16 -> Word16 -> Word16 # Methods(<) :: Word32 -> Word32 -> Bool #(<=) :: Word32 -> Word32 -> Bool #(>) :: Word32 -> Word32 -> Bool #(>=) :: Word32 -> Word32 -> Bool #max :: Word32 -> Word32 -> Word32 #min :: Word32 -> Word32 -> Word32 # Methods(<) :: Word64 -> Word64 -> Bool #(<=) :: Word64 -> Word64 -> Bool #(>) :: Word64 -> Word64 -> Bool #(>=) :: Word64 -> Word64 -> Bool #max :: Word64 -> Word64 -> Word64 #min :: Word64 -> Word64 -> Word64 # Ord () Methodscompare :: () -> () -> Ordering #(<) :: () -> () -> Bool #(<=) :: () -> () -> Bool #(>) :: () -> () -> Bool #(>=) :: () -> () -> Bool #max :: () -> () -> () #min :: () -> () -> () # Methods(<) :: TyCon -> TyCon -> Bool #(<=) :: TyCon -> TyCon -> Bool #(>) :: TyCon -> TyCon -> Bool #(>=) :: TyCon -> TyCon -> Bool #max :: TyCon -> TyCon -> TyCon #min :: TyCon -> TyCon -> TyCon # Methodscompare :: Void -> Void -> Ordering #(<) :: Void -> Void -> Bool #(<=) :: Void -> Void -> Bool #(>) :: Void -> Void -> Bool #(>=) :: Void -> Void -> Bool #max :: Void -> Void -> Void #min :: Void -> Void -> Void # Methods(<) :: Version -> Version -> Bool #(<=) :: Version -> Version -> Bool #(>) :: Version -> Version -> Bool #(>=) :: Version -> Version -> Bool # Methods Methods Methods(<) :: ExitCode -> ExitCode -> Bool #(>) :: ExitCode -> ExitCode -> Bool # Methodscompare :: All -> All -> Ordering #(<) :: All -> All -> Bool #(<=) :: All -> All -> Bool #(>) :: All -> All -> Bool #(>=) :: All -> All -> Bool #max :: All -> All -> All #min :: All -> All -> All # Methodscompare :: Any -> Any -> Ordering #(<) :: Any -> Any -> Bool #(<=) :: Any -> Any -> Bool #(>) :: Any -> Any -> Bool #(>=) :: Any -> Any -> Bool #max :: Any -> Any -> Any #min :: Any -> Any -> Any # Methods(<) :: Fixity -> Fixity -> Bool #(<=) :: Fixity -> Fixity -> Bool #(>) :: Fixity -> Fixity -> Bool #(>=) :: Fixity -> Fixity -> Bool #max :: Fixity -> Fixity -> Fixity #min :: Fixity -> Fixity -> Fixity # Methods Methods Methods Methods Methods(<) :: SomeNat -> SomeNat -> Bool #(<=) :: SomeNat -> SomeNat -> Bool #(>) :: SomeNat -> SomeNat -> Bool #(>=) :: SomeNat -> SomeNat -> Bool # Methods Ord a => Ord [a] Methodscompare :: [a] -> [a] -> Ordering #(<) :: [a] -> [a] -> Bool #(<=) :: [a] -> [a] -> Bool #(>) :: [a] -> [a] -> Bool #(>=) :: [a] -> [a] -> Bool #max :: [a] -> [a] -> [a] #min :: [a] -> [a] -> [a] # Ord a => Ord (Maybe a) Methodscompare :: Maybe a -> Maybe a -> Ordering #(<) :: Maybe a -> Maybe a -> Bool #(<=) :: Maybe a -> Maybe a -> Bool #(>) :: Maybe a -> Maybe a -> Bool #(>=) :: Maybe a -> Maybe a -> Bool #max :: Maybe a -> Maybe a -> Maybe a #min :: Maybe a -> Maybe a -> Maybe a # Integral a => Ord (Ratio a) Methodscompare :: Ratio a -> Ratio a -> Ordering #(<) :: Ratio a -> Ratio a -> Bool #(<=) :: Ratio a -> Ratio a -> Bool #(>) :: Ratio a -> Ratio a -> Bool #(>=) :: Ratio a -> Ratio a -> Bool #max :: Ratio a -> Ratio a -> Ratio a #min :: Ratio a -> Ratio a -> Ratio a # Ord (Ptr a) Methodscompare :: Ptr a -> Ptr a -> Ordering #(<) :: Ptr a -> Ptr a -> Bool #(<=) :: Ptr a -> Ptr a -> Bool #(>) :: Ptr a -> Ptr a -> Bool #(>=) :: Ptr a -> Ptr a -> Bool #max :: Ptr a -> Ptr a -> Ptr a #min :: Ptr a -> Ptr a -> Ptr a # Ord (FunPtr a) Methodscompare :: FunPtr a -> FunPtr a -> Ordering #(<) :: FunPtr a -> FunPtr a -> Bool #(<=) :: FunPtr a -> FunPtr a -> Bool #(>) :: FunPtr a -> FunPtr a -> Bool #(>=) :: FunPtr a -> FunPtr a -> Bool #max :: FunPtr a -> FunPtr a -> FunPtr a #min :: FunPtr a -> FunPtr a -> FunPtr a # Ord (V1 p) Methodscompare :: V1 p -> V1 p -> Ordering #(<) :: V1 p -> V1 p -> Bool #(<=) :: V1 p -> V1 p -> Bool #(>) :: V1 p -> V1 p -> Bool #(>=) :: V1 p -> V1 p -> Bool #max :: V1 p -> V1 p -> V1 p #min :: V1 p -> V1 p -> V1 p # Ord (U1 p) Methodscompare :: U1 p -> U1 p -> Ordering #(<) :: U1 p -> U1 p -> Bool #(<=) :: U1 p -> U1 p -> Bool #(>) :: U1 p -> U1 p -> Bool #(>=) :: U1 p -> U1 p -> Bool #max :: U1 p -> U1 p -> U1 p #min :: U1 p -> U1 p -> U1 p # Ord p => Ord (Par1 p) Methodscompare :: Par1 p -> Par1 p -> Ordering #(<) :: Par1 p -> Par1 p -> Bool #(<=) :: Par1 p -> Par1 p -> Bool #(>) :: Par1 p -> Par1 p -> Bool #(>=) :: Par1 p -> Par1 p -> Bool #max :: Par1 p -> Par1 p -> Par1 p #min :: Par1 p -> Par1 p -> Par1 p # Ord a => Ord (Min a) Methodscompare :: Min a -> Min a -> Ordering #(<) :: Min a -> Min a -> Bool #(<=) :: Min a -> Min a -> Bool #(>) :: Min a -> Min a -> Bool #(>=) :: Min a -> Min a -> Bool #max :: Min a -> Min a -> Min a #min :: Min a -> Min a -> Min a # Ord a => Ord (Max a) Methodscompare :: Max a -> Max a -> Ordering #(<) :: Max a -> Max a -> Bool #(<=) :: Max a -> Max a -> Bool #(>) :: Max a -> Max a -> Bool #(>=) :: Max a -> Max a -> Bool #max :: Max a -> Max a -> Max a #min :: Max a -> Max a -> Max a # Ord a => Ord (First a) Methodscompare :: First a -> First a -> Ordering #(<) :: First a -> First a -> Bool #(<=) :: First a -> First a -> Bool #(>) :: First a -> First a -> Bool #(>=) :: First a -> First a -> Bool #max :: First a -> First a -> First a #min :: First a -> First a -> First a # Ord a => Ord (Last a) Methodscompare :: Last a -> Last a -> Ordering #(<) :: Last a -> Last a -> Bool #(<=) :: Last a -> Last a -> Bool #(>) :: Last a -> Last a -> Bool #(>=) :: Last a -> Last a -> Bool #max :: Last a -> Last a -> Last a #min :: Last a -> Last a -> Last a # Ord m => Ord (WrappedMonoid m) Methods(<) :: WrappedMonoid m -> WrappedMonoid m -> Bool #(<=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #(>) :: WrappedMonoid m -> WrappedMonoid m -> Bool #(>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m #min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m # Ord a => Ord (Option a) Methodscompare :: Option a -> Option a -> Ordering #(<) :: Option a -> Option a -> Bool #(<=) :: Option a -> Option a -> Bool #(>) :: Option a -> Option a -> Bool #(>=) :: Option a -> Option a -> Bool #max :: Option a -> Option a -> Option a #min :: Option a -> Option a -> Option a # Ord a => Ord (NonEmpty a) Methodscompare :: NonEmpty a -> NonEmpty a -> Ordering #(<) :: NonEmpty a -> NonEmpty a -> Bool #(<=) :: NonEmpty a -> NonEmpty a -> Bool #(>) :: NonEmpty a -> NonEmpty a -> Bool #(>=) :: NonEmpty a -> NonEmpty a -> Bool #max :: NonEmpty a -> NonEmpty a -> NonEmpty a #min :: NonEmpty a -> NonEmpty a -> NonEmpty a # Ord a => Ord (ZipList a) Methodscompare :: ZipList a -> ZipList a -> Ordering #(<) :: ZipList a -> ZipList a -> Bool #(<=) :: ZipList a -> ZipList a -> Bool #(>) :: ZipList a -> ZipList a -> Bool #(>=) :: ZipList a -> ZipList a -> Bool #max :: ZipList a -> ZipList a -> ZipList a #min :: ZipList a -> ZipList a -> ZipList a # Ord a => Ord (Dual a) Methodscompare :: Dual a -> Dual a -> Ordering #(<) :: Dual a -> Dual a -> Bool #(<=) :: Dual a -> Dual a -> Bool #(>) :: Dual a -> Dual a -> Bool #(>=) :: Dual a -> Dual a -> Bool #max :: Dual a -> Dual a -> Dual a #min :: Dual a -> Dual a -> Dual a # Ord a => Ord (Sum a) Methodscompare :: Sum a -> Sum a -> Ordering #(<) :: Sum a -> Sum a -> Bool #(<=) :: Sum a -> Sum a -> Bool #(>) :: Sum a -> Sum a -> Bool #(>=) :: Sum a -> Sum a -> Bool #max :: Sum a -> Sum a -> Sum a #min :: Sum a -> Sum a -> Sum a # Ord a => Ord (Product a) Methodscompare :: Product a -> Product a -> Ordering #(<) :: Product a -> Product a -> Bool #(<=) :: Product a -> Product a -> Bool #(>) :: Product a -> Product a -> Bool #(>=) :: Product a -> Product a -> Bool #max :: Product a -> Product a -> Product a #min :: Product a -> Product a -> Product a # Ord a => Ord (First a) Methodscompare :: First a -> First a -> Ordering #(<) :: First a -> First a -> Bool #(<=) :: First a -> First a -> Bool #(>) :: First a -> First a -> Bool #(>=) :: First a -> First a -> Bool #max :: First a -> First a -> First a #min :: First a -> First a -> First a # Ord a => Ord (Last a) Methodscompare :: Last a -> Last a -> Ordering #(<) :: Last a -> Last a -> Bool #(<=) :: Last a -> Last a -> Bool #(>) :: Last a -> Last a -> Bool #(>=) :: Last a -> Last a -> Bool #max :: Last a -> Last a -> Last a #min :: Last a -> Last a -> Last a # Ord a => Ord (Down a) Methodscompare :: Down a -> Down a -> Ordering #(<) :: Down a -> Down a -> Bool #(<=) :: Down a -> Down a -> Bool #(>) :: Down a -> Down a -> Bool #(>=) :: Down a -> Down a -> Bool #max :: Down a -> Down a -> Down a #min :: Down a -> Down a -> Down a # (Ord a, Ord b) => Ord (Either a b) Methodscompare :: Either a b -> Either a b -> Ordering #(<) :: Either a b -> Either a b -> Bool #(<=) :: Either a b -> Either a b -> Bool #(>) :: Either a b -> Either a b -> Bool #(>=) :: Either a b -> Either a b -> Bool #max :: Either a b -> Either a b -> Either a b #min :: Either a b -> Either a b -> Either a b # Ord (f p) => Ord (Rec1 f p) Methodscompare :: Rec1 f p -> Rec1 f p -> Ordering #(<) :: Rec1 f p -> Rec1 f p -> Bool #(<=) :: Rec1 f p -> Rec1 f p -> Bool #(>) :: Rec1 f p -> Rec1 f p -> Bool #(>=) :: Rec1 f p -> Rec1 f p -> Bool #max :: Rec1 f p -> Rec1 f p -> Rec1 f p #min :: Rec1 f p -> Rec1 f p -> Rec1 f p # Ord (URec Char p) Methodscompare :: URec Char p -> URec Char p -> Ordering #(<) :: URec Char p -> URec Char p -> Bool #(<=) :: URec Char p -> URec Char p -> Bool #(>) :: URec Char p -> URec Char p -> Bool #(>=) :: URec Char p -> URec Char p -> Bool #max :: URec Char p -> URec Char p -> URec Char p #min :: URec Char p -> URec Char p -> URec Char p # Methodscompare :: URec Double p -> URec Double p -> Ordering #(<) :: URec Double p -> URec Double p -> Bool #(<=) :: URec Double p -> URec Double p -> Bool #(>) :: URec Double p -> URec Double p -> Bool #(>=) :: URec Double p -> URec Double p -> Bool #max :: URec Double p -> URec Double p -> URec Double p #min :: URec Double p -> URec Double p -> URec Double p # Ord (URec Float p) Methodscompare :: URec Float p -> URec Float p -> Ordering #(<) :: URec Float p -> URec Float p -> Bool #(<=) :: URec Float p -> URec Float p -> Bool #(>) :: URec Float p -> URec Float p -> Bool #(>=) :: URec Float p -> URec Float p -> Bool #max :: URec Float p -> URec Float p -> URec Float p #min :: URec Float p -> URec Float p -> URec Float p # Ord (URec Int p) Methodscompare :: URec Int p -> URec Int p -> Ordering #(<) :: URec Int p -> URec Int p -> Bool #(<=) :: URec Int p -> URec Int p -> Bool #(>) :: URec Int p -> URec Int p -> Bool #(>=) :: URec Int p -> URec Int p -> Bool #max :: URec Int p -> URec Int p -> URec Int p #min :: URec Int p -> URec Int p -> URec Int p # Ord (URec Word p) Methodscompare :: URec Word p -> URec Word p -> Ordering #(<) :: URec Word p -> URec Word p -> Bool #(<=) :: URec Word p -> URec Word p -> Bool #(>) :: URec Word p -> URec Word p -> Bool #(>=) :: URec Word p -> URec Word p -> Bool #max :: URec Word p -> URec Word p -> URec Word p #min :: URec Word p -> URec Word p -> URec Word p # Ord (URec (Ptr ()) p) Methodscompare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering #(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p #min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p # (Ord a, Ord b) => Ord (a, b) Methodscompare :: (a, b) -> (a, b) -> Ordering #(<) :: (a, b) -> (a, b) -> Bool #(<=) :: (a, b) -> (a, b) -> Bool #(>) :: (a, b) -> (a, b) -> Bool #(>=) :: (a, b) -> (a, b) -> Bool #max :: (a, b) -> (a, b) -> (a, b) #min :: (a, b) -> (a, b) -> (a, b) # (Ix i, Ord e) => Ord (Array i e) Methodscompare :: Array i e -> Array i e -> Ordering #(<) :: Array i e -> Array i e -> Bool #(<=) :: Array i e -> Array i e -> Bool #(>) :: Array i e -> Array i e -> Bool #(>=) :: Array i e -> Array i e -> Bool #max :: Array i e -> Array i e -> Array i e #min :: Array i e -> Array i e -> Array i e # Ord a => Ord (Arg a b) Methodscompare :: Arg a b -> Arg a b -> Ordering #(<) :: Arg a b -> Arg a b -> Bool #(<=) :: Arg a b -> Arg a b -> Bool #(>) :: Arg a b -> Arg a b -> Bool #(>=) :: Arg a b -> Arg a b -> Bool #max :: Arg a b -> Arg a b -> Arg a b #min :: Arg a b -> Arg a b -> Arg a b # Ord (Proxy k s) Methodscompare :: Proxy k s -> Proxy k s -> Ordering #(<) :: Proxy k s -> Proxy k s -> Bool #(<=) :: Proxy k s -> Proxy k s -> Bool #(>) :: Proxy k s -> Proxy k s -> Bool #(>=) :: Proxy k s -> Proxy k s -> Bool #max :: Proxy k s -> Proxy k s -> Proxy k s #min :: Proxy k s -> Proxy k s -> Proxy k s # Ord c => Ord (K1 i c p) Methodscompare :: K1 i c p -> K1 i c p -> Ordering #(<) :: K1 i c p -> K1 i c p -> Bool #(<=) :: K1 i c p -> K1 i c p -> Bool #(>) :: K1 i c p -> K1 i c p -> Bool #(>=) :: K1 i c p -> K1 i c p -> Bool #max :: K1 i c p -> K1 i c p -> K1 i c p #min :: K1 i c p -> K1 i c p -> K1 i c p # (Ord (f p), Ord (g p)) => Ord ((:+:) f g p) Methodscompare :: (f :+: g) p -> (f :+: g) p -> Ordering #(<) :: (f :+: g) p -> (f :+: g) p -> Bool #(<=) :: (f :+: g) p -> (f :+: g) p -> Bool #(>) :: (f :+: g) p -> (f :+: g) p -> Bool #(>=) :: (f :+: g) p -> (f :+: g) p -> Bool #max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p #min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p # (Ord (f p), Ord (g p)) => Ord ((:*:) f g p) Methodscompare :: (f :*: g) p -> (f :*: g) p -> Ordering #(<) :: (f :*: g) p -> (f :*: g) p -> Bool #(<=) :: (f :*: g) p -> (f :*: g) p -> Bool #(>) :: (f :*: g) p -> (f :*: g) p -> Bool #(>=) :: (f :*: g) p -> (f :*: g) p -> Bool #max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p #min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p # Ord (f (g p)) => Ord ((:.:) f g p) Methodscompare :: (f :.: g) p -> (f :.: g) p -> Ordering #(<) :: (f :.: g) p -> (f :.: g) p -> Bool #(<=) :: (f :.: g) p -> (f :.: g) p -> Bool #(>) :: (f :.: g) p -> (f :.: g) p -> Bool #(>=) :: (f :.: g) p -> (f :.: g) p -> Bool #max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p #min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # (Ord a, Ord b, Ord c) => Ord (a, b, c) Methodscompare :: (a, b, c) -> (a, b, c) -> Ordering #(<) :: (a, b, c) -> (a, b, c) -> Bool #(<=) :: (a, b, c) -> (a, b, c) -> Bool #(>) :: (a, b, c) -> (a, b, c) -> Bool #(>=) :: (a, b, c) -> (a, b, c) -> Bool #max :: (a, b, c) -> (a, b, c) -> (a, b, c) #min :: (a, b, c) -> (a, b, c) -> (a, b, c) # Ord a => Ord (Const k a b) Methodscompare :: Const k a b -> Const k a b -> Ordering #(<) :: Const k a b -> Const k a b -> Bool #(<=) :: Const k a b -> Const k a b -> Bool #(>) :: Const k a b -> Const k a b -> Bool #(>=) :: Const k a b -> Const k a b -> Bool #max :: Const k a b -> Const k a b -> Const k a b #min :: Const k a b -> Const k a b -> Const k a b # Ord (f a) => Ord (Alt k f a) Methodscompare :: Alt k f a -> Alt k f a -> Ordering #(<) :: Alt k f a -> Alt k f a -> Bool #(<=) :: Alt k f a -> Alt k f a -> Bool #(>) :: Alt k f a -> Alt k f a -> Bool #(>=) :: Alt k f a -> Alt k f a -> Bool #max :: Alt k f a -> Alt k f a -> Alt k f a #min :: Alt k f a -> Alt k f a -> Alt k f a # Ord ((:~:) k a b) Methodscompare :: (k :~: a) b -> (k :~: a) b -> Ordering #(<) :: (k :~: a) b -> (k :~: a) b -> Bool #(<=) :: (k :~: a) b -> (k :~: a) b -> Bool #(>) :: (k :~: a) b -> (k :~: a) b -> Bool #(>=) :: (k :~: a) b -> (k :~: a) b -> Bool #max :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b #min :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b # (Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) Methodscompare :: ErrorT e m a -> ErrorT e m a -> Ordering #(<) :: ErrorT e m a -> ErrorT e m a -> Bool #(<=) :: ErrorT e m a -> ErrorT e m a -> Bool #(>) :: ErrorT e m a -> ErrorT e m a -> Bool #(>=) :: ErrorT e m a -> ErrorT e m a -> Bool #max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a #min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # Ord (f p) => Ord (M1 i c f p) Methodscompare :: M1 i c f p -> M1 i c f p -> Ordering #(<) :: M1 i c f p -> M1 i c f p -> Bool #(<=) :: M1 i c f p -> M1 i c f p -> Bool #(>) :: M1 i c f p -> M1 i c f p -> Bool #(>=) :: M1 i c f p -> M1 i c f p -> Bool #max :: M1 i c f p -> M1 i c f p -> M1 i c f p #min :: M1 i c f p -> M1 i c f p -> M1 i c f p # (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) Methodscompare :: (a, b, c, d) -> (a, b, c, d) -> Ordering #(<) :: (a, b, c, d) -> (a, b, c, d) -> Bool #(<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #(>) :: (a, b, c, d) -> (a, b, c, d) -> Bool #(>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) Methodscompare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering #(<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #(<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #(>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #(>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) Methodscompare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering #(<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #(<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #(>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #(>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) Methodscompare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering #(<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #(<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #(>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #(>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) Methodscompare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering #(<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #(<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #(>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #(>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) #min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) Methodscompare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) #min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) Methodscompare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) #min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) Methodscompare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) #min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) Methodscompare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) #min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) Methodscompare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) #min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Methodscompare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Methodscompare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering #(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool #max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

data NonEmpty a :: * -> * #

Non-empty (and non-strict) list type.

Since: 4.9.0.0

Constructors

 a :| [a] infixr 5

Instances