123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452 |
- discard """
- output: '''
- 10
- 20
- int
- 20
- 3
- x as ParameterizedType[T]
- x as ParameterizedType[T]
- x as ParameterizedType[T]
- x as ParameterizedType
- x as ParameterizedType
- x as CustomTypeClass
- 1
- 2
- 3
- 4
- 5
- 6
- a
- b
- t
- e
- s
- t
- z
- e
- 1
- 2
- 3
- 20
- 10
- 5
- 9
- '''
- """
- import typetraits, strutils
- block tcomparable:
- type
- Comparable = concept a
- (a < a) is bool
- proc myMax(a, b: Comparable): Comparable =
- if a < b:
- return b
- else:
- return a
- doAssert myMax(5, 10) == 10
- doAssert myMax(31.3, 1.23124) == 31.3
- block tconceptinclosure:
- type
- FonConcept = concept x
- x.x is int
- GenericConcept[T] = concept x
- x.x is T
- const L = T.name.len
- Implementation = object
- x: int
- Closure = object
- f: proc()
- proc f1(x: FonConcept): Closure =
- result.f = proc () =
- echo x.x
- proc f2(x: GenericConcept): Closure =
- result.f = proc () =
- echo x.x
- echo GenericConcept.T.name
- proc f3[T](x: GenericConcept[T]): Closure =
- result.f = proc () =
- echo x.x
- echo x.L
- let x = Implementation(x: 10)
- let y = Implementation(x: 20)
- let a = x.f1
- let b = x.f2
- let c = x.f1
- let d = y.f2
- let e = y.f3
- a.f()
- d.f()
- e.f()
- block overload_precedence:
- type ParameterizedType[T] = object
- type CustomTypeClass = concept c
- true
- # 3 competing procs
- proc a[T](x: ParameterizedType[T]) =
- echo "x as ParameterizedType[T]"
- proc a(x: ParameterizedType) =
- echo "x as ParameterizedType"
- proc a(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- # the same procs in different order
- proc b(x: ParameterizedType) =
- echo "x as ParameterizedType"
- proc b(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- proc b[T](x: ParameterizedType[T]) =
- echo "x as ParameterizedType[T]"
- # and yet another order
- proc c(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- proc c(x: ParameterizedType) =
- echo "x as ParameterizedType"
- proc c[T](x: ParameterizedType[T]) =
- echo "x as ParameterizedType[T]"
- # remove the most specific one
- proc d(x: ParameterizedType) =
- echo "x as ParameterizedType"
- proc d(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- # then shuffle the order again
- proc e(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- proc e(x: ParameterizedType) =
- echo "x as ParameterizedType"
- # the least specific one is a match
- proc f(x: CustomTypeClass) =
- echo "x as CustomTypeClass"
- a(ParameterizedType[int]())
- b(ParameterizedType[int]())
- c(ParameterizedType[int]())
- d(ParameterizedType[int]())
- e(ParameterizedType[int]())
- f(ParameterizedType[int]())
- block templates:
- template typeLen(x): int = x.type.name.len
- template bunchOfChecks(x) =
- x.typeLen > 3
- x != 10 is bool
- template stmtListExprTmpl(x: untyped): untyped =
- x is int
- x
- type
- Obj = object
- x: int
- Gen[T] = object
- x: T
- Eq = concept x, y
- (x == y) is bool
- NotEq = concept x, y
- (x != y) is bool
- ConceptUsingTemplate1 = concept x
- echo x
- sizeof(x) is int
- bunchOfChecks x
- ConceptUsingTemplate2 = concept x
- stmtListExprTmpl x
- template ok(x) =
- static: assert(x)
- template no(x) =
- static: assert(not(x))
- ok int is Eq
- ok int is NotEq
- ok string is Eq
- ok string is NotEq
- ok Obj is Eq
- ok Obj is NotEq
- ok Gen[string] is Eq
- ok Gen[int] is NotEq
- no int is ConceptUsingTemplate1
- ok float is ConceptUsingTemplate1
- no string is ConceptUsingTemplate1
- ok int is ConceptUsingTemplate2
- no float is ConceptUsingTemplate2
- no string is ConceptUsingTemplate2
- block titerable:
- type
- Iterable[T] = concept x
- for value in x:
- type(value) is T
- proc sum[T](iter: Iterable[T]): T =
- static: echo T.name
- for element in iter:
- static: echo element.type.name
- result += element
- doAssert sum([1, 2, 3, 4, 5]) == 15
- block tmanual:
- template accept(e) =
- static: assert compiles(e)
- template reject(e) =
- static: assert(not compiles(e))
- type
- Container[T] = concept c
- c.len is Ordinal
- items(c) is T
- for value in c:
- type(value) is T
- proc takesIntContainer(c: Container[int]) =
- for e in c: echo e
- takesIntContainer(@[1, 2, 3])
- reject takesIntContainer(@["x", "y"])
- proc takesContainer(c: Container) =
- for e in c: echo e
- takesContainer(@[4, 5, 6])
- takesContainer(@["a", "b"])
- takesContainer "test"
- reject takesContainer(10)
- block modifiers_in_place:
- type
- VarContainer[T] = concept c
- put(var c, T)
- AltVarContainer[T] = concept var c
- put(c, T)
- NonVarContainer[T] = concept c
- put(c, T)
- GoodContainer = object
- x: int
- BadContainer = object
- x: int
- proc put(x: BadContainer, y: int) = discard
- proc put(x: var GoodContainer, y: int) = discard
- template ok(x) = assert(x)
- template no(x) = assert(not(x))
- static:
- ok GoodContainer is VarContainer[int]
- ok GoodContainer is AltVarContainer[int]
- no BadContainer is VarContainer[int]
- no BadContainer is AltVarContainer[int]
- ok GoodContainer is NonVarContainer[int]
- ok BadContainer is NonVarContainer[int]
- block treversable:
- type
- Reversable[T] = concept a
- a[int] is T
- a.high is int
- a.len is int
- a.low is int
- proc get[T](s: Reversable[T], n: int): T =
- s[n]
- proc hi[T](s: Reversable[T]): int =
- s.high
- proc lo[T](s: Reversable[T]): int =
- s.low
- iterator reverse[T](s: Reversable[T]): T =
- assert hi(s) - lo(s) == len(s) - 1
- for z in hi(s).countdown(lo(s)):
- yield s.get(z)
- for s in @["e", "z"].reverse:
- echo s
- block tmonoid:
- type Monoid = concept x, y
- x + y is type(x)
- type(z(type(x))) is type(x)
- proc z(x: typedesc[int]): int = 0
- doAssert(int is Monoid)
- # https://github.com/nim-lang/Nim/issues/8126
- type AdditiveMonoid = concept x, y, type T
- x + y is T
- # some redundant checks to test an alternative approaches:
- type TT = type(x)
- x + y is type(x)
- x + y is TT
- doAssert(1 is AdditiveMonoid)
- block tesqofconcept:
- type
- MyConcept = concept x
- someProc(x)
- SomeSeq = seq[MyConcept]
- proc someProc(x:int) = echo x
- proc work (s: SomeSeq) =
- for item in s:
- someProc item
- var s = @[1, 2, 3]
- work s
- block tvectorspace:
- type VectorSpace[K] = concept x, y
- x + y is type(x)
- zero(type(x)) is type(x)
- -x is type(x)
- x - y is type(x)
- var k: K
- k * x is type(x)
- proc zero(T: typedesc): T = 0
- static:
- assert float is VectorSpace[float]
- # assert float is VectorSpace[int]
- # assert int is VectorSpace
- block tstack:
- template reject(e) =
- static: assert(not compiles(e))
- type
- ArrayStack = object
- data: seq[int]
- proc push(s: var ArrayStack, item: int) =
- s.data.add item
- proc pop(s: var ArrayStack): int =
- return s.data.pop()
- type
- Stack[T] = concept var s
- s.push(T)
- s.pop() is T
- type ValueType = T
- const ValueTypeName = T.name.toUpperAscii
- proc genericAlgorithm[T](s: var Stack[T], y: T) =
- static:
- echo "INFERRED ", T.name
- echo "VALUE TYPE ", s.ValueType.name
- echo "VALUE TYPE NAME ", s.ValueTypeName
- s.push(y)
- echo s.pop
- proc implicitGeneric(s: var Stack): auto =
- static:
- echo "IMPLICIT INFERRED ", s.T.name, " ", Stack.T.name
- echo "IMPLICIT VALUE TYPE ", s.ValueType.name, " ", Stack.ValueType.name
- echo "IMPLICIT VALUE TYPE NAME ", s.ValueTypeName, " ", Stack.ValueTypeName
- return s.pop()
- var s = ArrayStack(data: @[])
- s.push 10
- s.genericAlgorithm 20
- echo s.implicitGeneric
- reject s.genericAlgorithm "x"
- reject s.genericAlgorithm 1.0
- reject "str".implicitGeneric
- reject implicitGeneric(10)
- import libs/[trie_database, trie]
- block ttrie:
- proc takeDb(d: TrieDatabase) = discard
- var mdb: MemDB
- takeDb(mdb)
- import mvarconcept
- block tvar:
- # bug #2346, bug #2404
- echo randomInt(5)
- block tcomment:
- type
- Foo = concept
- ## Some comment
- proc bar(x: Self)
- proc bar(x: int) = echo x
- proc foo(x: Foo) = x.bar
- foo(9)
|