-- import: <module-name>
You can do following imports:
- [Import `fastn`](import/#import-fastn)
- [Import module from current package](import/#import-module-from-current-package)
- [Import module from dependency package](import/#import-module-from-dependency-package)
- [Import special modules](import/#import-special-modules)
`ftd` also provides a way to define [import alias](import/#understanding-alias).
`fastn` provides a special module called `fastn`, which gives you access to
useful package-related variables. You must have noticed that `FASTN.ftd` imports
this module. To import the `fastn` module in your code, use the following
The special variables provided by this module are:
- document-name: Returns a string representing the current [document's
- package-name: Returns `string` representing the package name.
- home-url: Returns `string` representing the package's website address.
Import module from current package
Suppose you have a module called `bar.ftd` in your `fastn` package, named
`my-package`, and you want to import it in another module called `foo.ftd`. To
import the `bar` module in your `foo` module, use the following syntax:
-- import: my-package/bar
Import module from dependency package
Suppose you want to import the `bar` module from a dependency package called
`other-package` in `foo` module of your current package, `my-package`. To import
the bar module in your foo module, use the following syntax:
-- import: other-package/bar
Import special modules
The`fastn` package has a special module, `assets` importing which you get access
to its variables. These variables contains the reference to the files or fonts
defined in the package.
-- import: my-package/assets
The file referring variables are [foreign variables](foreign-variable), while,
fonts are simple variable.
For more information, please visit [assets](assets).
In `ftd`, an alias is an alternative name that can be used to refer to an
imported module. Aliases can be helpful in making the code more concise and
To define an alias in ftd, we can use the as keyword when importing a module.
For example, to create an alias `mn` for a module called `module-name`, we can
-- import: module-name as alias
This allows us to refer to the imported module as `mn` instead of `module-name`.
`ftd` defined alias
`ftd` also defines aliases by itself, when we import a module without specifying
an alias using the `as` keyword. In this case, the word after the last slash in
the module path becomes the alias. For example:
-- import: some/path/to/module
In this case, the alias would be `module`.
Advantages of Aliases
Aliases can be helpful in several ways:
- **Abbreviation**: Aliases can be used to create shorter or more concise names
commonly used or long entities.
- **Code readability**: Aliases can make code more readable and understandable
by giving names to modules that more clearly convey their purpose or meaning.
- **Refactoring**: When refactoring code, like changing the dependencies or
imported modules. Aliases can be used to keep the original names in use while
the code is being updated to use the new names, so the code continues to work
while changes are being made.
- **Reducing name collisions**: Aliases can help avoid naming collisions when
importing multiple modules with similar or identical names.
- **Compatibility**: Aliases can be used to maintain compatibility with legacy
code or other systems that refer to entities by different names. This can make
it easier to integrate with external packages or modules that use different
Overall, aliases can help improve the clarity, readability, and maintainability
of code, while also making it more efficient to write and easier to integrate
with other systems.