Emulating the Maybe monad in Ceylon

MaybeMonad.ceylon

/*
  Demonstrates how to do monadic-style processing of
  optional values in Ceylon. Represents an optional
  type by boxing non-null values as singletons, and
  the null value as the empty sequence. Monadic
  operations are inherited from the stream interface,
  with the caveat that m.flatMap(f) must be written 
  as m.flatMap(lift(f)) or as m.map(f).coalesced.
  
  For the record: this is not idiomatic Ceylon. In
  Ceylon, optional values are represented in a more
  efficient unboxed form using a union type of form
  T|Null.
*/

"The type of boxed optional values."
alias Maybe<X> 
        given X satisfies Object 
        => [X]|[];

"A function to box an optional value.
 (Just an alias for the built-in
 function emptyOrSingleton().)"
Maybe<X> maybe<X>(X? x) 
        given X satisfies Object 
        => emptyOrSingleton(x);
    
"A higher order function to lift a 
 function that returns an optional
 value. The resulting function 
 returns boxed optional values."
Maybe<X>(Y) lift<X,Y>(X?(Y) f) 
        given X satisfies Object 
        => compose(maybe<X>, f);


shared void run() {
    value arg = maybe(process.arguments[0]);
    
    //using lift()
    arg.map(String.trimmed)
       .flatMap(lift(parseInteger))
       .each(print);
    
    //alternatively
    arg.map(String.trimmed)
       .map(parseInteger).coalesced
       .each(print);
    
    //using a comprehension
    { for (a in arg) 
      for (t in maybe(a.trimmed))
      for (p in maybe(parseInteger(t)))
      p }
            .each(print);
}