I wrote a Maybe (a lazy Option[T]) that I can use in Scala.

Scala Maybe

… because I wanted a lazy variant of Option[+T]. I had a use case in mind at the time, but, since then; I’ve taken another approach.

Since writing this, I’ve found an explanation of Monads that “groks” with me and multiple other places where “lazy is better” and I preffer (my) Maybe[T] over Option[T].

package peterlavalle

/**
	* like Option[+A] but lazy
	*/
trait Maybe[+T] {

	/**
		* however we're implemented; ensure that any operations leading up to now are only called "once"
		*/
	def cache: Maybe[T]

	/**
		* Apply some operation to the value, and, return a new monad.
		*
		* this is (more likely) lazy
		**/
	def call[V](operation: T => V): Maybe[V]

	/**
		* bind it like a monad ... but ... not lazy
		*/
	def bind[V](operation: T => Maybe[V]): Maybe[V]

	/**
		* if we're empty; produce the other one
		*/
	def otherwise[E >: T](them: => Maybe[E]): Maybe[E]

	/**
		* produce/convert this to an eager Option[T] in preparation for reading or matching it.
		*
		* This is (kind of) a hack
		*/
	def some: Option[T]

	final def |[V](that: T => Maybe[V]): Maybe[V] = bind(that)

	final def ![V](that: T => V): Maybe[V] = call(that)

	final def ?[E >: T](them: => Maybe[E]): Maybe[E] = otherwise(them)
}

object Maybe {

	def apply[T](read: => T): Maybe[T] =
		new Maybe[T] {
			override lazy final val cache: Maybe[T] = {
				lazy val data: T = read
				apply(data)
			}

			override lazy final val some: Option[T] = Some(read)

			override final def otherwise[E >: T](them: => Maybe[E]): Maybe[E] = this

			override final def bind[V](map: T => Maybe[V]): Maybe[V] =
				map(read)

			override final def call[V](map: T => V): Maybe[V] =
				Maybe {
					map(read)
				}
		}

	def unapply[T](arg: Maybe[T]): Option[T] = arg.some

	case object Nope extends Maybe[Nothing] {
		override final val cache: Maybe[Nothing] = this

		override final val some: Option[Nothing] = None

		override final def bind[V](map: Nothing => Maybe[V]): Maybe[V] = Nope

		override final def call[V](map: Nothing => V): Maybe[V] = Nope

		override final def otherwise[E >: Nothing](them: => Maybe[E]): Maybe[E] = them
	}
}