Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

class LeftGCDMonoid m => LeftDistributiveGCDMonoid m

monoid-subclasses Data.Monoid.GCD

Class of left GCD monoids with left-distributivity. In addition to the general LeftGCDMonoid laws, instances of this class must also satisfy the following law:
```
commonPrefix (a <> b) (a <> c) == a <> commonPrefix b c
```

class (Monoid m, LeftReductive m) => LeftGCDMonoid m

monoid-subclasses	Data.Monoid.GCD

Class of monoids capable of finding the equivalent of greatest common divisor on the left side of two monoidal values. The following laws must be respected:

stripCommonPrefix a b == (p, a', b')
where p = commonPrefix a b
Just a' = stripPrefix p a
Just b' = stripPrefix p b
p == commonPrefix a b && p <> a' == a && p <> b' == b
where (p, a', b') = stripCommonPrefix a b

Furthermore, commonPrefix must return the unique greatest common prefix that contains, as its prefix, any other prefix x of both values:

not (x `isPrefixOf` a && x `isPrefixOf` b) || x `isPrefixOf` commonPrefix a b

and it cannot itself be a suffix of any other common prefix y of both values:

not (y `isPrefixOf` a && y `isPrefixOf` b && commonPrefix a b `isSuffixOf` y)

In addition, the commonPrefix operation must satisfy the following properties: Idempotence

commonPrefix a a == a

Identity

commonPrefix mempty a == mempty

commonPrefix a mempty == mempty

Commutativity

commonPrefix a b == commonPrefix b a

Associativity

commonPrefix (commonPrefix a b) c
==
commonPrefix a (commonPrefix b c)

class (Monoid m, LeftReductive m, RightReductive m) => OverlappingGCDMonoid m

monoid-subclasses Data.Monoid.GCD

Class of monoids for which the greatest overlap can be found between any two values, such that
```
a == a' <> overlap a b
b == overlap a b <> b'
```
The methods must satisfy the following laws:
```
stripOverlap a b == (stripSuffixOverlap b a, overlap a b, stripPrefixOverlap a b)
stripSuffixOverlap b a <> overlap a b == a
overlap a b <> stripPrefixOverlap a b == b
```
The result of overlap a b must be the largest prefix of b and suffix of a, in the sense that it contains any other value x that satifies the property (x isPrefixOf b) && (x isSuffixOf a):
```
∀x. (x `isPrefixOf` b && x `isSuffixOf` a) => (x `isPrefixOf` overlap a b && x `isSuffixOf` overlap a b)
```
and it must be unique so there's no other value y that satisfies the same properties for every such x:
```
∀y. ((∀x. (x `isPrefixOf` b && x `isSuffixOf` a) => x `isPrefixOf` y && x `isSuffixOf` y) => y == overlap a b)
```
In addition, the overlap operation must satisfy the following properties: Idempotence
```
overlap a a == a
```
Identity
```
overlap mempty a == mempty
```
```
overlap a mempty == mempty
```
class RightGCDMonoid m => RightDistributiveGCDMonoid m

monoid-subclasses Data.Monoid.GCD

Class of right GCD monoids with right-distributivity. In addition to the general RightGCDMonoid laws, instances of this class must also satisfy the following law:
```
commonSuffix (a <> c) (b <> c) == commonSuffix a b <> c
```

class (Monoid m, RightReductive m) => RightGCDMonoid m

monoid-subclasses	Data.Monoid.GCD

Class of monoids capable of finding the equivalent of greatest common divisor on the right side of two monoidal values. The following laws must be respected:

stripCommonSuffix a b == (a', b', s)
where s = commonSuffix a b
Just a' = stripSuffix p a
Just b' = stripSuffix p b
s == commonSuffix a b && a' <> s == a && b' <> s == b
where (a', b', s) = stripCommonSuffix a b

Furthermore, commonSuffix must return the unique greatest common suffix that contains, as its suffix, any other suffix x of both values:

not (x `isSuffixOf` a && x `isSuffixOf` b) || x `isSuffixOf` commonSuffix a b

and it cannot itself be a prefix of any other common suffix y of both values:

not (y `isSuffixOf` a && y `isSuffixOf` b && commonSuffix a b `isPrefixOf` y)

In addition, the commonSuffix operation must satisfy the following properties: Idempotence

commonSuffix a a == a

Identity

commonSuffix mempty a == mempty

commonSuffix a mempty == mempty

Commutativity

commonSuffix a b == commonSuffix b a

Associativity

commonSuffix (commonSuffix a b) c
==
commonSuffix a (commonSuffix b c)

class (DistributiveGCDMonoid m, LCMMonoid m) => DistributiveLCMMonoid m

monoid-subclasses Data.Monoid.LCM

Class of commutative LCM monoids with distributivity. In addition to the general LCMMonoid laws, instances of this class must also satisfy the following laws: The lcm operation itself must be both left-distributive and right-distributive:
```
lcm (a <> b) (a <> c) == a <> lcm b c
```
```
lcm (a <> c) (b <> c) == lcm a b <> c
```
The lcm and gcd operations must distribute over one another:
```
lcm a (gcd b c) == gcd (lcm a b) (lcm a c)
```
```
gcd a (lcm b c) == lcm (gcd a b) (gcd a c)
```

class GCDMonoid m => LCMMonoid m

monoid-subclasses	Data.Monoid.LCM

Class of Abelian monoids that allow the least common multiple to be found for any two given values. Operations must satisfy the following laws: Reductivity

isJust (lcm a b </> a)

isJust (lcm a b </> b)

Uniqueness

all isJust
[       c </> a
,       c </> b
, lcm a b </> c
]
==>
(lcm a b == c)

Idempotence

lcm a a == a

Identity

lcm mempty a == a

lcm a mempty == a

Commutativity

lcm a b == lcm b a

Associativity

lcm (lcm a b) c == lcm a (lcm b c)

Absorption

lcm a (gcd a b) == a

gcd a (lcm a b) == a

class (Monoid m, LeftReductive m, RightReductive m) => OverlappingGCDMonoid m

monoid-subclasses Data.Monoid.Monus

Class of monoids for which the greatest overlap can be found between any two values, such that
```
a == a' <> overlap a b
b == overlap a b <> b'
```
The methods must satisfy the following laws:
```
stripOverlap a b == (stripSuffixOverlap b a, overlap a b, stripPrefixOverlap a b)
stripSuffixOverlap b a <> overlap a b == a
overlap a b <> stripPrefixOverlap a b == b
```
The result of overlap a b must be the largest prefix of b and suffix of a, in the sense that it contains any other value x that satifies the property (x isPrefixOf b) && (x isSuffixOf a):
```
∀x. (x `isPrefixOf` b && x `isSuffixOf` a) => (x `isPrefixOf` overlap a b && x `isSuffixOf` overlap a b)
```
and it must be unique so there's no other value y that satisfies the same properties for every such x:
```
∀y. ((∀x. (x `isPrefixOf` b && x `isSuffixOf` a) => x `isPrefixOf` y && x `isSuffixOf` y) => y == overlap a b)
```
In addition, the overlap operation must satisfy the following properties: Idempotence
```
overlap a a == a
```
Identity
```
overlap mempty a == mempty
```
```
overlap a mempty == mempty
```
class MonoidNull m => PositiveMonoid m

monoid-subclasses Data.Monoid.Null

Subclass of Monoid for types whose values have no inverse, with the exception of mempty. More formally, the class instances must satisfy the following law:
```
null (x <> y) == (null x && null y)
```

monoid-subclasses	Data.Monoid.Monus

monoid-subclasses	Data.Monoid.Null

class (IsString t, LeftReductive t, LeftGCDMonoid t, FactorialMonoid t) => TextualMonoid t

monoid-subclasses	Data.Monoid.Textual

The TextualMonoid class is an extension of FactorialMonoid specialized for monoids that can contain characters. Its methods are generally equivalent to their namesake functions from Data.List and Data.Text, and they satisfy the following laws:

unfoldr splitCharacterPrefix . fromString == id
splitCharacterPrefix . primePrefix == fmap (\(c, t)-> (c, mempty)) . splitCharacterPrefix

map f . fromString == fromString . List.map f
concatMap (fromString . f) . fromString == fromString . List.concatMap f

foldl  ft fc a . fromString == List.foldl  fc a
foldr  ft fc a . fromString == List.foldr  fc a
foldl' ft fc a . fromString == List.foldl' fc a

scanl f c . fromString == fromString . List.scanl f c
scanr f c . fromString == fromString . List.scanr f c
mapAccumL f a . fromString == fmap fromString . List.mapAccumL f a
mapAccumL f a . fromString == fmap fromString . List.mapAccumL f a

takeWhile pt pc . fromString == fromString . takeWhile pc
dropWhile pt pc . fromString == fromString . dropWhile pc

mconcat . intersperse (singleton c) . split (== c) == id
find p . fromString == List.find p
elem c . fromString == List.elem c

A TextualMonoid may contain non-character data insterspersed between its characters. Every class method that returns a modified TextualMonoid instance generally preserves this non-character data. Methods like foldr can access both the non-character and character data and expect two arguments for the two purposes. For each of these methods there is also a simplified version with underscore in name (like foldr_) that ignores the non-character data. All of the following expressions are identities:

map id
concatMap singleton
foldl  (<>) (\a c-> a <> singleton c) mempty
foldr  (<>) ((<>) . singleton) mempty
foldl' (<>) (\a c-> a <> singleton c) mempty
scanl1 (const id)
scanr1 const
uncurry (mapAccumL (,))
uncurry (mapAccumR (,))
takeWhile (const True) (const True)
dropWhile (const False) (const False)
toString undefined . fromString
toText undefined . fromText

Page 23 of many | Previous | Next