Data.PartialSemigroup.Generics

If a type derives Generic and all of its fields have PartialSemigroup instances, you can get a PartialSemigroup for free using genericPartialSemigroupOp.

Example

For this demonstration we'll define a contrived example type T with two constructors, A and B.

>>> data T = A String (Either String String) | B String deriving (Generic, Show)

And then define its PartialSemigroup instance using genericPartialSemigroupOp.

>>> instance PartialSemigroup T where (<>?) = genericPartialSemigroupOp

This gives us an implementation of <>? which combines values only if they have the same structure.

>>> A "s" (Left "x") <>? A "t" (Left "y")
Just (A "st" (Left "xy"))

>>> B "x" <>? B "y"
Just (B "xy")

For values that do not have the same structure, <>? produces Nothing.

>>> A "s" (Left "x") <>? A "t" (Right "y")
Nothing

>>> A "x" (Left "y") <>? B "z"
Nothing

The generic PartialSemigroup operator

genericPartialSemigroupOp :: (Generic a, PartialSemigroupRep (Rep a)) => a -> a -> Maybe a

Implementation details

class PartialSemigroupRep rep where

The class of generic type Reps for which we can automatically derive PartialSemigroup:

• K1 - a single value
• M1 - a value with some additional metadata (which we simply discard)
• :+: - sum types
• :*: - product types

Minimal complete definition

repPartialSemigroupOp

Methods

repPartialSemigroupOp :: rep a -> rep a -> Maybe (rep a)

Instances

PartialSemigroup a => PartialSemigroupRep (K1 i a)

Methods

repPartialSemigroupOp :: K1 i a a -> K1 i a a -> Maybe (K1 i a a)

(PartialSemigroupRep rep1, PartialSemigroupRep rep2) => PartialSemigroupRep ((:+:) rep1 rep2)

Methods

repPartialSemigroupOp :: (rep1 :+: rep2) a -> (rep1 :+: rep2) a -> Maybe ((rep1 :+: rep2) a)

(PartialSemigroupRep rep1, PartialSemigroupRep rep2) => PartialSemigroupRep ((:*:) rep1 rep2)

Methods

repPartialSemigroupOp :: (rep1 :*: rep2) a -> (rep1 :*: rep2) a -> Maybe ((rep1 :*: rep2) a)

PartialSemigroupRep rep => PartialSemigroupRep (M1 i meta rep)

Methods

repPartialSemigroupOp :: M1 i meta rep a -> M1 i meta rep a -> Maybe (M1 i meta rep a)

Re-exports

class Generic a

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from, to

Instances

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Generic Ordering

Associated Types

type Rep Ordering :: * -> *

Methods

from :: Ordering -> Rep Ordering x

to :: Rep Ordering x -> Ordering

Generic ()

Associated Types

type Rep () :: * -> *

Methods

from :: () -> Rep () x

to :: Rep () x -> ()

Generic Void

Associated Types

type Rep Void :: * -> *

Methods

from :: Void -> Rep Void x

to :: Rep Void x -> Void

Generic Version

Associated Types

type Rep Version :: * -> *

Methods

from :: Version -> Rep Version x

to :: Rep Version x -> Version

Generic ExitCode

Associated Types

type Rep ExitCode :: * -> *

Methods

from :: ExitCode -> Rep ExitCode x

to :: Rep ExitCode x -> ExitCode

Generic All

Associated Types

type Rep All :: * -> *

Methods

from :: All -> Rep All x

to :: Rep All x -> All

Generic Any

Associated Types

type Rep Any :: * -> *

Methods

from :: Any -> Rep Any x

to :: Rep Any x -> Any

Generic Fixity

Associated Types

type Rep Fixity :: * -> *

Methods

from :: Fixity -> Rep Fixity x

to :: Rep Fixity x -> Fixity

Generic Associativity

Associated Types

type Rep Associativity :: * -> *

Methods

from :: Associativity -> Rep Associativity x

to :: Rep Associativity x -> Associativity

Generic SourceUnpackedness

Associated Types

type Rep SourceUnpackedness :: * -> *

Methods

from :: SourceUnpackedness -> Rep SourceUnpackedness x

to :: Rep SourceUnpackedness x -> SourceUnpackedness

Generic SourceStrictness

Associated Types

type Rep SourceStrictness :: * -> *

Methods

from :: SourceStrictness -> Rep SourceStrictness x

to :: Rep SourceStrictness x -> SourceStrictness

Generic DecidedStrictness

Associated Types

type Rep DecidedStrictness :: * -> *

Methods

from :: DecidedStrictness -> Rep DecidedStrictness x

to :: Rep DecidedStrictness x -> DecidedStrictness

Generic [a]

Associated Types

type Rep [a] :: * -> *

Methods

from :: [a] -> Rep [a] x

to :: Rep [a] x -> [a]

Generic (Maybe a)

Associated Types

type Rep (Maybe a) :: * -> *

Methods

from :: Maybe a -> Rep (Maybe a) x

to :: Rep (Maybe a) x -> Maybe a

Generic (V1 p)

Associated Types

type Rep (V1 p) :: * -> *

Methods

from :: V1 p -> Rep (V1 p) x

to :: Rep (V1 p) x -> V1 p

Generic (U1 p)

Associated Types

type Rep (U1 p) :: * -> *

Methods

from :: U1 p -> Rep (U1 p) x

to :: Rep (U1 p) x -> U1 p

Generic (Par1 p)

Associated Types

type Rep (Par1 p) :: * -> *

Methods

from :: Par1 p -> Rep (Par1 p) x

to :: Rep (Par1 p) x -> Par1 p

Generic (Identity a)

Associated Types

type Rep (Identity a) :: * -> *

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Generic (Min a)

Associated Types

type Rep (Min a) :: * -> *

Methods

from :: Min a -> Rep (Min a) x

to :: Rep (Min a) x -> Min a

Generic (Max a)

Associated Types

type Rep (Max a) :: * -> *

Methods

from :: Max a -> Rep (Max a) x

to :: Rep (Max a) x -> Max a

Generic (First a)

Associated Types

type Rep (First a) :: * -> *

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Associated Types

type Rep (Last a) :: * -> *

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (WrappedMonoid m)

Associated Types

type Rep (WrappedMonoid m) :: * -> *

Methods

from :: WrappedMonoid m -> Rep (WrappedMonoid m) x

to :: Rep (WrappedMonoid m) x -> WrappedMonoid m

Generic (Option a)

Associated Types

type Rep (Option a) :: * -> *

Methods

from :: Option a -> Rep (Option a) x

to :: Rep (Option a) x -> Option a

Generic (NonEmpty a)

Associated Types

type Rep (NonEmpty a) :: * -> *

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x

to :: Rep (NonEmpty a) x -> NonEmpty a

Generic (ZipList a)

Associated Types

type Rep (ZipList a) :: * -> *

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

Generic (Dual a)

Associated Types

type Rep (Dual a) :: * -> *

Methods

from :: Dual a -> Rep (Dual a) x

to :: Rep (Dual a) x -> Dual a

Generic (Endo a)

Associated Types

type Rep (Endo a) :: * -> *

Methods

from :: Endo a -> Rep (Endo a) x

to :: Rep (Endo a) x -> Endo a

Generic (Sum a)

Associated Types

type Rep (Sum a) :: * -> *

Methods

from :: Sum a -> Rep (Sum a) x

to :: Rep (Sum a) x -> Sum a

Generic (Product a)

Associated Types

type Rep (Product a) :: * -> *

Methods

from :: Product a -> Rep (Product a) x

to :: Rep (Product a) x -> Product a

Generic (First a)

Associated Types

type Rep (First a) :: * -> *

Methods

from :: First a -> Rep (First a) x

to :: Rep (First a) x -> First a

Generic (Last a)

Associated Types

type Rep (Last a) :: * -> *

Methods

from :: Last a -> Rep (Last a) x

to :: Rep (Last a) x -> Last a

Generic (Either a b)

Associated Types

type Rep (Either a b) :: * -> *

Methods

from :: Either a b -> Rep (Either a b) x

to :: Rep (Either a b) x -> Either a b

Generic (Rec1 f p)

Associated Types

type Rep (Rec1 f p) :: * -> *

Methods

from :: Rec1 f p -> Rep (Rec1 f p) x

to :: Rep (Rec1 f p) x -> Rec1 f p

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

Generic (URec Word p)

Associated Types

type Rep (URec Word p) :: * -> *

Methods

from :: URec Word p -> Rep (URec Word p) x

to :: Rep (URec Word p) x -> URec Word p

Generic (URec (Ptr ()) p)

Associated Types

type Rep (URec (Ptr ()) p) :: * -> *

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

Generic (a, b)

Associated Types

type Rep (a, b) :: * -> *

Methods

from :: (a, b) -> Rep (a, b) x

to :: Rep (a, b) x -> (a, b)

Generic (Arg a b)

Associated Types

type Rep (Arg a b) :: * -> *

Methods

from :: Arg a b -> Rep (Arg a b) x

to :: Rep (Arg a b) x -> Arg a b

Generic (WrappedMonad m a)

Associated Types

type Rep (WrappedMonad m a) :: * -> *

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a

Generic (Proxy k t)

Associated Types

type Rep (Proxy k t) :: * -> *

Methods

from :: Proxy k t -> Rep (Proxy k t) x

to :: Rep (Proxy k t) x -> Proxy k t

Generic (K1 i c p)

Associated Types

type Rep (K1 i c p) :: * -> *

Methods

from :: K1 i c p -> Rep (K1 i c p) x

to :: Rep (K1 i c p) x -> K1 i c p

Generic ((:+:) f g p)

Associated Types

type Rep ((:+:) f g p) :: * -> *

Methods

from :: (f :+: g) p -> Rep ((f :+: g) p) x

to :: Rep ((f :+: g) p) x -> (f :+: g) p

Generic ((:*:) f g p)

Associated Types

type Rep ((:*:) f g p) :: * -> *

Methods

from :: (f :*: g) p -> Rep ((f :*: g) p) x

to :: Rep ((f :*: g) p) x -> (f :*: g) p

Generic ((:.:) f g p)

Associated Types

type Rep ((:.:) f g p) :: * -> *

Methods

from :: (f :.: g) p -> Rep ((f :.: g) p) x

to :: Rep ((f :.: g) p) x -> (f :.: g) p

Generic (a, b, c)

Associated Types

type Rep (a, b, c) :: * -> *

Methods

from :: (a, b, c) -> Rep (a, b, c) x

to :: Rep (a, b, c) x -> (a, b, c)

Generic (WrappedArrow a b c)

Associated Types

type Rep (WrappedArrow a b c) :: * -> *

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

Generic (Const k a b)

Associated Types

type Rep (Const k a b) :: * -> *

Methods

from :: Const k a b -> Rep (Const k a b) x

to :: Rep (Const k a b) x -> Const k a b

Generic (Alt k f a)

Associated Types

type Rep (Alt k f a) :: * -> *

Methods

from :: Alt k f a -> Rep (Alt k f a) x

to :: Rep (Alt k f a) x -> Alt k f a

Generic (M1 i c f p)

Associated Types

type Rep (M1 i c f p) :: * -> *

Methods

from :: M1 i c f p -> Rep (M1 i c f p) x

to :: Rep (M1 i c f p) x -> M1 i c f p

Generic (a, b, c, d)

Associated Types

type Rep (a, b, c, d) :: * -> *

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x

to :: Rep (a, b, c, d) x -> (a, b, c, d)

Generic (a, b, c, d, e)

Associated Types

type Rep (a, b, c, d, e) :: * -> *

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e)

Generic (a, b, c, d, e, f)

Associated Types

type Rep (a, b, c, d, e, f) :: * -> *

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f)

Generic (a, b, c, d, e, f, g)

Associated Types

type Rep (a, b, c, d, e, f, g) :: * -> *

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g)

class PartialSemigroup a where

A PartialSemigroup is like a Semigroup, but with an operator returning Maybe a rather than a.

For comparison:

(<>)  :: Semigroup a        => a -> a -> a
(<>?) :: PartialSemigroup a => a -> a -> Maybe a

The associativity axiom for partial semigroups

For all x, y, z:

• If x <>? y = Just xy and y <>? z = Just yz, then

  • x <>? yz = xy <>? z.

Relationship to the semigroup associativity axiom

The partial semigroup associativity axiom is a natural adaptation of the semigroup associativity axiom

x <> (y <> z) = (x <> y) <> z

with a slight modification to accommodate situations where <> is undefined. We may gain some insight into the connection between Semigroup and PartialSemigroup by rephrasing the partial semigroup associativity in terms of a partial <> operator thusly:

For all x, y, z:

• If x <> y and y <> z are both defined, then

  • x <> (y <> z) is defined if and only if (x <> y) <> z is defined, and
  • if these things are all defined, then the axiom for total semigroups x <> (y <> z) = (x <> y) <> z must hold.

Minimal complete definition

(<>?)

Methods

(<>?) :: a -> a -> Maybe a infixr 6

Instances

PartialSemigroup ()

Methods

(<>?) :: () -> () -> Maybe ()

PartialSemigroup [a]

Methods

(<>?) :: [a] -> [a] -> Maybe [a]

PartialSemigroup a => PartialSemigroup (Identity a)

Methods

(<>?) :: Identity a -> Identity a -> Maybe (Identity a)

PartialSemigroup a => PartialSemigroup (ZipList a)

partialZip

Methods

(<>?) :: ZipList a -> ZipList a -> Maybe (ZipList a)

Num a => PartialSemigroup (Sum a)

Methods

(<>?) :: Sum a -> Sum a -> Maybe (Sum a)

Num a => PartialSemigroup (Product a)

Methods

(<>?) :: Product a -> Product a -> Maybe (Product a)

Semigroup a => PartialSemigroup (Total a)

Methods

(<>?) :: Total a -> Total a -> Maybe (Total a)

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

Methods

(<>?) :: Either a b -> Either a b -> Maybe (Either a b)

(PartialSemigroup a, PartialSemigroup b) => PartialSemigroup (a, b)

Methods

(<>?) :: (a, b) -> (a, b) -> Maybe (a, b)

PartialSemigroup b => PartialSemigroup (AppendRight a b)

Methods

(<>?) :: AppendRight a b -> AppendRight a b -> Maybe (AppendRight a b)

PartialSemigroup a => PartialSemigroup (AppendLeft a b)

Methods

(<>?) :: AppendLeft a b -> AppendLeft a b -> Maybe (AppendLeft a b)

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

Methods

(<>?) :: (a, b, c) -> (a, b, c) -> Maybe (a, b, c)