Modules and Extensions

Ziv's modular system is designed to promote code reusability and maintainability. This section covers how to create, import, and extend modules in Ziv.

Modules
Extensions

Modules

Ziv's modular system is designed to promote code reusability and maintainability. This section covers how to create, import, and extend modules in Ziv.

A module is a collection of functions, types, and variables that can be imported and used in other files. To create a module, you need to define a file with the .ziv extension and declare the module using the module keyword.

Here is an example of a simple module for mathematical operations:

# math.ziv

module math

fn add(a: int, b: int) -> int:
    return a + b

fn subtract(a: int, b: int) -> int:
    return a - b

end module

In this example, we define a module called math that contains two functions: add and subtract. These functions can be imported and used in other files.

Exporting and Importing Modules

By default, all functions, types, and variables defined in a module are public and can be accessed from other files. To import a module, you can use the import keyword followed by the module name.

If you want to restrict access to certain functions, types, or variables, you can use the private keyword to mark them as private.

private fn multiply(a: int, b: int) -> int:
    return a * b

Here is an example of importing the math module and using its functions:

# main.ziv

import math

fn main() -> void:
    result: int = math.add(1, 2)
    print(result)  # Output: 3

In this example, we import the math module and use its add function to add two numbers.

Importing Specific Functions

If you only need to import specific functions, types, or variables from a module, you can use the from keyword followed by the module name and the functions you want to import.

from math import add, subtract

Or you can import a specific function and rename it using the as keyword:

import math.add as sum

Creating Libraries

You can organize related modules into a library by creating a directory with the library name and placing the module files inside it. To import a module from a library, you can use the library name followed by the module name.

lib/
  math/
    math.ziv
  string/
    string.ziv

# string/string.ziv

module lib.string

fn capitalize(s: string) -> string:
    return s.capitalize()

end module

# main.ziv

import lib.string

fn main():
    result: string = lib.string.capitalize("hello")
    print(result)  # Output: Hello

In this example, we create a library with two modules: math and string. We import the string module from the library and use its capitalize function to capitalize a string.

Extensions

Extensions allow you to add new functionality to existing types without modifying their source code. This is useful when you want to extend the behavior of a type defined in a library or module.

Creating an Extension

To create an extension, you need to define a file with the .ziv extension and declare the extension using the extension keyword followed by the type you want to extend.

Here is an example of extending the string type with a new method:

# string_extension.ziv

extension string

fn uppercase() -> string:
    return self.upper()

end extension

In this example, we define an extension for the string type that adds a capitalize method to capitalize the string.

Importing Extensions

To use an extension, you need to import it in the file where you want to extend the type. You can import an extension using the import keyword followed by the extension file name.

# main.ziv

import string_extension

fn main():
    s: string = "hello"
    result: string = s.uppercase()
    print(result)  # Output: HELLO

In this example, we import the string_extension extension and use the uppercase method to convert a string to uppercase.

Extension Methods

Extension methods can access the properties and methods of the extended type using the self keyword. You can define extension methods for any type, including built-in types, user-defined types, and library types.


extension int

fn is_even() -> bool:
    return self % 2 == 0

end extension

In this example, we define an extension for the int type that adds an is_even method to check if the integer is even.

import int_extension

fn main():
    n: int = 10
    result: bool = n.is_even()
    print(result)  # Output: true

The Ziv Programming Language