/
Opt.scala
64 lines (55 loc) · 5.28 KB
/
Opt.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package scalqa; package lang; package short; package g; import language.implicitConversions; import G.Opt
object Opt:
@tn("getVoid") inline def void[A<:Raw] : Opt[A] = 100_000.cast[Opt[A]]
implicit inline def implicitRequest [A<:Raw](v:VOID) : Opt[A] = void[A]
implicit inline def implicitFromAnyShort[A<:Raw](inline v: A) : Opt[A] = v.cast[Opt[A]]
implicit inline def implicitToBoolean [A<:Raw](inline v: Opt[A]) : Boolean = v.real != void.real
implicit inline def implicitToValOpt [A<:Raw](inline v: Opt[A]) : Val.Opt[A] = v.ref
extension[A<:Raw](inline x: Opt[A])
/**/ inline def real : Int = x.cast[Int]
/**/ inline def ref : Val.Opt[A] = {val X=x; if(X.isEmpty) ZZ.None else java.lang.Short.valueOf(X.real.toShort)}.cast[Val.Opt[A]]
/**/ inline def isEmpty : Boolean = x.real == void.real
/**/ inline def nonEmpty : Boolean = x.real != void.real
/**/ inline def take( inline f: A => Boolean) : Opt[A] = {val X=x; var o:Opt[A]=VOID;if(X!=o && f(X.`val`)) o=X; o}
/**/ inline def takeOnly(inline v: A) : Opt[A] = x.take(_.real == v.real)
/**/ inline def drop( inline f: A => Boolean) : Opt[A] = {val X=x; var o:Opt[A]=VOID;if(X!=o && !f(X.`val`)) o=X; o}
/**/ inline def dropOnly(inline v: A) : Opt[A] = x.drop(_.real == v.real)
/**/ inline def default(inline v: => A) : Opt[A] = {val X=x; if(X.isEmpty) v else X }
infix inline def orOpt(inline that: => Opt[A]) : Opt[A] = {val X=x; if(X.isEmpty) that else X }
infix inline def or(inline default: => A) : A = {val X=x; if(X.isEmpty) default else X.`val`}
/**/ inline def contains(v: A) : Boolean = x == v.?
/**/ inline def forval[U]( inline f: A=>U) : Opt[A] = {val X=x; if(X.nonEmpty) f(X.`val`); X}
/**/ inline def foreach[U](inline f: A=>U) : Opt[A] = {val X=x; if(X.nonEmpty) f(X.`val`); X}
/**/ inline def fornil[U]( inline f: => U) : Opt[A] = {val X=x; if(X.isEmpty){ val u:U=f}; X}
/**/ inline def process[U,W](inline f:A=>U,inline fNil: =>W): Opt[A] = {val X=x; if(X.isEmpty){ val w:W=fNil} else f(X.`val`); X}
/**/ inline def filter(inline f: A => Boolean) : Opt[A] = x.take(f)
/**/ inline def withFilter(inline f: A=>Boolean) : Opt[A] = x.take(f)
/**/ inline def raw : Opt[A] = x
/**/ inline def mapIf(inline f:A=>Boolean,inline m:A=>A) : Opt[A] = x.map[A](v => if(f(v)) m(v) else v)
/**/ inline def map[B](inline f:A=>B) (using inline s:Specialized[B]): s.Opt = z.opt.map(x,f)
/**/ inline def mapOpt [B,OPT<:Any.Opt[B]](inline f: A=>OPT)(using inline o:Specialized.Opt[B,OPT], inline s:Specialized[B]): s.Opt = z.opt.mapOpt(x,f)
/**/ inline def flatMap[B,OPT<:Any.Opt[B]](inline f: A=>OPT)(using inline o:Specialized.Opt[B,OPT], inline s:Specialized[B]): s.Opt = z.opt.mapOpt(x,f)
/**/ inline def mix[B,C](inline o:Any.Opt[B],inline f:(A,B)=>C) (using inline s:Specialized[C]): s.Opt = z.opt.mix(x,o,f)
extension[A<:Raw](x: Opt[A])
/**/ def dropVoid (using d: Any.Def.Void[A]) : Opt[A] = if(x.nonEmpty && d.value_isVoid(x.`val`)) VOID else x
/**/ def get : A = { if(x.isEmpty) throw ZZ.EO(); x.`val` }
/**/ def stream : G.Stream[A]= if(x.isEmpty) G.Stream.void else G.Stream(x.`val`)
object TYPE:
opaque type DEF[+A<:Raw] <: Int.Opaque = Int.Opaque
given z_CanEqualOpt[A<:Raw,B<:Raw](using CanEqual[A,B]): CanEqual[Opt[A],Opt[B]] = CanEqual.derived
given z_NameDef [A<:Raw :Any.Def.TypeName] : Any.Def.TypeName[Opt[A]] = new any.z.opt.NameDef()
given z_VoidDef [A<:Raw] : Any.Def.Void[Opt[A]] = Z.OptEmptyDef.cast[Any.Def.Void[Opt[A]]]
given z_EmptyDef[A<:Raw] : Any.Def.Empty[Opt[A]] = Z.OptEmptyDef.cast[Any.Def.Empty[Opt[A]]]
given z_Doc[A<:Raw :Any.Def.TypeName :Any.Def.Tag] : Any.Def.Doc[Opt[A]] = new Z.OptDocDef()
/*___________________________________________________________________________
__________ ____ __ ______ ____
/ __/ ___// _ | / / / __ / / _ | Scala Quick API
__\ \/ /___/ __ |/ /__/ /_/ /_/ __ | (c) 2021, Scalqa.org Inc
/_____/\____/_/ |_/____/\______/_/ |_| github.com/scalqa
___________________________________________________________________________*/
/**
@type DEF -> ### Short Specialized Generic Option
To be used with Short based opaque values.
@def void -> Get void instance
@def implicitRequest -> General void instance request \n\n It is possible to use general request VOID to get void instance of this type, thanks to this implicit conversion.
*/