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
|
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
|