PureBasic Forums - English

Little John wrote:That would probably cause more confusion than it's worth.

Regenduft wrote:I think it would be nice to implement a keyword, which can be used in the DeclareModule section to hide stuff when importing the module by UseModule.

Regenduft wrote:

Little John wrote:That would probably cause more confusion than it's worth.

What kind of confusion could there be? (no rhetorical question)

Imho, these are the two styles that are useful with Modules
- give descriptive names that stand on their own, use UseModule and only write the full name to avoid (rare) conflicts
- give shorter names for simplicity inside the module and write the full name outside to keep the meaning of the call clear

Little John wrote:[1]Your suggestion would encourage people to mix both styles[/1], and [4] this would decrease the readability of the code.[/4] [2]Additionally, new users might e.g. erroneously think that "Hide" also applies if the full name with :: is used[/2]. [4]Let's not make things unnecessary unclear. Better keep it simple and straightforward.[/4]

[3]And for example something like Init() is normally best called inside the Module part, and not at all in the DeclareModule part.[/3] [4]The purpose of the new Modules is to help us write cleaner code. So we better should do so, rather than asking for new ways to write less clean or clear code.[/4]

1. I agree. That's the major point: I think it would ease the creation of reusable templates.
2. Yes, your are right that "Hide" is a stupid keyword. But in my humble opinion "confusing" new users is not a good argument, since you find a lot of notes in the PureBasic documentation stating "only for experienced users". If you would not understand the keyword or don't like it, your don't have to use it. The first error message or a look into the auto complete suggestions would make things clear, when getting lost.
3. Thinking of commands like "InitKeyboard()", I would say this is not necessarily true.
4. Now I'm confused. I think, that it would actually increase readability, it is more straightforward and it would add some flexibility. The introduction of the new keyword would not really bring a new feature. You can do it right now, too. But with a lot of "crazy" code! Read beyond for some examples.

DeclareModule UseFoo
  Macro DoSomething_()
    Foo::DoSomething()
  EndMacro
EndDeclareModule
DeclareModule Foo
  #Version = "1.0"
  Declare.s Init()
  Declare.s DoSomething()
EndDeclareModule

Module UseFoo
  ; void
EndModule
Module Foo
  Procedure.s Init()
    ProcedureReturn "initializing"
  EndProcedure
  Procedure.s DoSomething()
    ProcedureReturn "doing something"
  EndProcedure
EndModule

UseModule UseFoo

Debug Foo::#Version
Debug Foo::Init()
Debug DoSomething_()

DeclareModule UseFoo
  Declare.s DoSomething()
EndDeclareModule
DeclareModule Foo
  #Version = "1.0"
  Declare.s Init()
  Declare.s DoSomething()
EndDeclareModule

Module UseFoo
  Procedure.s DoSomething()
    ProcedureReturn Foo::DoSomething()
  EndProcedure
EndModule
Module Foo
  Procedure.s Init()
    ProcedureReturn "initializing"
  EndProcedure
  Procedure.s DoSomething()
    ProcedureReturn "doing something"
  EndProcedure
EndModule

UseModule UseFoo

Debug Foo::#Version
Debug Foo::Init()
Debug DoSomething()

DeclareModule UseFoo
  Prototype.s DoSomething()
  Define DoSomething.DoSomething
EndDeclareModule
DeclareModule Foo
  #Version = "1.0"
  Declare.s Init()
  Declare.s DoSomething()
EndDeclareModule

Module UseFoo
  Define ProtoInit
  If ProtoInit = 0
    DoSomething = Foo::@DoSomething()
  EndIf
EndModule
Module Foo
  Procedure.s Init()
    ProcedureReturn "initializing"
  EndProcedure
  Procedure.s DoSomething()
    ProcedureReturn "doing something"
  EndProcedure
EndModule

UseModule UseFoo

Debug Foo::#Version
Debug Foo::Init()
Debug DoSomething()