Skip to content

bkuhlmann/functionable

BranchesTags

Repository files navigation

Functionable

Enhances modules to be functional by disabling the ability to extend, include, or prepend while also ensuring all methods are class methods. This allows you to use a module as a functional collection of related methods for reuse throughout your application via composition instead of inheritance. In other words, this is an enhanced version of module_function by preventing inheritance and reducing the memory overhead due to making copies of the original methods.

Table of Contents

Features

  • Allows modules to be a collection of functional methods.

  • Allows your modules and/or methods to be composable instead of inherited.

  • Provides faster performance and a reduced memory than any object within your application. See the Benchmarks section for details.

Requirements

  1. Ruby.

  2. A solid understanding Ruby Modules.

Setup

To install with security, run:

# 💡 Skip this line if you already have the public certificate installed.
gem cert --add <(curl --compressed --location https://alchemists.io/gems.pem)
gem install functionable --trust-policy HighSecurity

To install without security, run:

gem install functionable

You can also add the gem directly to your project:

bundle add functionable

Once the gem is installed, you only need to require it:

require "functionable"

Usage

Enhancing your module to be functional is as simple as extending your module:

module Math
  extend Functionable

  def add(first, second) = first + second

  def subtract(first, second) = first - second

  def multiply(first, second) = first * second

  def divide(first, second) = first / second
end

Math.add 6, 3       # 9
Math.subtract 6, 3  # 3
Math.multiply 6, 3  # 18
Math.divide 6, 3    # 2

That’s it! Now you can add related methods, as desired, which are specific to your namespace.

Conceal

Should you need to make any of your methods private, use the conceal method as follows:

module Demo
  extend Functionable

  def welcome(*) = print(*)

  def print(message = "The default message.") = puts message

  conceal :print
end

Demo.welcome  # "The default message."
Demo.print    # private method 'print' called for module Demo (NoMethodError)

The conceal method takes the same parameters as the private_class_method which means you can use a string, symbol, a single argument, multiple arguments, or an array.

Avoidances

Functional modules are only meant to be a collection of related methods which allows you to namespace your behavior, compose multiple methods together, and use composition to inject your module as a dependency within objects that need this functionality.

This means the following behavior is disabled (each uses an anonymous module and/or class for demonstration purposes and reduced syntax).

Extend

Use composition instead of inheritance:

functions = Module.new.extend Functionable
Class.new.extend functions

# Module extend is disabled. (NoMethodError)

Include

Use composition instead of inheritance:

functions = Module.new.extend Functionable
Class.new.include functions

# Module include is disabled. (NoMethodError)

You also can’t include Funtionable, only extend:

Module.new.include Functionable
# Module include is disabled, use extend instead. (NoMethodError)

Prepend

Use composition instead of inheritance:

functions = Module.new.extend Functionable
Class.new.prepend functions

# Module prepend is disabled. (NoMethodError)

You also can’t prepend, only extend:

Module.new.prepend Functionable
# Module prepend is disabled, use extend instead. (NoMethodError)

Module Function

The following is not allowed because you have this behavior when extending Functionable:

Module.new do
  extend Functionable

  module_function
end

# Module function behavior is disabled. (NoMethodError)

Public

Avoid the following since all methods are public by default:

Module.new do
  extend Functionable

  public

  def demo = :demo
end

# Public visibility is disabled. (NoMethodError)

Protected

Avoid the following since a functionable module isn’t mean to be inherited:

Module.new do
  extend Functionable

  protected

  def demo = :demo
end

# Protected visibility is disabled. (NoMethodError)

Private

Avoid the following by using conceal instead:

Module.new do
  extend Functionable

  private

  def demo = :demo
end

# Private visibility is disabled, use conceal instead. (NoMethodError)

Aliasing

Avoid aliasing as you are not meant to inherit methods within a functional module:

Module.new do
  extend Functionable

  def demo = :demo
  alias_method :demo, :alt
end

# Aliasing :alt as :demo is disabled. (NoMethodError)

Class Variables

Avoid using class variables since they are a code smell and introduce unwanted state:

demo = Module.new do
  extend Functionable

  def get = class_variable_get :@@bogus

  def set = class_variable_set :@@bogus, :bogus
end

demo.get  # Getting class variable :@@bogus is disabled. (NoMethodError)
demo.set  # Setting class variable :@@bogus is disabled. (NoMethodError)

Class Methods

Avoid class methods, use instance methods instead:

Module.new do
  extend Functionable

  def self.bogus = :bogus
end

# Avoid defining :bogus as a class method because the method will be automatically converted to a class method for you. (NoMethodError)

Constants

Avoid dynamically setting constants since you can add constants directly to the top of the module:

demo = Module.new do
  extend Functionable

  def bogus = const_set :BOGUS, :bogus
end

demo.bogus  # Setting constant :BOGUS is disabled. (NoMethodError)

Define Method

Avoid dynamically defining a method since you can explicitly define your method instead:

Module.new do
  extend Functionable

  define_method :bogus, :bogus
end

# Defining method :bogus is disabled. (NoMethodError)

Remove Method

Avoid dynamically removing a method since you can explicitly delete the method instead.

Module.new do
  extend Functionable

  remove_method :bogus
end

# Removing method :bogus is disabled. (NoMethodError)

Undef Method

Avoid dynamically undefining a method since you can explicitly delete the method instead.

Module.new do
  extend Functionable

  undef_method :bogus
end

# Undefining method :bogus is disabled. (NoMethodError)

Benchmarks

When you lean into the power of functional programming in Ruby, you gain performance and lower your memory footprint since you are creating the minimal amount of objects necessary. In terms of CPU performance, here’s a benchmark script (see bin/benchmark included in this project):

#! /usr/bin/env ruby
# frozen_string_literal: true

require "bundler/inline"

gemfile true do
  source "https://rubygems.org"

  gem "benchmark-ips"
  gem "functionable", path: ".."
end

module ModuleSelf
  extend self

  def call(message = "benchmark") = message
end

module ModuleFunction
  module_function

  def call(message = "benchmark") = message
end

module ModuleFunctionable
  extend Functionable

  def call(message = "benchmark") = message
end

class ClassFunction
  def initialize message = "benchmark"
    @message = message
  end

  def call = message

  private

  attr_reader :message
end

proc_function = proc { |message = "message"| message }
lambda_function = -> message = "benchmark" { message }
memoized_instance = ClassFunction.new
memoized_method = memoized_instance.method :call

Benchmark.ips do |benchmark|
  benchmark.config time: 5, warmup: 2

  benchmark.report("Proc") { proc_function.call }
  benchmark.report("Lambda") { lambda_function.call }
  benchmark.report("Module (function)") { ModuleFunction.call }
  benchmark.report("Module (functionable)") { ModuleFunctionable.call }
  benchmark.report("Module (self)") { ModuleSelf.call }
  benchmark.report("Class (new)") { ClassFunction.new.call }
  benchmark.report("Class (memoized)") { memoized_instance.call }
  benchmark.report("Method (new)") { memoized_instance.method(:call).call }
  benchmark.report("Method (memoized)") { memoized_method.call }

  benchmark.compare!
end

When you run the above benchmark, you should see the following results:

ruby 4.0.1 (2026-01-13 revision e04267a14b) +YJIT +PRISM [arm64-darwin25.2.0]
Warming up --------------------------------------
                Proc     2.275M i/100ms
              Lambda     2.212M i/100ms
   Module (function)     4.654M i/100ms
Module (functionable)
                         4.682M i/100ms
       Module (self)     4.567M i/100ms
         Class (new)     2.359M i/100ms
    Class (memoized)     4.536M i/100ms
        Method (new)     1.176M i/100ms
   Method (memoized)     2.173M i/100ms
Calculating -------------------------------------
                Proc     23.976M (± 0.1%) i/s   (41.71 ns/i) -    120.575M in   5.029071s
              Lambda     24.414M (± 0.2%) i/s   (40.96 ns/i) -    123.885M in   5.074316s
   Module (function)     61.028M (± 0.7%) i/s   (16.39 ns/i) -    307.154M in   5.033292s
Module (functionable)
                         60.864M (± 0.5%) i/s   (16.43 ns/i) -    304.327M in   5.000243s
       Module (self)     60.261M (± 0.6%) i/s   (16.59 ns/i) -    301.446M in   5.002511s
         Class (new)     28.202M (± 8.2%) i/s   (35.46 ns/i) -    141.526M in   5.048420s
    Class (memoized)     57.157M (± 1.0%) i/s   (17.50 ns/i) -    285.794M in   5.000639s
        Method (new)     13.265M (± 9.7%) i/s   (75.39 ns/i) -     65.847M in   5.012654s
   Method (memoized)     24.390M (± 0.2%) i/s   (41.00 ns/i) -    123.861M in   5.078408s

Comparison:
   Module (function): 61027866.3 i/s
Module (functionable): 60864191.4 i/s - same-ish: difference falls within error
       Module (self): 60261194.0 i/s - same-ish: difference falls within error
    Class (memoized): 57156588.3 i/s - 1.07x  slower
         Class (new): 28201872.3 i/s - 2.16x  slower
              Lambda: 24414262.5 i/s - 2.50x  slower
   Method (memoized): 24389728.5 i/s - 2.50x  slower
                Proc: 23975703.7 i/s - 2.55x  slower
        Method (new): 13264797.8 i/s - 4.60x  slower

As you can see, a functional module is one of the fastest while everything else is much slower.

Development

To contribute, run:

git clone https://github.com/bkuhlmann/functionable
cd functionable
bin/setup

You can also use the IRB console for direct access to all objects:

bin/console

Tests

To test, run:

bin/rake

Credits

About

Enhances modules to be functional by default.

alchemists.io/projects/functionable

Topics

functional-programming functions composition

Resources

Readme

License

View license
Activity

Stars

3 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

4 tags

Sponsor this project

 
Learn more about GitHub Sponsors

Packages

 
 
 

Contributors

Languages