Trying to say " x gets bound to" is setting you up for failure. Let me explain, and guide you towards a better way of expressing yourself when talking about these sorts of things.

Suppose we have:

someList.flatMap(x => some_expression)

If we know that someList has type List[Int] , then we can safely say that inside of some_expression, x is bound to a value of type Int . Notice the caveat, "inside of some_expression". This is because, given someList = List(1,2,3) , x will take on the values of each of them: 1 , 2 , and 3 , in turn.

Consider a more generalized example:

someMonadicValue.flatMap(x => some_expression)

If we know nothing about someMonadicValue , then we don't know much about how some_expression is going to be invoked. It may be run once, or three times (as in the above example), or lazily, or asynchronously, or it may be scheduled for once someMonadicValue is finished (e.g. futures), or it may never be used (e.g. empty list, None). The Monad interface does not include reasoning about when or how someExpression will be used. So all you can say about what x will be is confined to the context of some_expression , whenever and however some_expression happens to be evaluated.

So back to the example.

someMonadicValue.flatMap(x => some_expression)

You are trying to say " x is the ??? of someMonadicValue ." And you are looking for the word that accurately replaces ???. Well I'm here to tell you that you're doing it wrong. If you want to speak about x , then either do it

Within the context of some_expression . In this case, use the bolded phrase I gave you above: "inside of some_expression, x is bound to a value of type Foo ." Or, alternatively, you can speak about x ... With additional knowledge about which monad you're dealing with.

In case #2, for example, for someList.flatMap(x => some_expression) , you could say that " x is each element of someList ." For someFuture.flatMap(x => some_expression) , you could say that " x is the successful future value of someFuture , if it indeed ever completes and succeeds."

You see, that's the beauty of Monads. That ??? that you are trying to describe, is the thing which the Monad interface abstracts over. Now do you see why it's so difficult to give ??? a name? It's because it has a different name and a different meaning for each particular monad. And that's the point of having the Monad abstraction: to unify these differing concepts under the same computational interface.