Most people do not know how to gift flowers. Fewer still know how to receive them. Men usually perceive it a something that women like. And most women don't like flowers actually or have a reason for loving them but they blindly follow mimetic activity of how romance was introduced to them and how they define themselves as receivers of it. I love flowers differently. For me, to give a flower is to acknowledge finitude. I believe that roses, or any kind of plant, is a lovely symbol of life, and maybe of death too. It lives, it decays, and in that decay it reveals what all presence truly is, something already in the process of leaving.

When I give someone a flower, I offer my presence in the same way; alive, fragile, and implicitly dying. Not as tragedy, but as truth. Life happens precisely because it does not last.

And life happens. Sometimes the symbol dies, sometimes the connection renews itself and another living thing appears between us (let that be you getting something else alive from me, like another rose), and this state of continuous maintainability of a relationship between two, is symbolized, to me, in the process of gifting, taking care, and reestablishing something that is alive.

To gift a flower, to care for it, to replace it when it die, this is how I run feelings towards anyone, or anything at all, sustained attention to something alive. #Modus Vivendi

A question that I had while reading Scala specs, is that why do we need Some at all? When we return an option of T, we are usually returning Some(T) or Nothing. But why not T or Nothing directly? I didn't see anything that makes Some make sense to me so far, other than it add an absence notation context (this is to say, that Some(T) means T in the context of the possibility of absence of T).

The reason that I found so far is that there is no runtime discriminator, which is basically a JVM limitation;

A runtime discriminator is data that tells you which alternative you have. Option looks like this:

sealed trait Option[+A]
case class Some[A](value: A) extends Option[A]
case object None extends Option[Nothing]

At runtime, an Option[A] value is either:

• an instance of Some, or
• the singleton object None

That class identity is the discriminator.

Pattern matching works because the JVM can ask:

isInstanceOf[Some[_]] ?
isInstanceOf[None.type] ?

Now remove Some and None

def findT(id: Int): T | Nothing

The issue here is that there is no value of type Nothing. It's compile-time only. I would even imagine that the type erasure in the JVM makes all the following equivalent:

User
User | Nothing
Option[User]

#Scala