blob: 35652e2e0ac6bbea1a91684cf4e5da8069343f97 (
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
discard """
output: '''4887 true
0.5'''
"""
# test the new borrow feature that works with generics:
proc `++`*[T: int | float](a, b: T): T =
result = a + b
type
DI = distinct int
DF = distinct float
DS = distinct string
proc `++`(x, y: DI): DI {.borrow.}
proc `++`(x, y: DF): DF {.borrow.}
proc `$`(x: DI): string {.borrow.}
proc `$`(x: DF): string {.borrow.}
echo 4544.DI ++ 343.DI, " ", (4.5.DF ++ 0.5.DF).float == 5.0
# issue #14440
type Radians = distinct float64
func `-=`(a: var Radians, b: Radians) {.borrow.}
var a = Radians(1.5)
let b = Radians(1.0)
a -= b
echo a.float64
block: #14449
type
Foo[T] = object
foo: T
Bar[T] {.borrow:`.`.} = distinct Foo[T]
SomeThing {.borrow:`.`.} = distinct Foo[float]
OtherThing {.borrow:`.`.} = distinct SomeThing
var
a: Bar[int]
b: SomeThing
c: OtherThing
a.foo = 300
b.foo = 400
c.foo = 42
assert a.foo == 300
assert b.foo == 400d
assert c.foo == 42d
block: # Borrow from muliple aliasses #16666
type
AImpl = object
i: int
A = AImpl
B {.borrow: `.`.} = distinct A
C = B
D {.borrow: `.`.} = distinct C
E {.borrow: `.`.} = distinct D
let
b = default(B)
d = default(D)
e = default(E)
assert b.i == 0
assert d.i == 0
assert e.i == 0
block: # Borrow from generic alias
type
AImpl[T] = object
i: T
B[T] = AImpl[T]
C {.borrow: `.`.} = distinct B[int]
D = B[float]
E {.borrow: `.`.} = distinct D
let
c = default(C)
e = default(E)
assert c.i == int(0)
assert e.i == 0d
|