smullyan 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc72b10962093f30311be948daf19e7fd1d4d4326109ea4648f3f2d7da9a2221
-  data.tar.gz: 666b61abefb823b327391786d60ccbe150c7e3328b5235f52cfb75318a472387
+  metadata.gz: 5c03c1b73d0e4b82d767b8edcff5cdd4b3746b8f25f0584095826c12aede049e
+  data.tar.gz: 1e760c61bd407b69b4f283ecee9aa468c107964fef7d97d72734a8ec298e9ba3
 SHA512:
-  metadata.gz: 5ca24e8d12f163e6d118d66bd7b4e85c8a1eada06b8cb99076ec1c1479cbc098456932e0b7350d197cbd407af726509057aba6d438ceba801fcc08bfa9b636dc
-  data.tar.gz: e8bfe5eb34b6d3e6affc0c79fde8937c8625dc7a60a9884997b220ecc46173518a725f070678eb6a792cee3ced000c40cffc90a7f33db083974314311c7898ad
+  metadata.gz: f90e78e8f5bb3cdf6293fc09ec9062ae52a36992e656de9b66606e92a260bc7a8462e6d55fefb85e3e77192b73d6d8fa846645ce11fab1b849f8cb6e4234f2aa
+  data.tar.gz: d59cc2c3de4d99b1216005319855bc926580bc3d50045a6a4e9983d543d8529b050515bdd83ee230ca2c7927440fb9182d4365dd3c4e5c3d5497a70665733e04

data/README.md

@@ -23,7 +23,7 @@ Or install it yourself as:
 ```ruby
 require 'smullyan'
 
-# Using the classic SKI combinators
+# Using SKI combinator names
 s = Smullyan::Birds::S
 k = Smullyan::Birds::K  
 i = Smullyan::Birds::I
@@ -64,4 +64,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/philcr
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb", "test/**/test_*.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb', 'test/**/test_*.rb']
 end
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 
-task default: %i[test rubocop]
+task default: %i[test rubocop]

data/benchmark/combinators_benchmark.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require_relative '../lib/smullyan'
+
+# Test functions
+identity = ->(x) { x }
+double = ->(x) { x * 2 }
+add_one = ->(x) { x + 1 }
+const_forty_two = ->(_x) { 42 }
+
+puts 'Benchmarking Combinator Implementations'
+puts '=' * 50
+puts
+
+# NOTE: I combinator doesn't have a direct implementation since it's already minimal
+
+# Benchmark B combinator
+puts 'B combinator (Bluebird - composition):'
+Benchmark.ips do |x|
+  x.report('B (derived)') do
+    Smullyan::Birds::B.call(double).call(add_one).call(5)
+  end
+
+  x.report('B_direct') do
+    Smullyan::Birds::B_direct.call(double).call(add_one).call(5)
+  end
+
+  x.compare!
+end
+puts
+
+# Benchmark C combinator
+puts 'C combinator (Cardinal - flip):'
+Benchmark.ips do |x|
+  subtract = ->(x) { ->(y) { x - y } }
+
+  x.report('C (derived)') do
+    Smullyan::Birds::C.call(subtract).call(10).call(3)
+  end
+
+  x.report('C_direct') do
+    Smullyan::Birds::C_direct.call(subtract).call(10).call(3)
+  end
+
+  x.compare!
+end
+puts
+
+# Benchmark W combinator
+puts 'W combinator (Warbler - duplication):'
+Benchmark.ips do |x|
+  # W needs a function that can take itself as argument
+  pair = ->(x) { ->(y) { [x, y] } }
+
+  x.report('W (derived)') do
+    Smullyan::Birds::W.call(pair).call(21)
+  end
+
+  x.report('W_direct') do
+    Smullyan::Birds::W_direct.call(pair).call(21)
+  end
+
+  x.compare!
+end
+puts
+
+# Benchmark M combinator
+puts 'M combinator (Mockingbird - self-application):'
+Benchmark.ips do |x|
+  x.report('M (derived)') do
+    Smullyan::Birds::M.call(const_forty_two)
+  end
+
+  x.report('M_direct') do
+    Smullyan::Birds::M_direct.call(const_forty_two)
+  end
+
+  x.compare!
+end
+puts
+
+# Benchmark L combinator
+puts 'L combinator (Lark):'
+Benchmark.ips do |x|
+  x.report('L (derived)') do
+    Smullyan::Birds::L.call(identity).call(const_forty_two)
+  end
+
+  x.report('L_direct') do
+    Smullyan::Birds::L_direct.call(identity).call(const_forty_two)
+  end
+
+  x.compare!
+end
+puts
+
+# Complex composition benchmark
+puts 'Complex composition (B B B pattern):'
+Benchmark.ips do |x|
+  triple = ->(x) { x * 3 }
+
+  x.report('B (derived) composed') do
+    b = Smullyan::Birds::B
+    b.call(b.call(triple).call(double)).call(add_one).call(2)
+  end
+
+  x.report('B_direct composed') do
+    b = Smullyan::Birds::B_direct
+    b.call(b.call(triple).call(double)).call(add_one).call(2)
+  end
+
+  x.compare!
+end
+puts
+
+# Y combinator benchmark (careful - recursive!)
+# Note: Y and Z don't have separate direct implementations since they're already optimized for Ruby
+puts 'Y combinator (limited recursion):'
+Benchmark.ips do |x|
+  # Simple recursive function that terminates quickly
+  sum_to_n = ->(f) { ->(n) { n <= 0 ? 0 : n + f.call(n - 1) } }
+
+  x.report('Y combinator') do
+    Smullyan::Birds::Y.call(sum_to_n).call(10)
+  end
+
+  x.report('Z combinator') do
+    Smullyan::Birds::Z.call(sum_to_n).call(10)
+  end
+
+  x.compare!
+end

data/benchmark/configurable_benchmark.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require_relative '../lib/smullyan'
+
+# Test functions
+identity = ->(x) { x }
+double = ->(x) { x * 2 }
+add_one = ->(x) { x + 1 }
+const_forty_two = ->(_x) { 42 }
+
+puts 'Benchmarking Configurable Combinator Implementations'
+puts '=' * 50
+puts
+
+# Benchmark B combinator with configuration switching
+puts 'B combinator (Bluebird - composition) via ConfigurableBirds:'
+Benchmark.ips do |x|
+  # Reset to derived
+  Smullyan.configuration.use_direct(:b, value: false)
+
+  x.report('B (config: derived)') do
+    Smullyan::ConfigurableBirds.B.call(double).call(add_one).call(5)
+  end
+
+  # Switch to direct
+  Smullyan.configuration.use_direct(:b, value: true)
+
+  x.report('B (config: direct)') do
+    Smullyan::ConfigurableBirds.B.call(double).call(add_one).call(5)
+  end
+
+  x.compare!
+end
+puts
+
+# Benchmark all combinators with direct implementation
+puts 'All combinators with direct implementation enabled:'
+Smullyan.configure do |config|
+  config.use_all_direct(value: true)
+end
+
+Benchmark.ips do |x|
+  x.report('B direct') do
+    Smullyan::ConfigurableBirds.B.call(double).call(add_one).call(5)
+  end
+
+  x.report('C direct') do
+    subtract = ->(x) { ->(y) { x - y } }
+    Smullyan::ConfigurableBirds.C.call(subtract).call(10).call(3)
+  end
+
+  x.report('W direct') do
+    pair = ->(x) { ->(y) { [x, y] } }
+    Smullyan::ConfigurableBirds.W.call(pair).call(21)
+  end
+
+  x.report('M direct') do
+    Smullyan::ConfigurableBirds.M.call(const_forty_two)
+  end
+
+  x.report('L direct') do
+    Smullyan::ConfigurableBirds.L.call(identity).call(const_forty_two)
+  end
+end
+puts
+
+# Compare configuration overhead
+puts 'Configuration overhead comparison:'
+Smullyan.configuration.use_direct(:b, false)
+
+Benchmark.ips do |x|
+  x.report('B via ConfigurableBirds') do
+    Smullyan::ConfigurableBirds.B.call(double).call(add_one).call(5)
+  end
+
+  x.report('B direct constant') do
+    Smullyan::Birds::B.call(double).call(add_one).call(5)
+  end
+
+  x.compare!
+end
+
+# Reset configuration
+Smullyan.reset_configuration!

data/lib/smullyan/birds/bluebird.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "starling"
-require_relative "kestrel"
+require_relative 'starling'
+require_relative 'kestrel'
 
 module Smullyan
   module Birds
     # The Bluebird - function composition
     # Bluebird x y z = x (y z)
-    # Can be derived as: B = S (K S) K
-    Bluebird = S.call(K.call(S)).call(K)
-    
+
+    # Derived implementation: B = S (K S) K
+    B_derived = S.call(K.call(S)).call(K)
+
     # Direct implementation for comparison/efficiency
-    Bluebird_direct = ->(x) { ->(y) { ->(z) { x.call(y.call(z)) } } }
-    
-    # Traditional combinator name
-    B = Bluebird         # B combinator
-    B_direct = Bluebird_direct
+    B_direct = ->(x) { ->(y) { ->(z) { x.call(y.call(z)) } } }
+
+    # Default to derived implementation for backward compatibility
+    Bluebird = B_derived
+    B = Bluebird
   end
-end
+end

data/lib/smullyan/birds/cardinal.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "starling"
-require_relative "bluebird"
-require_relative "kestrel"
+require_relative 'starling'
+require_relative 'bluebird'
+require_relative 'kestrel'
 
 module Smullyan
   module Birds
     # The Cardinal - flips the order of arguments
     # Cardinal x y z = x z y
-    # Can be derived as: C = S (B B S) (K K)
-    Cardinal = S.call(B.call(B).call(S)).call(K.call(K))
-    
+
+    # Derived implementation: C = S (B B S) (K K)
+    C_derived = S.call(B.call(B).call(S)).call(K.call(K))
+
     # Direct implementation for comparison/efficiency
-    Cardinal_direct = ->(x) { ->(y) { ->(z) { x.call(z).call(y) } } }
-    
-    # Traditional combinator name
-    C = Cardinal         # C combinator
-    C_direct = Cardinal_direct
+    C_direct = ->(x) { ->(y) { ->(z) { x.call(z).call(y) } } }
+
+    # Default to derived implementation for backward compatibility
+    Cardinal = C_derived
+    C = Cardinal
   end
-end
+end

data/lib/smullyan/birds/finch.rb

@@ -0,0 +1,12 @@
+module Smullyan
+    module Birds
+        # The Finch bird (F combinator)
+        # The finch applies its third argument 
+        # to the first and second arguments in reverse order.
+        # Finch x y z = z y x
+        Finch = ->(x) { ->(y) { ->(z) { z.call(y).call(x) } } }
+
+        # Traditional combinator name
+        F = Finch # F combinator
+    end
+end

data/lib/smullyan/birds/identity.rb

@@ -5,9 +5,9 @@ module Smullyan
     # The Identity bird - returns its argument unchanged
     # Identity x = x
     Identity = ->(x) { x }
-    
+
     # Traditional combinator names
     I = Identity      # I combinator
     Idiot = Identity  # Alternative name from Smullyan's book
   end
-end
+end

data/lib/smullyan/birds/kestrel.rb

@@ -4,9 +4,9 @@ module Smullyan
   module Birds
     # The Kestrel - returns the first of two arguments
     # Kestrel x y = x
-    Kestrel = ->(x) { ->(y) { x } }
-    
+    Kestrel = ->(x) { ->(_y) { x } }
+
     # Traditional combinator name
-    K = Kestrel  # K combinator
+    K = Kestrel # K combinator
   end
-end
+end

data/lib/smullyan/birds/lark.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "cardinal"
-require_relative "bluebird"
-require_relative "mockingbird"
+require_relative 'cardinal'
+require_relative 'bluebird'
+require_relative 'mockingbird'
 
 module Smullyan
   module Birds
     # The Lark - applies first argument to result of second argument applied to itself
     # Lark x y = x (y y)
-    # Can be derived as: L = C B M
-    Lark = C.call(B).call(M)
-    
+
+    # Derived implementation: L = C B M
+    L_derived = C.call(B).call(M)
+
     # Direct implementation for comparison/efficiency
-    Lark_direct = ->(x) { ->(y) { x.call(y.call(y)) } }
-    
-    # Traditional combinator name
-    L = Lark         # L combinator
-    L_direct = Lark_direct
+    L_direct = ->(x) { ->(y) { x.call(y.call(y)) } }
+
+    # Default to derived implementation for backward compatibility
+    Lark = L_derived
+    L = Lark
   end
-end
+end

data/lib/smullyan/birds/mockingbird.rb

@@ -1,20 +1,21 @@
 # frozen_string_literal: true
 
-require_relative "starling"
-require_relative "identity"
+require_relative 'starling'
+require_relative 'identity'
 
 module Smullyan
   module Birds
     # The Mockingbird - self-application
     # Mockingbird x = x x
-    # Can be derived as: M = S I I
-    Mockingbird = S.call(I).call(I)
-    
+
+    # Derived implementation: M = S I I
+    M_derived = S.call(I).call(I)
+
     # Direct implementation for comparison/efficiency
-    Mockingbird_direct = ->(x) { x.call(x) }
-    
-    # Traditional combinator name
-    M = Mockingbird         # M combinator
-    M_direct = Mockingbird_direct
+    M_direct = ->(x) { x.call(x) }
+
+    # Default to derived implementation for backward compatibility
+    Mockingbird = M_derived
+    M = Mockingbird
   end
-end
+end

data/lib/smullyan/birds/starling.rb

@@ -5,8 +5,8 @@ module Smullyan
     # The Starling - distributes its third argument to both its first and second
     # Starling x y z = x z (y z)
     Starling = ->(x) { ->(y) { ->(z) { x.call(z).call(y.call(z)) } } }
-    
+
     # Traditional combinator name
-    S = Starling  # S combinator
+    S = Starling # S combinator
   end
-end
+end

data/lib/smullyan/birds/warbler.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "cardinal"
-require_relative "starling"
-require_relative "identity"
+require_relative 'cardinal'
+require_relative 'starling'
+require_relative 'identity'
 
 module Smullyan
   module Birds
     # The Warbler - duplicates its argument
     # Warbler x y = x y y
-    # Can be derived as: W = C S I
-    Warbler = C.call(S).call(I)
-    
+
+    # Derived implementation: W = C S I
+    W_derived = C.call(S).call(I)
+
     # Direct implementation for comparison/efficiency
-    Warbler_direct = ->(x) { ->(y) { x.call(y).call(y) } }
-    
-    # Traditional combinator name
-    W = Warbler         # W combinator
-    W_direct = Warbler_direct
+    W_direct = ->(x) { ->(y) { x.call(y).call(y) } }
+
+    # Default to derived implementation for backward compatibility
+    Warbler = W_derived
+    W = Warbler
   end
-end
+end

data/lib/smullyan/birds/why.rb

@@ -5,21 +5,14 @@ module Smullyan
     # The Why bird (Y combinator) - fixed-point combinator
     # Why f = f (Why f)
     # Here's a practical implementation that works in applicative-order languages like Ruby
-    Why = ->(f) {
+    Why = lambda { |f|
       ->(x) { f.call(->(v) { x.call(x).call(v) }) }.call(
         ->(x) { f.call(->(v) { x.call(x).call(v) }) }
       )
     }
-    
-    # Alternative Z combinator (strict fixed-point) that's more suitable for eager evaluation
-    Z = ->(f) {
-      ->(x) { f.call(->(v) { x.call(x).call(v) }) }.call(
-        ->(x) { f.call(->(v) { x.call(x).call(v) }) }
-      )
-    }
-    
+
     # Traditional combinator names
     Y = Why              # Y combinator (fixed-point)
     Sage = Why           # Y combinator (alternative name)
   end
-end
+end

data/lib/smullyan/configurable_birds.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Smullyan
+  # Module for getting configurable combinator implementations
+  module ConfigurableBirds
+    # rubocop:disable Naming/MethodName
+    class << self
+      def B
+        if Smullyan.configuration.direct?(:b)
+          Birds::B_direct
+        else
+          Birds::B_derived
+        end
+      end
+      alias Bluebird B
+
+      def C
+        if Smullyan.configuration.direct?(:c)
+          Birds::C_direct
+        else
+          Birds::C_derived
+        end
+      end
+      alias Cardinal C
+
+      def W
+        if Smullyan.configuration.direct?(:w)
+          Birds::W_direct
+        else
+          Birds::W_derived
+        end
+      end
+      alias Warbler W
+
+      def M
+        if Smullyan.configuration.direct?(:m)
+          Birds::M_direct
+        else
+          Birds::M_derived
+        end
+      end
+      alias Mockingbird M
+
+      def L
+        if Smullyan.configuration.direct?(:l)
+          Birds::L_direct
+        else
+          Birds::L_derived
+        end
+      end
+      alias Lark L
+    end
+    # rubocop:enable Naming/MethodName
+  end
+end

data/lib/smullyan/configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# The Smullyan module provides implementations of combinators from
+# Raymond Smullyan's "To Mock a Mockingbird" and related works.
+module Smullyan
+  # Configuration for selecting combinator implementations
+  class Configuration
+    attr_accessor :use_direct_implementation
+
+    def initialize
+      @use_direct_implementation = {
+        b: false,  # Bluebird
+        c: false,  # Cardinal
+        w: false,  # Warbler
+        m: false,  # Mockingbird
+        l: false   # Lark
+      }
+    end
+
+    # Configure specific combinators
+    def use_direct(combinator, value: true)
+      key = combinator.to_s.downcase.to_sym
+      raise ArgumentError, "Unknown combinator: #{combinator}" unless @use_direct_implementation.key?(key)
+
+      @use_direct_implementation[key] = value
+    end
+
+    # Configure all combinators at once
+    def use_all_direct(value: true)
+      @use_direct_implementation.each_key do |key|
+        @use_direct_implementation[key] = value
+      end
+    end
+
+    # Check if a combinator should use direct implementation
+    def direct?(combinator)
+      key = combinator.to_s.downcase.to_sym
+      @use_direct_implementation[key] || false
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/smullyan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Smullyan
-  VERSION = "0.1.0"
-end
+  VERSION = '0.1.1'
+end

data/lib/smullyan.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
 
-require_relative "smullyan/version"
-require_relative "smullyan/birds/identity"
-require_relative "smullyan/birds/kestrel"
-require_relative "smullyan/birds/starling"
-require_relative "smullyan/birds/bluebird"
-require_relative "smullyan/birds/cardinal"
-require_relative "smullyan/birds/warbler"
-require_relative "smullyan/birds/mockingbird"
-require_relative "smullyan/birds/why"
-require_relative "smullyan/birds/lark"
+require_relative 'smullyan/version'
+require_relative 'smullyan/configuration'
+require_relative 'smullyan/birds/identity'
+require_relative 'smullyan/birds/kestrel'
+require_relative 'smullyan/birds/starling'
+require_relative 'smullyan/birds/bluebird'
+require_relative 'smullyan/birds/cardinal'
+require_relative 'smullyan/birds/warbler'
+require_relative 'smullyan/birds/mockingbird'
+require_relative 'smullyan/birds/why'
+require_relative 'smullyan/birds/lark'
+require_relative 'smullyan/birds/finch'
+require_relative 'smullyan/configurable_birds'
 
 module Smullyan
   class Error < StandardError; end
-  
+
   # All combinators are now in separate files
   module Birds
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smullyan
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Phil Crissman
@@ -10,33 +10,33 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '5.18'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '5.18'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.18'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.18'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -77,9 +77,12 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/combinators_benchmark.rb
+- benchmark/configurable_benchmark.rb
 - lib/smullyan.rb
 - lib/smullyan/birds/bluebird.rb
 - lib/smullyan/birds/cardinal.rb
+- lib/smullyan/birds/finch.rb
 - lib/smullyan/birds/identity.rb
 - lib/smullyan/birds/kestrel.rb
 - lib/smullyan/birds/lark.rb
@@ -87,6 +90,8 @@ files:
 - lib/smullyan/birds/starling.rb
 - lib/smullyan/birds/warbler.rb
 - lib/smullyan/birds/why.rb
+- lib/smullyan/configurable_birds.rb
+- lib/smullyan/configuration.rb
 - lib/smullyan/version.rb
 homepage: https://github.com/philcrissman/smullyan
 licenses: