Module

// calculator_module.dart
library calculator_module;

// Internal helper function
double _add(double a, double b) {
  return a + b;
}

// Internal helper function
double _subtract(double a, double b) {
  return a - b;
}

// Public API - the module's exposed interface
class CalculatorModule {
  double calculate(double a, double b, String operation) {
    switch (operation) {
      case 'add':
        return _add(a, b);
      case 'subtract':
        return _subtract(a, b);
      default:
        throw ArgumentError('Invalid operation');
    }
  }
}

object Calculator {

  private def add(x: Int, y: Int): Int =
    x + y

  private def subtract(x: Int, y: Int): Int =
    x - y

  def calculateSum(x: Int, y: Int): Int =
    add(x, y)

  def calculateDifference(x: Int, y: Int): Int =
    subtract(x, y)
}

// Example Usage:
object Main extends App {
  val sum = Calculator.calculateSum(5, 3)
  val difference = Calculator.calculateDifference(10, 4)
  println(s"Sum: $sum")
  println(s"Difference: $difference")
}

<?php
/**
 * Module Pattern Example in PHP
 */

$module = function() {
  // Private variables and functions
  $privateVariable = 'Secret Value';

  function privateFunction() {
    return 'This is a private function.';
  }

  // Public interface
  return [
    'getPrivateVariable' => function() use ($privateVariable) {
      return $privateVariable;
    },
    'publicFunction' => function() {
      return 'This is a public function that calls a private one: ' . privateFunction();
    },
  ];
};

// Usage
echo $module()['getPrivateVariable']() . "\n";
echo $module()['publicFunction']() . "\n";

// Attempting to access private parts directly will result in an error
// echo $module()['privateVariable']; // Fatal error: Uncaught Error: Call to undefined function
?>

# frozen_string_literal: true

module StringExtensions
  refine do
    def valid_email?(regex = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i)
      match?(regex)
    end
  end
end

String.include StringExtensions

# Example Usage:
puts "test@example.com".valid_email? # Output: true
puts "invalid-email".valid_email?    # Output: false
puts "another.test@sub.example.co.uk".valid_email? # Output: true

// Calculator.swift

public class Calculator {

    // Public API - methods exposed to other parts of the application
    public func add(_ a: Double, _ b: Double) -> Double {
        return performOperation(a, b, operation: +)
    }

    public func subtract(_ a: Double, _ b: Double) -> Double {
        return performOperation(a, b, operation: -)
    }

    public func multiply(_ a: Double, _ b: Double) -> Double {
        return performOperation(a, b, operation: *)
    }

    public func divide(_ a: Double, _ b: Double) -> Double {
        return performOperation(a, b, operation: /)
    }

    // Private helper function - internal implementation detail
    private func performOperation(_ a: Double, _ b: Double, operation: (Double, Double) -> Double) -> Double {
        // Add error handling or logging here if needed
        return operation(a, b)
    }
}

// OrderProcessor.kt

object OrderProcessor {
    private val items = mutableListOf<String>()

    fun addItem(item: String) {
        items.add(item)
    }

    fun getTotal(): Int {
        return items.size // Simplified total calculation for demonstration
    }

    fun processOrder(): String {
        if (items.isEmpty()) {
            return "Order is empty."
        }
        return "Processing order with ${items.joinToString(", ")}."
    }

    fun getItems(): List<String> {
        return items.toList() // Return a copy to prevent external modification
    }
}

fun main() {
    OrderProcessor.addItem("Shirt")
    OrderProcessor.addItem("Pants")
    println("Total items: ${OrderProcessor.getTotal()}")
    println(OrderProcessor.processOrder())
    println("Items in order: ${OrderProcessor.getItems()}")
}

// src/lib.rs

pub mod geometry {
    // Publicly available types and functions
    pub struct Rectangle {
        pub width: u32,
        pub height: u32,
    }

    impl Rectangle {
        pub fn area(&self) -> u32 {
            self.width * self.height
        }

        // Private function - only accessible within the geometry module
        fn is_square(&self) -> bool {
            self.width == self.height
        }

        pub fn new(width: u32, height: u32) -> Rectangle {
            Rectangle { width, height }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::geometry::Rectangle;

    #[test]
    fn test_rectangle_area() {
        let rect = Rectangle::new(5, 10);
        assert_eq!(rect.area(), 50);
    }

    #[test]
    fn test_is_square_access() {
        let rect = Rectangle::new(5, 5);
        // This would cause a compile error because is_square is private
        // assert_eq!(rect.is_square(), true);
    }
}

package main

import "fmt"

// State holds the internal state of the Originator.
type State struct {
	Value int
}

// Memento is an immutable snapshot of the Originator's state.
type Memento struct {
	State State
}

// Originator creates and manages its own state.
type Originator struct {
	currentState State
}

// NewOriginator creates a new Originator with an initial state.
func NewOriginator(initialValue int) *Originator {
	return &Originator{State{Value: initialValue}}
}

// SetValue changes the Originator's state.
func (o *Originator) SetValue(newValue int) {
	o.currentState.Value = newValue
}

// Value returns the current value of the originator.
func (o *Originator) Value() int {
	return o.currentState.Value
}

// Save creates a memento containing the current state.
func (o *Originator) Save() *Memento {
	return &Memento{State{Value: o.currentState.Value}}
}

// Restore sets the Originator's state to the one stored in the memento.
func (o *Originator) Restore(memento *Memento) {
	o.currentState = memento.State
}

func main() {
	originator := NewOriginator(10)
	fmt.Println("Initial value:", originator.Value())

	memento := originator.Save()

	originator.SetValue(20)
	fmt.Println("Value after change:", originator.Value())

	originator.Restore(memento)
	fmt.Println("Value after restore:", originator.Value())
}

// counter.h
#ifndef COUNTER_H
#define COUNTER_H

// Public interface
typedef struct Counter Counter;
Counter* counter_create();
void counter_increment(Counter* counter);
int counter_get_value(const Counter* counter);
void counter_destroy(Counter* counter);

#endif // COUNTER_H

// counter.c
#include "counter.h"
#include <stdlib.h>

struct Counter {
    int value;
    // Private data - not exposed in the header
};

Counter* counter_create() {
    Counter* counter = (Counter*)malloc(sizeof(Counter));
    if (counter != NULL) {
        counter->value = 0;
    }
    return counter;
}

void counter_increment(Counter* counter) {
    if (counter != NULL) {
        counter->value++;
    }
}

int counter_get_value(const Counter* counter) {
    if (counter != NULL) {
        return counter->value;
    }
    return -1; // Or some other error indicator
}

void counter_destroy(Counter* counter) {
    if (counter != NULL) {
        free(counter);
    }
}

// main.c (Example Usage)
#include <stdio.h>
#include "counter.h"

int main() {
    Counter* my_counter = counter_create();
    if (my_counter == NULL) {
        fprintf(stderr, "Failed to create counter\n");
        return 1;
    }

    counter_increment(my_counter);
    counter_increment(my_counter);

    printf("Counter value: %d\n", counter_get_value(my_counter));

    counter_destroy(my_counter);
    return 0;
}

// Math.h - Public Interface
#ifndef MATH_H
#define MATH_H

namespace Math {
  /**
   * @brief Calculates the factorial of a non-negative integer.
   *
   * @param n The input integer.
   * @return The factorial of n.  Returns 1 for n = 0.
   * @throws std::invalid_argument if n is negative.
   */
  int factorial(int n);
} // namespace Math

#endif // MATH_H

// Math.cpp - Private Implementation
#include "Math.h"
#include <stdexcept>

namespace Math {
  // Private helper function for factorial calculation
  static int factorialHelper(int n) {
    if (n == 0) {
      return 1;
    }
    return n * factorialHelper(n - 1);
  }

  int factorial(int n) {
    if (n < 0) {
      throw std::invalid_argument("Factorial is not defined for negative numbers.");
    }
    return factorialHelper(n);
  }
} // namespace Math

// main.cpp - Usage Example
#include <iostream>
#include "Math.h"

int main() {
  try {
    std::cout << "Factorial of 5: " << Math::factorial(5) << std::endl;
    std::cout << "Factorial of 0: " << Math::factorial(0) << std::endl;
    // std::cout << Math::factorialHelper(5) << std::endl; // This would cause a compile error
    std::cout << "Factorial of -1: ";
    Math::factorial(-1);
  } catch (const std::invalid_argument& e) {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Module.cs
public static class StringFormatter
{
    private const string DefaultSeparator = "-";

    public static string ToKebabCase(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return string.Empty;
        }

        var result = System.Text.RegularExpressions.Regex.Replace(input, "[^a-zA-Z0-9]", " ");
        result = string.Join(DefaultSeparator, result.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)).ToLower();
        return result;
    }

    public static string Truncate(string input, int maxLength)
    {
        if (string.IsNullOrEmpty(input) || input.Length <= maxLength)
        {
            return input;
        }

        return input.Substring(0, maxLength) + "...";
    }

    internal static string GetInternalConstant()
    {
        return DefaultSeparator;
    }
}

// counter.ts

const counterModule = (function() {
  let counter = 0;

  return {
    increment: function() {
      counter++;
    },
    getCount: function() {
      return counter;
    }
  };
})();

export default counterModule;

// gist-module.js

const myModule = (function() {
  // Private variables and functions
  let privateCounter = 0;

  function privateFunction() {
    privateCounter++;
    console.log("Private function called. Counter:", privateCounter);
  }

  // Public API (returned object)
  return {
    publicMethod: function(message) {
      console.log("Public method says:", message);
      privateFunction(); // Accessing private function
    },
    getCounter: function() {
      return privateCounter;
    },
    initialValue: 42 // Public property
  };
})();

// Usage
myModule.publicMethod("Hello from the outside!");
console.log("Counter value:", myModule.getCounter());
console.log("Initial value:", myModule.initialValue);
// Attempting to access privateCounter directly will result in undefined.

# math_operations.py

def _add(x, y):
    """Internal function for addition."""
    return x + y

def _subtract(x, y):
    """Internal function for subtraction."""
    return x - y

def calculate(operation, x, y):
    """Public interface for performing calculations."""
    if operation == "add":
        return _add(x, y)
    elif operation == "subtract":
        return _subtract(x, y)
    else:
        raise ValueError("Invalid operation")

if __name__ == '__main__':
    # Example usage
    result = calculate("add", 5, 3)
    print(f"5 + 3 = {result}")

    result = calculate("subtract", 10, 4)
    print(f"10 - 4 = {result}")

    try:
        result = calculate("multiply", 2, 6)
    except ValueError as e:
        print(e)

// api/MyModule.java
package com.example.mymodule.api;

public class MyModule {

    private final com.example.mymodule.internal.Implementation impl;

    public MyModule() {
        this.impl = new com.example.mymodule.internal.Implementation();
    }

    public String doSomething(String input) {
        return impl.internalLogic(input);
    }
}

// internal/Implementation.java
package com.example.mymodule.internal;

class Implementation {

    String internalLogic(String input) {
        return "Module processed: " + input;
    }
}

// Example Usage (in a separate file/module)
/*
package com.example.usermodule;

import com.example.mymodule.api.MyModule;

public class User {
    public static void main(String[] args) {
        MyModule module = new MyModule();
        System.out.println(module.doSomething("Hello"));
        // Cannot access Implementation directly
    }
}
*/