The fileutil package from tcllib has fullnormalize that handles all links in a path

package require fileutil
set ::APP_PATH [file dir [fileutil::fullnormalize [info script]]]

you might consider cd into the directory while loading resources:

set dir [pwd]
cd [file dir [fileutil::fullnormalize [info sript]]]
try {foreach fn {liba.tcl libb.tcl} {source $fn}} finally {cd $dir}

dave b

I read the docs for tm and they say "A Tcl Module is a Tcl Package contained in a single file, and no other files required by it". This seems a bit restrictive compared to the package approach. And anyway, I'm only really looking at how to spread an application over multiple files; all the tcl files are for the application, they're not self-contained as such.

I've now tried using modules and despite the docs it seems to work fine and requires one less file (no need for pkgIndex.tcl)

# file: myapp.tcl
tcl::tm::path add [file dirname [info script]]
package require app
app::main

# file: app-1.0.0.tm
package provide app 1.0
package require util
namespace eval app {}

proc app::main {} {
puts "app.tcl main [util::commas 1234567890]"
}

# file: util-1.0.0.tm
package provide util 1.0
namespace eval util {}

proc util::commas {x} {
regsub -all \\d(?=(\\d{3})+([regexp -inline {\.\d*$} $x]$)) $x {\0,}
}

At Thu, 1 Jun 2023 07:27:58 -0700 (PDT) Mark <m.n.summerfield@googlemail.com> wrote:

>

> I read the docs for tm and they say "A Tcl Module is a Tcl Package contained
> in a single file, and no other files required by it". This seems a bit
> restrictive compared to the package approach. And anyway, I'm only really
> looking at how to spread an application over multiple files; all the tcl
> files are for the application, they're not self-contained as such.

You can have a "master" .tm file, that source's any number of other files:

foo-1.2.3.tm:

set dir [file dirname [info script]]

source [file join $dir foo-a.tcl]
source [file join $dir foo-b.tcl]
source [file join $dir foo-c.tcl]

so

package require foo 1.2.3

will load foo-a.tcl, foo-b.tcl, and foo-c.tcl.

>
>

--
Robert Heller -- Cell: 413-658-7953 GV: 978-633-5364
Deepwoods Software -- Custom Software Services
http://www.deepsoft.com/ -- Linux Administration Services
heller@deepsoft.com -- Webhosting Services

* Mark <m.n.summerfield@googlemail.com>
| I've now tried using modules and despite the docs it seems to work
| fine and requires one less file (no need for pkgIndex.tcl)

Even better, thanks for sharing!

R'

Mark <m.n.summerfield@googlemail.com> wrote:
> I've now tried using modules and despite the docs it seems to work fine and requires one less file (no need for pkgIndex.tcl)
>
> # file: myapp.tcl
> tcl::tm::path add [file dirname [info script]]
> package require app
> app::main
>
> # file: app-1.0.0.tm
> package provide app 1.0
> package require util
> namespace eval app {}
>
> proc app::main {} {
> puts "app.tcl main [util::commas 1234567890]"
> }
>
> # file: util-1.0.0.tm
> package provide util 1.0
> namespace eval util {}
>
> proc util::commas {x} {
> regsub -all \\d(?=(\\d{3})+([regexp -inline {\.\d*$} $x]$)) $x {\0,}
> }

As I just learned from a post a few hours ago, you don't need the
"package provide" lines inside module (.tm) files. So you could drop
those lines as well.

And you do not /need/ to make the main 'app' a module file (unless you
really want to do so). The /secondary/ files can be modules, and the
main app just a script that loads the modules.

Thanks for the help.

So now I'm still only using 3 files but with even less boilerplate than before. And this is a nice scalable solution.

# file: myapp.tcl # this is the "driver" the user runs: ./myapp.tcl
tcl::tm::path add [file dirname [info script]]
package require app
app::main

# file: app-1.0.0.tm # this is the application module for main
package require util
namespace eval app {}

proc app::main {} {
puts "app-1.0.0.tm main [util::commas 1234567890]"
}

# file: util-1.0.0.tm # this is a supporting module
namespace eval util {}

proc util::commas {x} {
regsub -all \\d(?=(\\d{3})+([regexp -inline {\.\d*$} $x]$)) $x {\0,}
}

Although the above works fine, it causes nagelfar to complain:

$ nagelfar.tcl -quiet -H -tab 4 -len 76 -Wunusedvar *.{tcl,tm}
myapp.tcl: 8: W Unknown command "app::main"
app-1.0.0.tm: 9: W Unknown command "util::commas"

This is a "normal" warning. It can be safely ignored. nagelfar has no way of
"knowing" about procs defined in a file other than the one it is currently
processing.

At Thu, 1 Jun 2023 11:40:18 -0700 (PDT) Mark <m.n.summerfield@googlemail.com> wrote:

>
> Although the above works fine, it causes nagelfar to complain:
>
> $ nagelfar.tcl -quiet -H -tab 4 -len 76 -Wunusedvar *.{tcl,tm}
> myapp.tcl: 8: W Unknown command "app::main"
> app-1.0.0.tm: 9: W Unknown command "util::commas"
>
>

--
Robert Heller -- Cell: 413-658-7953 GV: 978-633-5364
Deepwoods Software -- Custom Software Services
http://www.deepsoft.com/ -- Linux Administration Services
heller@deepsoft.com -- Webhosting Services

El jueves, 1 de junio de 2023 a las 16:28:02 UTC+2, Mark escribió:
> I read the docs for tm and they say "A Tcl Module is a Tcl Package contained in a single file, and no other files required by it". This seems a bit restrictive compared to the package approach. And anyway, I'm only really looking at how to spread an application over multiple files; all the tcl files are for the application, they're not self-contained as such.

so what's the real difference between a package and a module in terms of use? it seems modules are just an evolution over packages intended to the same use.

After reading the replies in this thread (and without reading any doc), I have a doubt, if package provide is not required in a module, how tcl knows what names you want to export in the module? is it the case that all symbols defined in the module are public by default (and thus imported when you do a package require)?

pd <eukelade@gmail.com> wrote:
> El jueves, 1 de junio de 2023 a las 16:28:02 UTC+2, Mark escribió:
>> I read the docs for tm and they say "A Tcl Module is a Tcl Package
>> contained in a single file, and no other files required by it".
>> This seems a bit restrictive compared to the package approach. And
>> anyway, I'm only really looking at how to spread an application over
>> multiple files; all the tcl files are for the application, they're
>> not self-contained as such.
>
> so what's the real difference between a package and a module in terms
> of use?

Use?

By an end user: no difference (other than needing the tm::path setup
properly to find them -- which should be handled by the app. code).

By a creator: modules are slightly simpler to create, but offer
slightly less flexibility to the creator in the process.

Modules also potentially might be slightly faster to source on first
use, as they are a set of files in a directory, and the filenames
define the module names and versions so a single glob of a single
directory can retreive all the names and versions.

For packages, they are each in an individual directory, and the
pkgIndex.tcl in each has to be sourced to find the names and versions,
so finding packages involves a directory tree walk and sourcing of
potentially a lot of pkgIndex.tcl files.

> it seems modules are just an evolution over packages intended to the
> same use.

In effect, yes.

> After reading the replies in this thread (and without reading any
> doc), I have a doubt, if package provide is not required in a module,

After Shelte indicated this was so, I did a quick test. It is not
required in a module. Tcl picks up the version from the module
filename.

> how tcl knows what names you want to export in the module?

The same way as it knows for a package, by what you define in the
module file. If the module defines a namespace (and it should, to
avoid name collisions) then the names to be exported are the names
given to the namespace export command that should be part of the module
file.

> is it the case that all symbols defined in the module are public by
> default (and thus imported when you do a package require)?

No, importing expects a namespace, and importing requires that the
nameespace first export the names that should be 'importable'. I.e.,
as with globals in Tcl, namespace names are not normally importable
unless you specify them to be so.

On 6/2/2023 2:55 AM, pd wrote:
> El jueves, 1 de junio de 2023 a las 16:28:02 UTC+2, Mark escribió:
>> I read the docs for tm and they say "A Tcl Module is a Tcl Package contained in a single file, and no other files required by it". This seems a bit restrictive compared to the package approach. And anyway, I'm only really looking at how to spread an application over multiple files; all the tcl files are for the application, they're not self-contained as such.
>
> so what's the real difference between a package and a module in terms of use? it seems modules are just an evolution over packages intended to the same use.
>
> After reading the replies in this thread (and without reading any doc), I have a doubt, if package provide is not required in a module, how tcl knows what names you want to export in the module? is it the case that all symbols defined in the module are public by default (and thus imported when you do a package require)?

One can use a [package provide] command if one really
wants to, but it's not necessary. If used, it does add
a slight maintenance cost, since it will need to be
updated if/when a new version is added. It has to
agree with the version that the file name is encoded with.

Modules, like packages, are intended to be code that
forms a library where ordinarily more than one program
will be using the code. For example, the http package
is actually provided as a module. A module is simply
a lite weight package, that is pure tcl and can be
loaded via a source command.

One can use the *list* subcommand to find which of the
directories are built in searches similar to how the
global auto_path is setup. For example,

$ tclsh
% join [tcl::tm::path list] \n
/usr/lib/tcltk/tcl8/site-tcl
/usr/lib/tcltk/tcl8/8.0
/usr/lib/tcltk/tcl8/8.1
/usr/lib/tcltk/tcl8/8.2
/usr/lib/tcltk/tcl8/8.3
/usr/lib/tcltk/tcl8/8.4
/usr/lib/tcltk/tcl8/8.5
/usr/lib/tcltk/tcl8/8.6
/usr/lib/tcl8/site-tcl
/usr/lib/tcl8/8.0
/usr/lib/tcl8/8.1
/usr/lib/tcl8/8.2
/usr/lib/tcl8/8.3
/usr/lib/tcl8/8.4
/usr/lib/tcl8/8.5
/usr/lib/tcl8/8.6
/usr/share/tcltk/tcl8/site-tcl
/usr/share/tcltk/tcl8/8.0
/usr/share/tcltk/tcl8/8.1
/usr/share/tcltk/tcl8/8.2
/usr/share/tcltk/tcl8/8.3
/usr/share/tcltk/tcl8/8.4
/usr/share/tcltk/tcl8/8.5
/usr/share/tcltk/tcl8/8.6
/usr/share/tcltk/tcl8.6/tcl8

$ ls /usr/share/tcltk/tcl8.6/tcl8
http-2.9.0.tm msgcat-1.6.1.tm platform-1.0.14.tm tcltest-2.5.0.tm

So, if one wants to supply a module that does not
need a [tcl::tm::path add] one can place a module
into one of the *known* directories listed above.