public A SumLeft(Semigroup <A> m) => tail.FoldLeft <A>(m.Op, head);
public Reducer <Q, B> XSelect <B>(Func <A, B> f, Func <B, A> g)
{
var t = this;
return(Semigroup.XSelect(f, g).Reducer <Q>(q => f(t.unit(q))));
}
public A SumRight(Semigroup <A> m) => tail.FoldRight <A>(m.Op, head);
public A SumLeft(Semigroup <A> m)
{
return(tail.FoldLeft <A>(m.Op, head));
}
public Reducer <Q, Pair <A, B> > Pair <B>(Reducer <Q, B> s)
{
var t = this;
return(Semigroup.Pair(s.Semigroup).Reducer <Q>(q => t.unit(q).And(s.unit(q))));
}
public Input <E> Append(Input <E> o, Semigroup <E> m)
{
return(m.Input.Op(this, o));
}
public PairAndSemigroup <A, B> Constrain(Semigroup <A> s)
{
return(new PairAndSemigroup <A, B>(this, s));
}
public A Apply(A a1, A a2)
{
return(Semigroup.Apply(a1, a2));
}
public Func <A, A> Curried1(A a1)
{
return(Semigroup.Curried1(a1));
}
public Monoid <B> XSelect <B>(Func <A, B> f, Func <B, A> g)
{
return(Semigroup.XSelect(f, g).Monoid(f(id)));
}
public PairAndSemigroup <A, B> Constrain(Semigroup <A> s) => new PairAndSemigroup <A, B>(this, s);
public Monoid <Func <B, C, D, A> > Pointwise3 <B, C, D>()
{
var t = this;
return(Semigroup.Pointwise3 <B, C, D>().Monoid((_, __, ___) => t.id));
}
public Monoid <Func <B, A> > Pointwise <B>()
{
var t = this;
return(Semigroup.Pointwise <B>().Monoid(_ => t.id));
}
public Monoid <Pair <A, B> > Pair <B>(Monoid <B> s)
{
return(Semigroup.Pair(s.Semigroup).Monoid(id.And(s.Id)));
}
public B SumMapRight <B>(Func <A, B> f, Semigroup <B> m) => tail.FoldRight <B>((a, b) => m.Op(f(a), b), f(head));
public Input <E> Append(Input <E> o, Semigroup <E> m) => m.Input.Op(this, o);
public B SumMapLeft <B>(Func <A, B> f, Semigroup <B> m) => tail.FoldLeft <B>((a, b) => m.Op(a, f(b)), f(head));
public A Apply(A a1, A a2) => Semigroup.Apply(a1, a2);
internal PairAndSemigroup(Pair <A, B> pair, Semigroup <A> s)
{
this.pair = pair;
this.s = s;
}
public Func <A, A> Curried1(A a1) => Semigroup.Curried1(a1);
public Semigroup <Pair <A, B> > Pair <B>(Semigroup <B> s)
{
var t = this;
return(new Semigroup <Pair <A, B> >((p1, p2) => t.op(p1._1.Get, p2._1.Get).And(s.op(p1._2.Get, p2._2.Get))));
}
public A SumRight(Semigroup <A> m)
{
return(tail.FoldRight <A>(m.Op, head));
}