Modules & Packages: Defining and Importing

# One file is one module (§16.1). `pub` exports a sub across the
# module boundary; a plain `sub` stays private to the module.
pub sub area($radius: Float): Float {
    pi() * square($radius)
}

# Private to this module: an importer cannot call these (compile-time
# error), but area() - in the same module - still can.
sub square($x: Float): Float { $x * $x }
sub pi(): Float { 3.14159 }

sub main() {
    # Same module, so call directly. From another module you would
    # `import geometry::circle` and call `circle::area(2.0)`.
    $a = area(2.0)
    print("circle area: $a")
}

// geometry/circle.go
package geometry

// Exported: an uppercase initial makes Area visible to importers.
func Area(radius float64) float64 {
	return pi() * square(radius)
}

// Unexported: a lowercase initial keeps these package-private.
func square(x float64) float64 { return x * x }
func pi() float64            { return 3.14159 }

// main.go
package main

import (
	"fmt"

	"example.com/app/geometry"
)

func main() {
	a := geometry.Area(2.0)
	fmt.Printf("circle area: %v\n", a)
}

(* circle.ml - a .ml file is automatically a module named Circle. *)
let area radius = pi () *. square radius
and square x = x *. x
and pi () = 3.14159

(* circle.mli - the interface lists what the module exports.
   Only `area` is named here, so `square` and `pi` stay hidden. *)
val area : float -> float

(* main.ml *)
let () =
  let a = Circle.area 2.0 in
  Printf.printf "circle area: %f\n" a

-- Circle.hs - one file is one module; the export list is the public face.
module Circle (area) where

-- Only `area` is listed above, so `square` and `pit` stay module-private:
-- importing or calling them from elsewhere is a compile-time error.
area :: Double -> Double
area radius = pit * square radius

square :: Double -> Double
square x = x * x

pit :: Double
pit = 3.14159

-- Main.hs --------------------------------------------------
module Main where

import Circle (area)

main :: IO ()
main = putStrLn ("circle area: " ++ show (area 2.0))

# Geometry/Circle.pm - a package in a file matching its name.
package Geometry::Circle;
use strict;
use warnings;
use Exporter 'import';

# @EXPORT_OK is the module's public face: names a caller may request.
our @EXPORT_OK = qw(area);

use constant PI => 3.14159;

sub area  { my ($r) = @_; PI * _square($r) }

# A leading underscore is the convention for "private"; not exported.
sub _square { my ($x) = @_; $x * $x }

1;  # a module must end with a true value

# --- main.pl -----------------------------------------------
use strict;
use warnings;
use lib '.';                    # find modules under the current dir
use Geometry::Circle qw(area);  # import the requested name

my $a = area(2.0);
print "circle area: $a\n";

# Geometry/Circle.rakumod - a module file.
unit module Geometry::Circle;

# `is export` marks a routine as part of the public interface.
sub area($radius) is export {
    pi-of() * square($radius)
}

# No `is export`: visible only inside the module.
sub square($x) { $x * $x }
sub pi-of()    { 3.14159 }

# --- main.raku ---------------------------------------------
use lib '.';
use Geometry::Circle;

my $a = area(2.0);
say "circle area: $a";

// circle.rs - a file is a module; `pub` exports an item.
pub fn area(radius: f64) -> f64 {
    pi() * square(radius)
}

// No `pub`: private to this module.
fn square(x: f64) -> f64 { x * x }
fn pi() -> f64 { 3.14159 }

// main.rs
mod circle; // declare the circle module (loads circle.rs)

fn main() {
    let a = circle::area(2.0);
    println!("circle area: {a}");
}

# geometry/circle.py - a module is a .py file; a package is a directory
# (here geometry/ with an __init__.py).
import math

# Public by convention: a plain name is importable.
def area(radius: float) -> float:
    return math.pi * _square(radius)

# A leading underscore marks a name "private" by convention; it is not
# enforced, but `from circle import *` skips it.
def _square(x: float) -> float:
    return x * x

# --- main.py -----------------------------------------------
from geometry import circle

def main() -> None:
    a = circle.area(2.0)
    print(f"circle area: {a}")

if __name__ == "__main__":
    main()