foldMap says having a foldable A, a mapping function from A to B and B
is monoid it will fold F[A] into B.

foldRight says having a foldable A, initial value z of type B, and a mapping
function from (A, B) combination to B, it will fold fa int B.
By providing implementations for those two methods we’ll get following
operations on foldable for free.

foldMap. As already mentioned having B be a monoid and a mapping from
A to B it will fold into B. Here are some examples:

List(1, 2, 3).foldMap() = 6 (which is same as
List(1, 2, 3).foldMap((a: Int) ⇒ a) since identity is the default
value for mapping function). Not that here Monoid for integer is used on
zero and plus options so we get back the sum by doing foldMap.
Another example with int to string mapping:

List(1, 2, 3).foldMap((a: Int) ⇒ a.toString) = "123",
and here monoid for string is used and we get back a concatenated string.

nil[Int].foldMap() = 0 since B is monoid (int in this instance)
when foldable is empty it will fold it into zero.

foldMap1Opt. Where foldMap requires B to be monoid, foldMap1Opt
releives it a bit by requiring B to be a semigroup instead of monid (meaning
it doesn’t have zero) and returnign Option[B]. Examples:

List(1, 2, 3).foldMap1Opt() = Some(6) here we get the sum back since
the plus is the append operator of int semigroup we imported.

nil[Int].foldMap1Opt() = None. Here we get None since your List is
empty.

foldRight. As already mentioned is one of the abstract methods that need
to be implemented. Let’s look at it for list of integeres.
List(1, 2, 3, 4).foldRight(1)(_ * _) = 24 here we’re getting product
back as I defined my inital value 1 and my mapping function is product(
of course there is an easier way to do this in scalaz, which I’ll conver when
I get to Traverse but this will do good for the demo.)

foldMapRight1Opt. Similar to foldRight but instead of providing
starting value we provide a function that returns starting value. But here if
it’s empty, starting value won’t be there, so it returns optional. Examples:

List(1, 2, 3).foldMapRight1Opt(a ⇒ a + 1)(_ + _) = Some(7)

nil[Int].foldMapRight1Opt(a ⇒ a + 1)(_ + _) = None

foldRight1Opt is similar to foldMapRight1Opt but intead of taking a
function for starting value it defaults to identity function.

List(1, 2, 3).foldRight1Opt(_ + _) = Some(6)

nil[Int].foldRight1Opt(_ + _) = None

foldLeft. Nothing fancy here just a regular fold left. Instard of folding
from right it folds from left.
List(1, 2, 3).foldLeft(0)(_ - _) = -6 where fold right will give 2.

foldMapLeft1Opt and foldLeft1Opt. Similar to their right version
except it’s fold left.