oxygen-meta
oxygen-meta
API
oxygen
core.generic
ShowGeneric
annotation
fieldName
fieldName
hide
hide
obfuscate
const
map
obfuscate
typeName
typeName
meta
CaseExtractor
CaseExtractor
Zip
Merge
Zip
ZipLowPriority
LowPriority1
LowPriority2
LowPriority3
LowPriority4
ExprMonad
ExprMonad
K0
Derivable
Config
ProductDeriver
ProductDeriver
Impl
NotSupported
Split
WithInstances
SumDeriver
SumDeriver
NotSupported
Split
WithInstances
Derivable
Entity
Child
Deferred
Child
Entity
Expressions
Expressions
Elem
Generic
Generic
CacheVals
ChildFunction0
ChildFunction1
ChildFunction2
MapChildren
IdentityGeneric
IdentityChild
ProductGeneric
AnyValGeneric
AnyValGeneric
AnyValUtil
CaseClassGeneric
CaseClassGeneric
CaseObjectGeneric
CaseObjectGeneric
CaseObjectInstantiate
Subset
Empty
Many
NonEmpty
Single
Subset
subInstance
ProductGeneric
Field
Instantiate
ProductOrSumGeneric
SumGeneric
EnumGeneric
FlatGeneric
NestedGeneric
OrdinalStrategy
UnrollStrategy
SumGeneric
Case
Matcher
ValDefinitions
ValDefinitionsWith
annotation
showDerivation
MatchBuilder
MatchBuilder
Case
Case
CaseImpl
StringExpr
Str
StrBuilder
StringExpr
oxygen-meta
/
oxygen
/
oxygen.meta
/
ExprMonad
ExprMonad
oxygen.meta.ExprMonad
See the
ExprMonad
companion object
trait
ExprMonad
[
F
[
_
]]
Attributes
Companion
object
Graph
Reset zoom
Hide graph
Show graph
Supertypes
class
Object
trait
Matchable
class
Any
Members list
Clear all
Value members
Abstract methods
def
flatMap
[
A
,
B
](
a
:
Expr
[
F
[
A
]])(
f
:
Expr
[
A
=>
F
[
B
]])(
using
quotes
:
Quotes
,
fType
:
Type
[
F
],
aType
:
Type
[
A
],
bType
:
Type
[
B
]):
Expr
[
F
[
B
]]
def
map
[
A
,
B
](
a
:
Expr
[
F
[
A
]])(
f
:
Expr
[
A
=>
B
])(
using
quotes
:
Quotes
,
fType
:
Type
[
F
],
aType
:
Type
[
A
],
bType
:
Type
[
B
]):
Expr
[
F
[
B
]]
def
pure
[
A
](
a
:
Expr
[
A
])(
using
quotes
:
Quotes
,
fType
:
Type
[
F
],
aType
:
Type
[
A
]):
Expr
[
F
[
A
]]
Concrete methods
final
def
flatMapE
[
A
,
B
](
a
:
Expr
[
F
[
A
]])(
f
:
Quotes
?=>
Expr
[
A
]
=>
Expr
[
F
[
B
]])(
using
quotes
:
Quotes
,
fType
:
Type
[
F
],
aType
:
Type
[
A
],
bType
:
Type
[
B
]):
Expr
[
F
[
B
]]
final
def
mapE
[
A
,
B
](
a
:
Expr
[
F
[
A
]])(
f
:
Quotes
?=>
Expr
[
A
]
=>
Expr
[
B
])(
using
quotes
:
Quotes
,
fType
:
Type
[
F
],
aType
:
Type
[
A
],
bType
:
Type
[
B
]):
Expr
[
F
[
B
]]
In this article
Attributes
Members list
Value members
Abstract methods
Concrete methods