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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
discard """
output: '''
tdistinct
25
false
false
false
false
Foo
'''
"""
echo "tdistinct"
block tborrowdot:
type
Foo = object
a, b: int
s: string
Bar {.borrow: `.`.} = distinct Foo
var bb: ref Bar
new bb
bb.a = 90
bb.s = "abc"
block tcurrncy:
template Additive(typ: untyped) =
proc `+`(x, y: typ): typ {.borrow.}
proc `-`(x, y: typ): typ {.borrow.}
# unary operators:
proc `+`(x: typ): typ {.borrow.}
proc `-`(x: typ): typ {.borrow.}
template Multiplicative(typ, base: untyped) =
proc `*`(x: typ, y: base): typ {.borrow.}
proc `*`(x: base, y: typ): typ {.borrow.}
proc `div`(x: typ, y: base): typ {.borrow.}
proc `mod`(x: typ, y: base): typ {.borrow.}
template Comparable(typ: untyped) =
proc `<`(x, y: typ): bool {.borrow.}
proc `<=`(x, y: typ): bool {.borrow.}
proc `==`(x, y: typ): bool {.borrow.}
template DefineCurrency(typ, base: untyped) =
type
typ = distinct base
Additive(typ)
Multiplicative(typ, base)
Comparable(typ)
proc `$`(t: typ): string {.borrow.}
DefineCurrency(TDollar, int)
DefineCurrency(TEuro, int)
echo($( 12.TDollar + 13.TDollar )) #OUT 25
block tconsts:
# bug #2641
type MyChar = distinct char
const c:MyChar = MyChar('a')
type MyBool = distinct bool
const b:MyBool = MyBool(true)
type MyBoolSet = distinct set[bool]
const bs:MyBoolSet = MyBoolSet({true})
type MyCharSet= distinct set[char]
const cs:MyCharSet = MyCharSet({'a'})
type MyBoolSeq = distinct seq[bool]
const bseq:MyBoolSeq = MyBoolSeq(@[true, false])
type MyBoolArr = distinct array[3, bool]
const barr:MyBoolArr = MyBoolArr([true, false, true])
# bug #2760
type
DistTup = distinct tuple
foo, bar: string
const d: DistTup = DistTup((
foo:"FOO", bar:"BAR"
))
# bug #7167
type Id = distinct range[0..3]
proc `<=`(a, b: Id): bool {.borrow.}
var xs: array[Id, bool]
for x in xs: echo x # type mismatch: got (T) but expected 'bool'
# bug #11715
type FooD = distinct int
proc `<=`(a, b: FooD): bool {.borrow.}
for f in [FooD(0): "Foo"]: echo f
block tRequiresInit:
template accept(x) =
static: doAssert compiles(x)
template reject(x) =
static: doAssert not compiles(x)
type
Foo = object
x: string
DistinctFoo {.requiresInit, borrow: `.`.} = distinct Foo
DistinctString {.requiresInit.} = distinct string
reject:
var foo: DistinctFoo
foo.x = "test"
doAssert foo.x == "test"
accept:
let foo = DistinctFoo(Foo(x: "test"))
doAssert foo.x == "test"
reject:
var s: DistinctString
s = "test"
doAssert s == "test"
accept:
let s = "test"
doAssert s == "test"
|