com
.
twitter
.
algebird
Group
object
Group
extends
GeneratedGroupImplicits
with
ProductGroups
with
FromAlgebraGroupImplicit0
with
Serializable
Linear Supertypes
Serializable
,
Serializable
,
FromAlgebraGroupImplicit0
,
FromAlgebraGroupImplicit1
,
ProductGroups
,
GeneratedGroupImplicits
,
AnyRef
,
Any
Ordering
Alphabetic
By inheritance
Inherited
Group
Serializable
Serializable
FromAlgebraGroupImplicit0
FromAlgebraGroupImplicit1
ProductGroups
GeneratedGroupImplicits
AnyRef
Any
Hide All
Show all
Learn more about member selection
Visibility
Public
All
Value Members
final
def
!=
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
final
def
!=
(
arg0:
Any
)
:
Boolean
Definition Classes
Any
final
def
##
()
:
Int
Definition Classes
AnyRef → Any
final
def
==
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
final
def
==
(
arg0:
Any
)
:
Boolean
Definition Classes
Any
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
,
ugroup:
Group
[
U
]
,
vgroup:
Group
[
V
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
,
ugroup:
Group
[
U
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
,
G
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
,
G
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
,
F
]
(
applyX: (
A
,
B
,
C
,
D
,
E
,
F
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
,
F
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
,
E
]
(
applyX: (
A
,
B
,
C
,
D
,
E
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
,
E
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
,
D
]
(
applyX: (
A
,
B
,
C
,
D
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
,
D
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
,
C
]
(
applyX: (
A
,
B
,
C
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
,
C
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
def
apply
[
X
,
A
,
B
]
(
applyX: (
A
,
B
) ⇒
X
,
unapplyX: (
X
) ⇒
Option
[(
A
,
B
)]
)
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
)
:
Group
[
X
]
Definition Classes
ProductGroups
final
def
asInstanceOf
[
T0
]
:
T0
Definition Classes
Any
implicit
def
bigDecimalGroup
:
Group
[
BigDecimal
]
implicit
def
bigIntGroup
:
Group
[
BigInt
]
implicit
def
boolGroup
:
Group
[
Boolean
]
def
clone
()
:
AnyRef
Attributes
protected[
java.lang
]
Definition Classes
AnyRef
Annotations
@throws
(
...
)
implicit
def
doubleGroup
:
Group
[
Double
]
final
def
eq
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
def
equals
(
arg0:
Any
)
:
Boolean
Definition Classes
AnyRef → Any
def
equiv
[
T
]
(
implicit
grp:
Group
[
T
]
)
:
Equiv
[
T
]
def
finalize
()
:
Unit
Attributes
protected[
java.lang
]
Definition Classes
AnyRef
Annotations
@throws
(
classOf[java.lang.Throwable]
)
implicit
def
floatGroup
:
Group
[
Float
]
implicit
def
fromAlgebraAdditiveGroup
[
T
]
(
implicit
m:
AdditiveGroup
[
T
]
)
:
Group
[
T
]
Definition Classes
FromAlgebraGroupImplicit1
implicit
def
fromAlgebraGroup
[
T
]
(
implicit
m:
algebra.Group
[
T
]
)
:
Group
[
T
]
Definition Classes
FromAlgebraGroupImplicit0
final
def
getClass
()
:
Class
[_]
Definition Classes
AnyRef → Any
implicit
def
group10
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group11
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group12
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group13
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group14
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group15
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group16
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group17
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group18
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group19
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group2
[
A
,
B
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
)
:
Group
[(
A
,
B
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group20
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group21
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
,
ugroup:
Group
[
U
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group22
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
,
jgroup:
Group
[
J
]
,
kgroup:
Group
[
K
]
,
lgroup:
Group
[
L
]
,
mgroup:
Group
[
M
]
,
ngroup:
Group
[
N
]
,
ogroup:
Group
[
O
]
,
pgroup:
Group
[
P
]
,
qgroup:
Group
[
Q
]
,
rgroup:
Group
[
R
]
,
sgroup:
Group
[
S
]
,
tgroup:
Group
[
T
]
,
ugroup:
Group
[
U
]
,
vgroup:
Group
[
V
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
,
J
,
K
,
L
,
M
,
N
,
O
,
P
,
Q
,
R
,
S
,
T
,
U
,
V
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group3
[
A
,
B
,
C
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
)
:
Group
[(
A
,
B
,
C
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group4
[
A
,
B
,
C
,
D
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
)
:
Group
[(
A
,
B
,
C
,
D
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group5
[
A
,
B
,
C
,
D
,
E
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group6
[
A
,
B
,
C
,
D
,
E
,
F
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group7
[
A
,
B
,
C
,
D
,
E
,
F
,
G
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group8
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
)]
Definition Classes
GeneratedGroupImplicits
implicit
def
group9
[
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
]
(
implicit
agroup:
Group
[
A
]
,
bgroup:
Group
[
B
]
,
cgroup:
Group
[
C
]
,
dgroup:
Group
[
D
]
,
egroup:
Group
[
E
]
,
fgroup:
Group
[
F
]
,
ggroup:
Group
[
G
]
,
hgroup:
Group
[
H
]
,
igroup:
Group
[
I
]
)
:
Group
[(
A
,
B
,
C
,
D
,
E
,
F
,
G
,
H
,
I
)]
Definition Classes
GeneratedGroupImplicits
def
hashCode
()
:
Int
Definition Classes
AnyRef → Any
implicit
def
indexedSeqGroup
[
T
]
(
implicit
arg0:
Group
[
T
]
)
:
Group
[
IndexedSeq
[
T
]]
implicit
def
intGroup
:
Group
[
Int
]
def
intTimes
[
T
]
(
i:
BigInt
,
v:
T
)
(
implicit
grp:
Group
[
T
]
)
:
T
Same as v + v + v .
Same as v + v + v .. + v (i times in total)
final
def
isInstanceOf
[
T0
]
:
Boolean
Definition Classes
Any
implicit
def
jboolGroup
:
Group
[
Boolean
]
implicit
def
jdoubleGroup
:
Group
[
Double
]
implicit
def
jfloatGroup
:
Group
[
Float
]
implicit
def
jintGroup
:
Group
[
Integer
]
implicit
def
jlongGroup
:
Group
[
Long
]
implicit
def
jshortGroup
:
Group
[
Short
]
implicit
def
longGroup
:
Group
[
Long
]
implicit
def
mapGroup
[
K
,
V
]
(
implicit
group:
Group
[
V
]
)
:
Group
[
Map
[
K
,
V
]]
def
minus
[
T
]
(
l:
T
,
r:
T
)
(
implicit
grp:
Group
[
T
]
)
:
T
final
def
ne
(
arg0:
AnyRef
)
:
Boolean
Definition Classes
AnyRef
def
negate
[
T
]
(
x:
T
)
(
implicit
grp:
Group
[
T
]
)
:
T
final
def
notify
()
:
Unit
Definition Classes
AnyRef
final
def
notifyAll
()
:
Unit
Definition Classes
AnyRef
implicit
def
nullGroup
:
Group
[
Null
]
implicit
def
optionGroup
[
T
]
(
implicit
arg0:
Group
[
T
]
)
:
OptionGroup
[
T
]
implicit
def
scMapGroup
[
K
,
V
]
(
implicit
group:
Group
[
V
]
)
:
Group
[
Map
[
K
,
V
]]
implicit
def
shortGroup
:
Group
[
Short
]
final
def
synchronized
[
T0
]
(
arg0: ⇒
T0
)
:
T0
Definition Classes
AnyRef
def
toString
()
:
String
Definition Classes
AnyRef → Any
implicit
def
unitGroup
:
Group
[
Unit
]
final
def
wait
()
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
final
def
wait
(
arg0:
Long
,
arg1:
Int
)
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
final
def
wait
(
arg0:
Long
)
:
Unit
Definition Classes
AnyRef
Annotations
@throws
(
...
)
Inherited from
Serializable
Inherited from
Serializable
Inherited from
FromAlgebraGroupImplicit0
Inherited from
FromAlgebraGroupImplicit1
Inherited from
ProductGroups
Inherited from
GeneratedGroupImplicits
Inherited from
AnyRef
Inherited from
Any
Ungrouped
