I try to hold down on the number of forward references to SRFIs that don't yet exist, especially ones for which there isn't even a complete pre-SRFI spec.  But yes, I do expect to have a spec for monads, idioms (applicative functors) and functors.

On Thu, Jun 4, 2020 at 4:20 AM Shiro Kawai <xxxxxx@gmail.com> wrote:
If we'll have more monadic data types, I agree that consistent protool is a good thing.  Clarifying paragraph would be great so that the user will see what's coming.

On Wed, Jun 3, 2020 at 9:52 PM Marc Nieper-Wißkirchen <xxxxxx@nieper-wisskirchen.de> wrote:
Am Do., 4. Juni 2020 um 06:22 Uhr schrieb Shiro Kawai <xxxxxx@gmail.com>:
> Sorry for commenting in the last minute---I just started implementing it and finally took a closer look.
> I thought maybe-map would map proc to every value contained in maybe but realized it's more like the sense of fmap in Haskell Functor, correct?
> I do see the consistency, but I'm not sure the value of providing *-for-each, *-fold and *-unfold full-set of sequence protocol, as they are trivially implemented.   How much do we expect that Maybe and Either being used as a 0-or-1 length sequence?
> My concern is that *-map family has been used for n-length sequences, and our Maybe/Either has multiple values, it can be easily confused users expecting  srfi-189 *-map etc. are for mapping operations on each value it contains.

As we want that SRFI 189 will fit into a general monadic framework (I
guess that we will see more monads while R7RS-large takes shape), I am
very much in favor of leaving these procedures in SRFI 189, although
they are almost trivial for this type of monad.

I agree, though, that it may make sense to add a clarifying paragraph
at the beginning concerning multiple values, which makes it clear that
"multiple values" (which is not a first-class citizen in Scheme; but
see SRFI 195 for a reification) are abstractly not a sequence of
single values.  In Scheme, we do not have type signatures, which makes
some explanations wordier and harder to understand.  If we had
Haskell-like types, there would be a type `a' for each shape of
multiple values (in Scheme, the shape of a multiple value is
completely determined by the number of values; but see the Kernel
programming language, which allows trees if I remember correctly).

So, we have, for example, a Maybe type `Maybe a', which either stores
a "value" of shape/type `a' or a Nothing. If  `*' is the type
corresponding to a single value and `[*]' the type of lists of length
`a', `Maybe a' is not the same as `Maybe [*]'. As `a' is an abstract
type on this level, it simply does not make sense for the sequence
operations to traverse whatever may be stored in `a', so no confusion
can arise.