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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
discard """
output: '''B
0
E2-B'''
joinable: false
"""
{.experimental: "overloadableEnums".}
type
E1 = enum
value1,
value2
E2 = enum
value1,
value2 = 4
const
Lookuptable = [
E1.value1: "1",
value2: "2"
]
when false:
const
Lookuptable: array[E1, string] = [
value1: "1",
value2: "2"
]
proc p(e: E1): int =
# test that the 'case' statement is smart enough:
case e
of value1: echo "A"
of value2: echo "B"
let v = p value2 # ERROR: ambiguous!
# (value2|value2) nkClosedSymChoice -> nkSym
proc x(p: int) = discard
proc x(p: string) = discard
proc takeCallback(param: proc(p: int)) = discard
takeCallback x
echo ord v
block: # https://github.com/nim-lang/RFCs/issues/8
type
Enum1 = enum
A, B, C
Enum2 = enum
A, Z
proc f(e: Enum1): int = ord(e)
proc g(e: Enum2): int = ord(e)
proc h(e: Enum1): int = ord(e)
proc h(e: Enum2): int = ord(e)
let fA = f(A) # Type of A is well defined
let gA = g(A) # Same as above
let hA1 = h(Enum1.A) # A requires disambiguation
let hA2 = h(Enum2.A) # Similarly
let hA3 = h(B)
let hA4 = h(B)
let x = ord(Enum1.A) # Also
doAssert fA == 0
doAssert gA == 0
doAssert hA1 == 0
doAssert hA2 == 0
doAssert x == 0
doAssert hA3 == 1
doAssert hA4 == 1
# bug #18769
proc g3[T](x: T, e: E2): int =
case e
of value1: echo "E2-A" # Error: type mismatch: got 'E1' for 'value1' but expected 'E2 = enum'
of value2: echo "E2-B"
let v5 = g3(99, E2.value2)
block: # only allow enums to overload enums
# mirrors behavior without overloadableEnums
proc foo() = discard
block:
type Foo = enum foo
doAssert foo is Foo
foo()
import macros
block: # test with macros/templates
type
Enum1 = enum
value01, value02
Enum2 = enum
value01, value10
macro isOneM(a: untyped): bool =
result = newCall(bindSym"==", a, ident"value01")
macro isOneMS(a: untyped): bool =
result = newCall(bindSym"==", a, bindSym"value01")
template isOneT(a: untyped): bool =
a == value01
let e1 = Enum1.value01
let e2 = Enum2.value01
doAssert isOneM(e1)
doAssert isOneM(e2)
doAssert isOneMS(e1)
doAssert isOneMS(e2)
doAssert isOneT(e1)
doAssert isOneT(e2)
|
