Learn full-stack web development using fastn in a week
Learn Now


In fastn, one module/component can access code from another component by importing it. To import a module, use the following syntax:
use of import
-- import: <module-name>

Import fastn

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 syntax:
import fastn
-- import: fastn
The special variables provided by this module are:
  • document-name: Returns a string representing the current document's name.
  • 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:
In foo.ftd
-- 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:
In foo.ftd
-- import: other-package/bar

Import special modules

Thefastn 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 assets
-- import: my-package/assets

The file referring variables are foreign variables, while, fonts are simple variable.

For more information, please visit assets.

Understanding Alias

In fastn, 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 readable.

Defining Alias

To define an alias in fastn, 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 write:
-- import: module-name as mn
This allows us to refer to the imported module as mn instead of module-name.

fastn defined alias

fastn 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 for 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 naming conventions.

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.