Mirror of forum.nim-lang.org

1920 :: qualify import for message syntax

• geezer9 (orginal) [2016-01-03T03:50:35+01:00] view original

  A proc declared as:

  proc foo(x:Thing,y:string)
  Run

  can be called using an alternate (method-like) syntax:

  x.foo(y)
  Run

  But when foo is imported from a module by

  from modfoo import nil
  Run

  so as to force use of modfoo qualification, I could only think to code:

  modfoo.foo(x,y)
  Run

  Is there a syntax to use something like the x.foo(y) notation?

---

• Araq (orginal) [2016-01-03T15:30:02+01:00] view original

  import modfoo except Thing seems to be what you want. You're then only forced to fully qualify modfoo.Thing.

---

• DTxplorer (orginal) [2016-01-05T22:50:29+01:00] view original

  Would it be a good idea to have a different operator to access module's symbols ?

  Maybe :: ?

---

• OderWat (orginal) [2016-01-06T01:56:38+01:00] view original

  Like x.modfoo::foo(y) I guess is what you mean? Is x.modfoo.foo(y) working?

---

• geezer9 (orginal) [2016-01-06T03:45:52+01:00] view original

  I guess some notation x.ZZZZ(y) where the ZZZZ somehow indicates the use of the proc foo which is imported from modfoo

  Probably something like:

  x.foo[modfoo](y)

  or

  x.modfoo[foo](y)

  or maybe

  x.(modfoo.foo)(y)

  but neither of those really fit well into the nim syntax scheme. Oh, well, maybe it is a bad idea.

---

• DTxplorer (orginal) [2016-01-06T11:41:28+01:00] view original

  I meant something who looks a bit like the C++ namespaces. It's not a solution for geezer9 (Araq gives him one), it's just a suggestion for the Nim's future ;) .

  import modfoo as mfoo
  
  mfoo::x.foo(y)
  Run

---

• wicastC (orginal) [2016-01-06T14:47:45+01:00] view original

  @DTxplorer should it be batter with this style?

  x.mfoo::foo(y)
  Run

  So we can have some more complex code.

  import foo1,foo2
  
  x.foo1::foo(y).foo2::foo(z)
  Run

  But anyway,it only happened when import some procs having exactly the same signature.Quite rare situation but namespace indicating with OOP is necessary.

  Most of the time x.foo(y) is enough.

---

• Araq (orginal) [2016-01-06T14:56:36+01:00] view original

  How is mfoo::x.foo(y) any better than mfoo.foo(x, y)? The purpose of the dot notation is convenience. Explicitly listing the module name is not convenient to begin with, so it doesn't need more sugar.

---

• wicastC (orginal) [2016-01-06T15:06:12+01:00] view original

  x.foo1::foo(y).foo2::foo(z)
  Run

  should same as

  foo2.foo(foo1.foo(x,y),y) #I even not sure is this correct,nesting is hard to read and write.
  Run

  suppose foo1.foo and foo2.foo has exactly the same signature.

  By the way,I hate c++'s :: style,but nesting is worse.

---