smullyan 0.1.0

checksums.yaml

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

data/CLAUDE.md

@@ -0,0 +1,67 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a Ruby gem implementing combinators from Raymond Smullyan's "To Mock a Mockingbird". The project uses:
+- Ruby (>= 2.7.0)
+- Minitest for testing
+- RuboCop for code linting
+- Bundler for dependency management
+
+## Common Development Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rake test
+# or
+bundle exec rake
+
+# Run a specific test file
+bundle exec ruby test/test_ski.rb
+
+# Run linting
+bundle exec rubocop
+
+# Run tests and linting (default task)
+bundle exec rake
+
+# Build the gem
+bundle exec rake build
+
+# Install gem locally
+bundle exec rake install
+
+# Release to RubyGems (requires permissions)
+bundle exec rake release
+```
+
+## Project Structure
+
+- `lib/smullyan.rb` - Main module with combinator implementations (Birds module)
+- `lib/smullyan/version.rb` - Version constant
+- `test/test_smullyan.rb` - Minitest test files
+- `smullyan.gemspec` - Gem specification
+- `Rakefile` - Rake tasks for testing and building
+
+## Architecture Notes
+
+The gem implements combinators from combinatory logic, each with both a letter name and a bird name from Smullyan's book:
+
+### Core SKI Combinators:
+- **S combinator (Starling)**: `S x y z = x z (y z)`
+- **K combinator (Kestrel)**: `K x y = x`
+- **I combinator (Identity/Idiot)**: `I x = x`
+
+### Additional Combinators:
+- **B combinator (Bluebird)**: `B x y z = x (y z)` - function composition
+- **C combinator (Cardinal)**: `C x y z = x z y` - argument flip
+- **W combinator (Warbler)**: `W x y = x y y` - duplication
+- **M combinator (Mockingbird)**: `M x = x x` - self-application
+- **Y combinator (Why/Sage)**: Fixed-point combinator for recursion
+
+These are implemented as Ruby lambda functions in the `Smullyan::Birds` module, with both single-letter names (S, K, I, etc.) and bird names (Starling, Kestrel, Identity, etc.) available.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Phil Crissman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Smullyan
+
+A Ruby implementation of combinators from Raymond Smullyan's "To Mock a Mockingbird".
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'smullyan'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install smullyan
+
+## Usage
+
+```ruby
+require 'smullyan'
+
+# Using the classic SKI combinators
+s = Smullyan::Birds::S
+k = Smullyan::Birds::K  
+i = Smullyan::Birds::I
+
+# Or use the bird names!
+kestrel = Smullyan::Birds::Kestrel      # K combinator
+starling = Smullyan::Birds::Starling    # S combinator
+mockingbird = Smullyan::Birds::Mockingbird # M combinator
+
+# Example: Identity function derived from S and K
+identity = s.call(k).call(k)
+identity.call(42) # => 42
+
+# Example: Function composition with the Bluebird
+bluebird = Smullyan::Birds::Bluebird
+double = ->(x) { x * 2 }
+increment = ->(x) { x + 1 }
+double_after_increment = bluebird.call(double).call(increment)
+double_after_increment.call(5) # => 12
+
+# Example: Y combinator for recursion
+why = Smullyan::Birds::Why
+factorial = why.call(->(f) {
+  ->(n) { n <= 1 ? 1 : n * f.call(n - 1) }
+})
+factorial.call(5) # => 120
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/philcrissman/smullyan.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/smullyan/birds/bluebird.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+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)
+    
+    # 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
+  end
+end

data/lib/smullyan/birds/cardinal.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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))
+    
+    # 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
+  end
+end

data/lib/smullyan/birds/identity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Smullyan
+  module Birds
+    # 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

data/lib/smullyan/birds/kestrel.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Smullyan
+  module Birds
+    # The Kestrel - returns the first of two arguments
+    # Kestrel x y = x
+    Kestrel = ->(x) { ->(y) { x } }
+    
+    # Traditional combinator name
+    K = Kestrel  # K combinator
+  end
+end

data/lib/smullyan/birds/lark.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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)
+    
+    # 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
+  end
+end

data/lib/smullyan/birds/mockingbird.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+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)
+    
+    # Direct implementation for comparison/efficiency
+    Mockingbird_direct = ->(x) { x.call(x) }
+    
+    # Traditional combinator name
+    M = Mockingbird         # M combinator
+    M_direct = Mockingbird_direct
+  end
+end

data/lib/smullyan/birds/starling.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Smullyan
+  module Birds
+    # 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
+  end
+end

data/lib/smullyan/birds/warbler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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)
+    
+    # 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
+  end
+end

data/lib/smullyan/birds/why.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Smullyan
+  module Birds
+    # 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) {
+      ->(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

data/lib/smullyan/version.rb

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

data/lib/smullyan.rb

@@ -0,0 +1,20 @@
+# 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"
+
+module Smullyan
+  class Error < StandardError; end
+  
+  # All combinators are now in separate files
+  module Birds
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: smullyan
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Phil Crissman
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.18'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+description: A Ruby gem implementing the combinatory logic birds from Raymond Smullyan's
+  To Mock a Mockingbird
+email:
+- your-email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/smullyan.rb
+- lib/smullyan/birds/bluebird.rb
+- lib/smullyan/birds/cardinal.rb
+- lib/smullyan/birds/identity.rb
+- lib/smullyan/birds/kestrel.rb
+- lib/smullyan/birds/lark.rb
+- lib/smullyan/birds/mockingbird.rb
+- lib/smullyan/birds/starling.rb
+- lib/smullyan/birds/warbler.rb
+- lib/smullyan/birds/why.rb
+- lib/smullyan/version.rb
+homepage: https://github.com/philcrissman/smullyan
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/philcrissman/smullyan
+  source_code_uri: https://github.com/philcrissman/smullyan
+  changelog_uri: https://github.com/philcrissman/smullyan/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: A Ruby implementation of combinators from Raymond Smullyan's To Mock a Mockingbird
+test_files: []