proposal (with implementation): `undistinct(T)`

[timotheecour]

type A=distinct int

proc test()=
  let a1:A = 0.A
  let a2:A = 0.A

  when defined(case0):
    # ok but verbose and not DRY
    echo a1.int == a2.int

  when defined(case1):
    # Error: type mismatch: got <A, A>
    echo a1 == a2

  when defined(case2):
    # ok but requires boilerplate
    proc `==`(a:A, b:A):bool = a.int == b.int
    echo a1 == a2

  when defined(case2b):
    # ok but requires boilerplate (a tiny bit less)
    proc `==`(a:A, b:A):bool {.borrow.}
    echo a1 == a2

  when defined(case3):
    # BUG: not matched (how to do that?) ; should be in system.nim
    proc `==`[T](a:distinct T, b:distinct T): bool = a.T == b.T
    echo a1 == a2

test()

redefining == for distinct int (more generally distinct T for any type T) doesn't make much sense, it's just boilerplate.

so the proposal is:

• add undistinct(T) such that type T2 = distinct T; assert T2.undistinct is T
• add this to system.nim or some stdlib module EDIT removed from this proposal after feedback

proc `==`[T:distinct](a:T, b:T): bool =
  type T2 = T.undistinct
  a.T2 == b.T2

NOTE: https://nim-lang.org/docs/manual.html#type-relations-type-equality-modulo-type-distinction suggests using a.baseType but that doesn't work

EDIT see my reply below for a working implementation

[timotheecour]

/cc @Araq
ok I figured out how to do it; should that be in macros or system (after cleaning up implementation)?
if we want == to be automatic for distinct types, it should be in system...

Anyhow, undistinct is super useful, it allows doing what's in the doc in https://nim-lang.org/docs/manual.html#type-relations-type-equality-modulo-type-distinction https://nim-lang.org/docs/manual.html#distinct-type-modelling-currencies (defineCurrency etc) in a perhaps cleaner way; there are other use cases.

import macros

macro undistinct*(T: typedesc): untyped =
  let typeNode = getTypeImpl(T)
  expectKind(typeNode, nnkBracketExpr)
  doAssert: ($typeNode[0]) == "typeDesc"
  let typeSym = typeNode[1]
  let impl = getTypeImpl(typeSym)
  doAssert: $impl.typeKind == "ntyDistinct"
  getTypeInst(impl[0])


proc `==`[T:distinct](a:T, b:T): bool =
  type T2 = T.undistinct
  a.T2 == b.T2

when isMainModule:
  import unittest
  type A=distinct int
  proc test()=
    let a1:A = 0.A
    require: a1 is distinct

    type B=A.undistinct
    require: B is int

    echo a1 == a1

  test()

[andreaferretti]

What if the reason I am using distinct types is because I have a different concept of equality? Example (untested, to give an idea)

type Modulo[N: static[int]] = distinct int

proc `==`[N: static[int]](a, b: Modulo[N]): bool = (a -b) mod N == 0

[andreaferretti]

(If you want to avoid boilerplate there is {.borrow.})

[awr1]

I've been wanting a feature like this for some time, to be able to convert distinct types to their base forms. (indistinct might be a more natural-sounding name)

[andreaferretti]

The undistinct (or indistinct) macro is in fact very nice. I would do a PR to add that in sugar, without the == definition, which seems rather arbitrary.

[awr1]

Is it possible to make a distinct form of a distinct type? If so, that raises the question of what this macro should do: should it revert to the root type or just the parent?

[timotheecour]

just the parent. but maybe we can add a bool flag recursive

[mratsim]

I remember trying to build my own undistinct macro here a couple months ago.

What I didn't think of was that I could getTypeInst(impl[0]) the implementation extracted via getTypeImpl. So I tried to automatically generate the proper converter instead.

Anyway, I think it should be in sugar. Also related to #7719 / nim-lang/RFCs#44 (Working with types in macros is difficult)