Differences between compiling 'classic call syntax' vs 'method call syntax' .

[bellthom]

Differences between compiling if using 'classic call syntax' vs 'method call syntax' .

Here's the appoach to provoke error:

1.) Create files as descibed beneath in section "Sample code".

2.) Try to compile "Test1.nim" (using classic call syntax)
=> Compile ends propperly

3.) Try to compile "Test2.nim" (same as Test1.nim, but using 'method call syntax')
=> Compile ends in error message:

d:\Users\thomas\Desktop\Test\test.nim(4, 5) Error: undeclared field: 'Window' for type system.int [declared in D:\Nim\nim-1.0.0\lib\system.nim(26, 3)]
found 'Window' of kind 'module'

Sample code:

Create File: "win32.nim"

from window as Window import nil

Create File: "window.nim"

proc New*(title:string):int = 
  echo "> Create New Window With Title = " & $title
  return 1234567890
proc Title*(self:int, name:string) = 
  echo "> Title Of window " & $self & " Changed To " & $name
template Title*(self:int):string = 
  "< Title Of Window " & $self

Create File: "Test1.nim"

include win32
let main = Window.New(r"Hello World")
Window.Title(main,r"New Title")
echo Window.Title(main)

Create File: "Test1.nim"

include win32
let main = Window.New(r"Hello World")
main.Window.Title(r"New Title")
echo main.Window.Title

[demotomohiro]

This is limitations of the method call syntax.

[krux02]

cannot reproduce this on my working computer Linux. Can you provide an examples that doesn't use platform dependent API?

[bellthom]

Hi Arne,
your blended by the vaiable names. It's plain and simple nim code. There is no byte of plattform dependend code like OS calls or similar stuff.

The point is that in 'classic call syntax' the call of a procedure, in this case:

    Window.Title(main, r"New Title")  

works propperly. But if you try to do the same call in 'methode call syntax'

    main.Window.Title(r"New Title")

the compilation fails. It seems that the compiler only recognize the term ' .Window. ' and don't resolve it up to the procedure ' .Windows.Title. '

I'll prepare a more generic sample on Linux at the beginnig of the next week.

Have a nice weekend,

br, Thomas

[krux02]

Yea, I am confused by the names a lot. Your programming patterns don't match very well with the style that is used in Nim programs. Packages are normally never written with upper case letters, that is usually reseved for types. So in main.Window.Title(r"New Title") I read a type conversion of main to Window, not a package qualified name Window.Title. If you look at the ast, it should be clear that your intent can't work, because main.Window is resolved first.

import macros
dumpLisp:
  main.Window.Title(r"New Title")
# output:
# (StmtList
#  (Call
#   (DotExpr
#    (DotExpr
#     (Ident "main")
#     (Ident "Window"))
#    (Ident "Title"))
#   (RStrLit "New Title")))

I don't know exactly what programming language you are coming from, but I think it is either Go or Python since I see this preference for defensive imports from x import nil. They really don't go well with the Nim style of programming. These types of imports are usually only used from beginners in Nim who learned a different style of programming from experience in other languages.

In nim you should work with static overloading in mind. So if your argument type is from your own module, you can pick whatever name you want, it won't collide with anything from other modules.

If you only have arguments with types from system, you should make sure that the name is very specific. For example proc New*(title: string) is a bad name. Better include the name of the type that you want to create. I've modified your example into a more usual nim style and then also the problems go away. I hope it will help you.

# window.nim
type Window = distinct int
proc NewWindow*(title:string):Window =
  echo "> Create New Window With Title = " & $title
  return Window(1234567890)
proc Title*(self: Window, name:string) =
  echo "> Title Of window " & $int(self) & " Changed To " & $name
template Title*(self: Window):string =
  "< Title Of Window " & $int(self)

# test1.nim
import window
let main = NewWindow(r"Hello World")
Title(main, r"New Title")
echo Title(main)

# test2.nim
import window
let main = NewWindow(r"Hello World")
main.Title(r"New Title")
echo main.Title

After all, it is really about letting your guards down regarding the nonconservative import. I know this can be hard if other languages hammered into your brain that this is a really dangerous operation. Well in Nim it's not, it is the recommended way to work.

[bellthom]

Hi Arne,
my interpretation of your answer is, that the decribed NIM-behaviour is not a bug - it's 'works as designed'. So chapter https://nim-lang.org/docs/manual.html#templates-limitations-of-the-method-call-syntax of NIM's-documentation could be extended by ... methode call syntax ... is not possible for nested modules.

But finally it's your product, so feel free to do what ever you like and also to close this issue.

br, Thomas