choam-laws
choam-laws
API
dev.tauri.choam.laws
AsyncReactiveLaws
AsyncReactiveLaws
ReactiveLaws
ReactiveLaws
RefLaws
RxnLaws
TestInstances
dev.tauri.choam.laws.discipline
AsyncReactiveLawTests
AsyncReactiveLawTests
ReactiveLawTests
ReactiveLawTests
RefLawTests
RefLawTests
RxnLawTests
choam-laws
/
dev.tauri.choam.laws
/
RxnLaws
RxnLaws
dev.tauri.choam.laws.RxnLaws
trait
RxnLaws
Attributes
Graph
Reset zoom
Hide graph
Show graph
Supertypes
class
Object
trait
Matchable
class
Any
Clear all
Members list
Concise view
Value members
Concrete methods
def
andAlsoIsAndThen
[
A
,
B
,
C
,
D
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
C
,
D
]):
IsEq
[
Rxn
[(
A
,
C
), (
B
,
D
)]]
def
asIsMap
[
A
,
B
,
C
](
rxn
:
Rxn
[
A
,
B
],
c
:
C
):
IsEq
[
Rxn
[
A
,
C
]]
def
associativeAndAlso
[
A
,
B
,
C
,
D
,
E
,
F
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
C
,
D
],
z
:
Rxn
[
E
,
F
]):
IsEq
[
Rxn
[((
A
,
C
),
E
), ((
B
,
D
),
F
)]]
def
choiceRetryNeutralLeft
[
A
,
B
](
x
:
Rxn
[
A
,
B
]):
IsEq
[
Rxn
[
A
,
B
]]
def
choiceRetryNeutralRight
[
A
,
B
](
x
:
Rxn
[
A
,
B
]):
IsEq
[
Rxn
[
A
,
B
]]
def
contramapIsLiftAndThen
[
A
,
B
,
C
](
f
:
A
=>
B
,
rxn
:
Rxn
[
B
,
C
]):
IsEq
[
Rxn
[
A
,
C
]]
def
distributiveAndAlsoChoice1
[
A
,
B
,
C
,
D
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
C
,
D
],
z
:
Rxn
[
C
,
D
]):
IsEq
[
Rxn
[(
A
,
C
), (
B
,
D
)]]
def
distributiveAndAlsoChoice2
[
A
,
B
,
C
,
D
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
A
,
B
],
z
:
Rxn
[
C
,
D
]):
IsEq
[
Rxn
[(
A
,
C
), (
B
,
D
)]]
def
distributiveAndThenChoice1
[
A
,
B
,
C
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
B
,
C
],
z
:
Rxn
[
B
,
C
]):
IsEq
[
Rxn
[
A
,
C
]]
def
distributiveAndThenChoice2
[
A
,
B
,
C
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
A
,
B
],
z
:
Rxn
[
B
,
C
]):
IsEq
[
Rxn
[
A
,
C
]]
def
equalsItself
[
A
,
B
](
rxn
:
Rxn
[
A
,
B
]):
IsEq
[
Rxn
[
A
,
B
]]
def
flatMapFIsAndThenComputed
[
A
,
B
,
C
](
x
:
Rxn
[
A
,
B
],
f
:
B
=>
Axn
[
C
]):
IsEq
[
Rxn
[
A
,
C
]]
def
flatMapIsSecondAndThenComputed
[
A
,
B
,
C
](
x
:
Rxn
[
A
,
B
],
f
:
B
=>
Rxn
[
A
,
C
]):
IsEq
[
Rxn
[
A
,
C
]]
def
mapIsAndThenLift
[
A
,
B
,
C
](
rxn
:
Rxn
[
A
,
B
],
f
:
B
=>
C
):
IsEq
[
Rxn
[
A
,
C
]]
def
provideIsContramap
[
A
,
B
](
a
:
A
,
rxn
:
Rxn
[
A
,
B
]):
IsEq
[
Axn
[
B
]]
def
pureIsRet
[
A
](
a
:
A
):
IsEq
[
Axn
[
A
]]
def
timesIsAndAlso
[
A
,
B
,
C
](
x
:
Rxn
[
A
,
B
],
y
:
Rxn
[
A
,
C
]):
IsEq
[
Rxn
[
A
, (
B
,
C
)]]
def
toFunctionIsProvide
[
A
,
B
](
rxn
:
Rxn
[
A
,
B
],
a
:
A
):
IsEq
[
Axn
[
B
]]
def
voidIsMap
[
A
,
B
](
rxn
:
Rxn
[
A
,
B
]):
IsEq
[
Rxn
[
A
,
Unit
]]