blob: 2152d7fff9d7826d6c61a2deda0a041590c17139 (
plain) (
blame)
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
|
discard """
output: '''B
0'''
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
|