An HBifunctor where it doesn't matter which binds first is Associative. Knowing this gives us a lot of power to rearrange the internals of our HFunctor at will.

For example, for the functor product:

data (f :*: g) a = f a :*: g a

We know that f :*: (g :*: h) is the same as (f :*: g) :*: h.

Reassociate an application of t.

Reassociate an application of t.

For some ts, you can represent the act of applying a functor f to t many times, as a single type. That is, there is some type SF t f that is equivalent to one of:

• f a -- 1 time
• t f f a -- 2 times
• t f (t f f) a -- 3 times
• t f (t f (t f f)) a -- 4 times
• t f (t f (t f (t f f))) a -- 5 times
• .. etc

This typeclass associates each t with its "induced semigroupoidal functor combinator" SF t.

This is useful because sometimes you might want to describe a type that can be t f f, t f (t f f), t f (t f (t f f)), etc.; "f applied to itself", with at least one f. This typeclass lets you use a type like NonEmptyF in terms of repeated applications of :*:, or Ap1 in terms of repeated applications of Day, or Free1 in terms of repeated applications of Comp, etc.

For example, f :*: f can be interpreted as "a free selection of two fs", allowing you to specify "I have to fs that I can use". If you want to specify "I want 1, 2, or many different fs that I can use", you can use NonEmptyF f.

At the high level, the main way to use a Semigroupoidal is with biretract and binterpret:

biretract :: t f f ~> f
binterpret :: (f ~> h) -> (g ~> h) -> t f g ~> h

which are like the HBifunctor versions of retract and interpret: they fully "mix" together the two inputs of t.

Also useful is:

toSF :: t f f a -> SF t f a

Which converts a t into its aggregate type SF.

In reality, most Semigroupoidal instances are also Monoidal instances, so you can think of the separation as mostly to help organize functionality. However, there are two non-monoidal semigroupoidal instances of note: LeftF and RightF, which are higher order analogues of the First and Last semigroups, roughly.

Convenient alias for the constraint required for biretract, binterpret, etc.

It's usually a constraint on the target/result context of interpretation that allows you to "exit" or "run" a Semigroupoidal t.

An SF t f represents the successive application of t to f, over and over again. So, that means that an SF t f must either be a single f, or an t f (SF t f).

matchingSF states that these two are isomorphic. Use matchSF and inject !*! consSF to convert between one and the other.

Useful wrapper over binterpret to allow you to directly extract a value b out of the t f a, if you can convert f x into b.

Note that depending on the constraints on the interpretation of t, you may have extra constraints on b.

• If C (SF t) is Unconstrained, there are no constraints on b
• If C (SF t) is Apply, b needs to be an instance of Semigroup
• If C (SF t) is Applicative, b needs to be an instance of Monoid

For some constraints (like Monad), this will not be usable.

-- Return the length of either the list, or the Map, depending on which
--   one s in the +
biget length length
    :: ([] :+: Map Int) Char
    -> Int

-- Return the length of both the list and the map, added together
biget (Sum . length) (Sum . length)
    :: Day [] (Map Int) Char
    -> Sum Int

Useful wrapper over biget to allow you to collect a b from all instances of f and g inside a t f g a.

This will work if C t is Unconstrained, Apply, or Applicative.

Infix alias for binterpret

Infix alias for biget

-- Return the length of either the list, or the Map, depending on which
--   one s in the +
length !$! length
    :: ([] :+: Map Int) Char
    -> Int

-- Return the length of both the list and the map, added together
Sum . length !$! Sum . length
    :: Day [] (Map Int) Char
    -> Sum Int