Rosetta stone of module syntaxes across languages

kornel · 2017-02-21 15:24:49 UTC

I’m trying to compare how packages and modules are declared and defined in programming languages.

The task is:

if you have a package/crate/project called “pkg”, define a module/namespace “foo”, in a standalone file used only for that module, containing a function “bar”.
use the module within the same package (so that foo.bar()/foo::bar() is callable)
use the module from a completely different package (so that foo.bar()/foo::bar() from “pkg” is callable).

How would you organize this? I’ve tried to come up with syntax used in various languages:

gist.github.com

https://gist.github.com/pornel/0f7ebcec230117ab52c959fe0b090335#file-modules-md

imports.md


Language    | Adding files from filesystem to the build | How? | Unfinished files break the program?
--- | --- | --- | ---
Rust        | Explicit `mod`     | declaration | No
CommonJS    | Explicit `require` | import | No
ES6         | Explicit `import`  | import | No
Python      | Explicit `import`  | import | No
Lua (new)   | Explicit `require` | import | No
PHP         | Explicit `require` or use via autoload | import or any use | No
Perl        | Explicit `use`     | import | No

This file has been truncated. show original

modules.md

Language    | Declarations of existence in the parent module | Declarations in the module itself | Use of the module in the same package | Use of the module from another package | Notes
--- | ---  | ---  | ---  | ---  | ---
Rust        | `mod foo;` or<br>`pub mod foo;` | `pub fn bar(){}`                  | `mod foo;` or<br>`use foo;`                    | `extern crate pkg;`<br>`use pkg::foo;` |
CommonJS    | *none*                  | `exports.bar = function(){}`              | `const foo = require('./foo');`                | `const foo = require('pkg/foo');`  |
ES6         | *none*                  | `export function bar(){}`                 | `import foo from './foo';`                     | `import foo from 'pkg/foo';`       |
Python      | *none*                  | `def bar():`<br>`  pass`                  | `import foo`                                   | `from pkg import foo`               |
Lua (new)   | *none*                  | `local foo = {}`<br>`function foo.bar()`<br>`end`<br>`return foo` | `local foo = require "foo"` | `local foo = require "foo"`   |
PHP         | *none*                  | `namespace Pkg\Foo;`<br>`function bar() {}` | `use Pkg\Foo;`                               | `use Pkg\Foo;`                     |
Perl        | *none*                  | `package Pkg::Foo;`<br>`sub bar {}`       | `use Pkg::Foo;`                                | `use Pkg::Foo;`                    |
D           | *none*                  | `module pkg.foo; void bar(){}`            | `import pkg.foo;`                              | `import pkg.foo;`                  |

This file has been truncated. show original

^ please view the table in the gist, since Discourse doesn’t support table markup

Please correct me if I got any languages wrong. Feel free to suggest syntax for other languages.

carols10cents · 2017-02-21 16:27:39 UTC

So I went to look to see if this is on Rosetta Code, but either they’re describing this concept in different words or I missed it

I found these similar tasks, I’m not sure if this is helpful or not:

If what you’re describing indeed doesn’t exist, I think you should add it as a new task on Rosetta Code!!

ExpHP · 2017-02-22 00:32:08 UTC

Judging from the Rust, CommonJS, and ES6 examples, I gather that the “Use of the module across packages” column is supposed to bring the module into scope under the name “foo”? Then the Python example should be from pkg import foo.

The posted example makes bar available under pkg.foo.bar. Surprisingly, there are in fact cases where import pkg does not accomplish this same feat (namely, when pkg doesn’t import foo, or imports it under another name).

Haskell:

No declarations in the parent module (not counting the extremely long and delicate lists of modules that you have to constantly maintain for their build system, cabal).

Syntax inside the module:

module Pkg.Foo(bar) where

bar :: ()
bar = ()

Importing from within or from, er… not within a package:

import qualified Pkg.Foo as Foo

(I just noticed how unrelated the words “within” and “without” are, and I’ve spoken this language my entire life.)

kornel · 2017-02-26 12:46:43 UTC

Thanks for help.

I’ve added a second table with how and when modules are compiled/added to the build.

I’ve noticed that Java-as-the-language may be different than Java-as-managed-by-IDE.