emanlib 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1325271b5892d5c0195b9169f09416790ea4887f680e194afb2445f33bb57b75
+  data.tar.gz: effa861c1070d969e2ab86287c101ba90bcd52ad9f82cceb87616d79f3b5a554
+SHA512:
+  metadata.gz: 2a5248da79b6d73c42c62932c9a2473d10dee603aa9c40ba880cbe708f5ae450d1fa0861805c507051fa5dd3d777031dbfecd6a2120ac0fe688bc5743ee0eaf5
+  data.tar.gz: 77a89f7f87e7003134b581f272c4892f61c3cc861371cc7758b21a022463caa8468064b16adafd88b0d70f7b0bf1d431290b90bfe2dda22c16d6ff619d3d0389

data/lib/emanlib.rb

@@ -0,0 +1,73 @@
+require_relative "patch/define"
+require_relative "patch/foobar"
+require_relative "patch/lambda"
+
+module EmanLib
+  # The identity Lambda object (`_`).
+  # Store in a short variable, and use it as a building block for anonymous functions.
+  #
+  #     _ = EmanLib.LAMBDA
+  #     [1, 2, 3].map(&_.succ) => [2, 3, 4]
+  #     [[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]
+  LAMBDA = Lambda.new
+
+  # Helper method to create definitions.
+  # A convenient shorthand for `Object.new.define(...)`.
+  #
+  # @param args [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
+  # @param block [Proc] If provided, its local variables are used to define methods.
+  # @return [Object] A new object with dynamically defined methods.
+  #
+  # @see [Object#define]
+  #
+  # @example
+  #   point = let(x: 10, y: 20)
+  #   puts point.x # => 10
+  #
+  #   settings = let do
+  #     theme = "dark"
+  #     font_size = 12
+  #     binding
+  #   end
+  #   puts settings.theme # => "dark"
+  #
+  #   complex_data = let([[:id, "item1"]], name: "Test Item") do
+  #     details = { color: "red", size: "large" }
+  #     binding
+  #   end
+  #
+  #   puts complex_data.id            # => "item1"
+  #   puts complex_data.name          # => "Test Item"
+  #   puts complex_data.details.color # => "red"
+  def let(*args, &block)
+    Object.new.define(*args, &block)
+  end
+
+  module_function :let
+
+  # Support for using a `_` as the second operand with operators.
+  # WARN: This method will MODIFY the standard library classes.
+  # In particular, the operators: `- * / % ** & | ^ << >> <=> == === != > < >= <=`
+  # in the classes: `Integer, Float, Rational, Complex, Array, String, Hash, Range, Set`
+  def support_lambda
+    [[Integer, Float, Rational, Complex, Array, String, Hash, Range, Set],
+     %i[- * / % ** & | ^ << >> <=> == === != > < >= <=]].op(:product)
+      .each do |klass, op|
+      next unless klass.instance_methods(false).include?(op)
+
+      original = klass.instance_method(op)
+      klass.define_method(op) do |other|
+        if other.is_a?(Lambda)
+          repr = [self]
+          repr.concat(other.repr)
+          repr << Lambda::Function.new(op)
+          Lambda.new(repr)
+        else
+          original.bind(self).call(other)
+        end
+      end
+    end
+  end
+
+  module_function :support_lambda
+end

data/lib/patch/define.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+# Enhances the Binding class to easily extract local variables into a Hash.
+class Binding
+  # Converts the local variables accessible from this binding into a Hash.
+  # The keys of the hash are the variable names (as Symbols), and the values
+  # are the corresponding variable values.
+  #
+  # @return [Hash<Symbol, Object>] A hash mapping local variable names to their values.
+  #
+  # @example
+  #   def my_method
+  #     a = 10
+  #     b = "hello"
+  #     binding.variables # => {:a=>10, :b=>"hello"}
+  #   end
+  def variables
+    Hash[
+      local_variables.map do |var|
+        [var, local_variable_get(var)]
+      end
+    ]
+  end
+end
+
+# Enhances the Array class with a utility method to check its structure.
+class Array
+  # Checks if the array is "hashy", meaning it consists entirely of
+  # two-element arrays. This structure is suitable for conversion to a Hash
+  # using `to_h`.
+  #
+  # @return [Boolean] `true` if the array is "hashy", `false` otherwise.
+  #
+  # @example
+  #   [[:a, 1], [:b, 2]].hashy?  # => true
+  #   [["key1", "value1"]].hashy? # => true
+  #   [[1, 2, 3], [:b, 2]].hashy? # => false (first item has 3 elements)
+  #   [1, 2, 3].hashy?            # => false (items are not arrays)
+  #   [[], [:a, 1]].hashy?       # => false (first item is not a 2-element array)
+  def hashy?
+    all? { |item| item.is_a?(Array) && item.size == 2 }
+  end
+end
+
+# Enhances the String class with validation for method and variable names.
+class String
+  # Checks if the string is a valid Ruby method or variable name.
+  #
+  # Valid method names can include letters, numbers, underscores, and may
+  # end with `!`, `=`, or `?`.
+  # Valid variable names can include letters, numbers, and underscores but
+  # cannot end with `!`, `=`, or `?`.
+  #
+  # @param target [:method, :variable] Specifies whether to validate as a method
+  #   name or a variable name. Defaults to `:method`.
+  # @return [Boolean] `true` if the string is a valid name for the specified target,
+  #   `false` otherwise.
+  #
+  # @example
+  #   "my_method".valid_name?                # => true
+  #   "my_method?".valid_name?               # => true
+  #   "setter=".valid_name?                 # => true
+  #   "_private_method!".valid_name?         # => true
+  #   "ConstantLike".valid_name?             # => true
+  #   "1invalid".valid_name?                 # => false (starts with a number)
+  #   "invalid-name".valid_name?             # => false (contains hyphen)
+  #
+  #   "my_variable".valid_name?(target: :variable) # => true
+  #   "_var".valid_name?(target: :variable)        # => true
+  #   "my_variable?".valid_name?(target: :variable)# => false (ends with ?)
+  #   "A_CONSTANT".valid_name?(target: :variable)  # => true
+  def valid_name?(target: :method)
+    case target
+    when :method
+      self =~ /\A[a-zA-Z_]\w*[!?=]?\z/
+    when :variable
+      self =~ /\A[a-zA-Z_]\w*\z/
+    else
+      false
+    end
+  end
+end
+
+# Enhances the base Object class to allow dynamic definition of properties
+class Object
+  # Dynamically defines properties on `self`,
+  # based on the provided arguments and/or block.
+  #
+  # Arguments can be Hashes or "hashy" Arrays (arrays of `[key, value]` pairs).
+  # If a block is given, its local variables are also used to define methods.
+  # Keys are converted to symbols and validated as method names.
+  #
+  # If a value is a Hash or a "hashy" Array, it's recursively
+  # used to define nested properties.
+  #
+  # @param `args` [Array<Hash, Array>] A list of Hashes or "hashy" Arrays.
+  #   Each key-value pair will result in a getter and setter method.
+  # @param `block` [Proc] If provided, `block.call` is expected to return a `Binding`
+  #   (i.e. last expression in the block must be `binding`).
+  #   Local variables from this binding will be used to define methods.
+  #
+  # @return [self] The object itself, now with the newly defined methods.
+  #
+  # @raise [ArgumentError] If an argument is not a Hash or a "hashy" Array.
+  # @raise [ArgumentError] If a key is not a valid method name.
+  #
+  # @example Defining with a Hash
+  #   # let(...) === Object.new.define(...)
+  #
+  #   person = let(name: "Alice", age: 30)
+  #   person.name # => "Alice"
+  #   person.age = 31
+  #   person.age # => 31
+  #
+  # @example Defining with a "hashy" Array
+  #   config = let([[:host, "localhost"], [:port, 8080]])
+  #   config.host # => "localhost"
+  #
+  # @example Defining with a block
+  #   user = let do
+  #     username = "bob"
+  #     active = true
+  #     binding # Important: makes local variables available
+  #   end
+  #
+  #   user.username # => "bob"
+  #   user.active?  # This won't define active? automatically, but user.active
+  #
+  # @example Nested definitions
+  #   settings = let(
+  #     database: { adapter: "sqlite3", pool: 5 },
+  #     logging: [[:level, "info"], [:file, "/var/log/app.log"]]
+  #   )
+  #   settings.database.adapter # => "sqlite3"
+  #   settings.logging.level    # => "info"
+  #
+  # @example Combining arguments
+  #   complex = let({id: 1}, [[:type, "example"]]) do
+  #     description = "A complex object"
+  #     status = :new
+  #     binding
+  #   end
+  #
+  #   complex.id          # => 1
+  #   complex.type        # => "example"
+  #   complex.description # => "A complex object"
+  def define(*args, &block)
+    # Stores all key-value pairs to be defined
+    variable = {}
+
+    # Process Hashes and "hashy" Arrays first
+    args.each do |arg|
+      case arg
+      when Hash
+        variable.merge!(arg)
+      when Array
+        raise ArgumentError, "Array should be Hash like." unless arg.hashy?
+        variable.merge!(arg.to_h)
+      else
+        raise ArgumentError, "Invalid argument type: #{arg.class}"
+      end
+    end
+
+    # Process local variables from the block
+    if block_given? # If provided
+      binding = block.call # The block is expected to return its binding.
+      raise ArgumentError, "Block must return a Binding object." unless binding.is_a?(Binding)
+
+      variable.merge!(binding.variables)
+    end
+
+    # Define getters and setters and store values
+    variable.each do |name, value|
+      name = name.to_s.to_sym
+      raise ArgumentError, "Invalid name: #{name}" unless name.to_s.valid_name?(target: :method)
+
+      # Recursively define for nested Hashes or "hashy" Arrays
+      if value.is_a? Hash
+        value = Object.new.define(value)
+      elsif value.is_a?(Array) && value.hashy?
+        value = Object.new.define(value.to_h)
+      end
+
+      # Store the original value in an instance variable
+      instance_variable_set("@#{name}", value)
+
+      define_singleton_method(name) do
+        instance_variable_get("@#{name}")
+      end
+
+      define_singleton_method("#{name}=") do |value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    self
+  end
+end

data/lib/patch/foobar.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+# Extends the base Object class with utility methods for control flow,
+# introspection, and data manipulation.
+class Object
+  # If the object is truthy (neither `nil` nor `false`), yields the object
+  # itself to the given block.
+  #
+  # @example
+  #   123.if { |x| puts "Number is #{x}" } # Output: Number is 123
+  #   nil.if { |x| puts "This won't print: #{x}" } # Nothing
+  #   false.if { |x| puts "This also won't print: #{x}" } # Nothing
+  #   "hello".if { |s| s.upcase } # => "HELLO"
+  #
+  # @yield [self] Gives `self` to the block if `self` is truthy.
+  # @return [Object, nil] The result of the block if executed, otherwise `nil`.
+  def if
+    self && yield(self)
+  end
+
+  # If the object is truthy, yields the object to the block and then returns `self`.
+  # This is similar to {Object#if}, but always returns `self`, making it useful
+  # for chaining or conditional side effects.
+  #
+  # @example
+  #   value = "test".tif { |s| puts "Processing #{s}" } # Output: Processing test
+  #   puts value # Output: test
+  #
+  #   data = [1, 2, 3]
+  #   data.tif { |arr| arr.pop if arr.size > 2 }
+  #   puts data.inspect # Output: [1, 2] (if data was not empty)
+  #
+  # @yield [self] Gives `self` to the block if `self` is truthy.
+  # @return [self] The original object.
+  def tif
+    tap { self && yield(self) }
+  end
+
+  # If the object is falsy (`nil` or `false`), yields the object itself to the
+  # given block.
+  #
+  # @example
+  #   nil.or { |x| puts "Object was nil" } # Output: Object was nil
+  #   false.or { |x| puts "Object was false" } # Output: Object was false
+  #   123.or { |x| puts "This won't print: #{x}" } # Output: (nothing)
+  #   "".or { |s| s + "default" } # => "" (empty string is truthy)
+  #
+  # @yield [self] Gives `self` to the block if `self` is falsy.
+  # @return [Object, nil] The result of the block if executed, otherwise `self`.
+  #   Note that `self || yield(self)` returns `self` if truthy, and `yield(self)` if falsy.
+  def or
+    self || yield(self)
+  end
+
+  # If the object is falsy, yields the object to the block and then returns `self`.
+  # This is similar to {#or}, but always returns the original object.
+  #
+  # @see Object#default An alias for this method.
+  #
+  # @example
+  #   result = nil.tor { |x| puts "Handled nil case" } # Output: Handled nil case
+  #   puts result.inspect # Output: nil
+  #
+  #   user_input = "".empty? && nil # user_input is nil
+  #   user_input.tor { puts "This will print" }
+  #
+  # @yield [self] Gives `self` to the block if `self` is falsy.
+  # @return [self] The original object.
+  def tor
+    tap { self || yield(self) }
+  end
+
+  # If `x` is case-equal (`===`) to `self`, yields to the block and returns `self`.
+  # This is useful for chaining checks, mimicking a case-like structure.
+  #
+  # @param x [Object] The object to compare against `self` using `===`. Defaults to `self`,
+  #   which means `self === self` is checked if no argument is passed (effectively
+  #   yielding if `self` is matched by itself, which is always true for typical objects).
+  # @yield If `x === self` is true.
+  # @return [self] The original object.
+  #
+  # @example
+  #   status_code = 200
+  #   status_code
+  #     .when(200..299) { puts "Yay!" } # Only one to run
+  #     .when(400..499) { puts "Client Error!" }
+  #     .when(500..599) { puts "Server Error!" }
+  #
+  #   # Only `Array`'s block runs here
+  #   [1,2,3,4,5,6]
+  #       .when(Array) { puts "It's an array" }
+  #       .when(String) { puts "It's a string" }
+  #
+  #   # Chaining `default` (alias for `tor`)
+  #   "hello"
+  #     .when(Integer) { |n| puts "#{n} + 1 = #{n + 1}" }
+  #     .default { puts "This won't run either" }
+  #
+  #   # If value was nil:
+  #   # nil.when(Integer){}.default { puts "this will print" }
+  def when(x = self)
+    tap { yield(self) if x === self }
+  end
+
+  # Just like [Object#when], but propagates the values of the blocks that execute.
+  # This method can be chained because it returns `self` if no block is executed.
+  #
+  # @param x [Object] The object to compare against `self` using `===`. Default is `self`.
+  # @yield If `x === self` is true.
+  # @return [Object | self] The result of the block if executed, otherwise `self`.
+  #
+  # @example
+  #   42.iff(Integer) { |x| x * 2 } # => 84
+  #   "foo".iff(Float) { |n| n / 2 }.iff(String) { |s| s.upcase } # => "FOO"
+  def iff(x = self)
+    if x === self
+      yield(self)
+    else
+      self
+    end
+  end
+
+  # Asserts a condition about `self`.
+  # If a block is given, it asserts that the block, when called with `self`, returns a truthy value.
+  # If no block is given, it asserts that `n === self` is true.
+  # If the assertion fails, it performs a non-local exit by `raise`.
+  #
+  # @param `n` ([Object]) The object to compare with `self` if no block is given. Defaults to `self`.
+  # @param `error` ([Class]) The class of error to raise if the assertion fails.
+  #   Defaults to `StandardError`.
+  # @yield [self] Optional block whose truthiness is asserted.
+  # @return [self] The original object if assertion passes.
+  # @throw `error` (or a related symbol) if the assertion fails.
+  #
+  # @example
+  #   5.assert(Integer) # Passes
+  #   "string".assert(error: ArgumentError) { |s| s.length > 5 } # Passes
+  def assert(n = self, error: StandardError)
+    tap { (block_given? ? yield(self) : (n === self)) || raise(error) }
+  end
+
+  # Prints the `inspect` representation of `self` to standard output.
+  # Returns `self`, allowing for chaining.
+  #
+  # @example
+  #   [1, 2, 3]
+  #      .show # prints [1, 2, 3]
+  #      .map { |x| x * 2 }
+  #      .show # print [2, 4, 6]
+  def show
+    tap { puts inspect }
+  end
+end
+
+alias m method
+alias default tor
+alias env binding
+
+# Extends the Integer class with methods for time durations and comparisons.
+class Integer
+  # Represents the integer as a duration in seconds.
+  # @return [Integer] self
+  def second; self end
+
+  # Converts the integer (assumed to be minutes) into seconds.
+  # @return [Integer] Total seconds.
+  def minute; self * 60.second end
+
+  # Converts the integer (assumed to be hours) into seconds.
+  # @return [Integer] Total seconds.
+  def hour; self * 60.minute end
+
+  # Converts the integer (assumed to be days) into seconds.
+  # @return [Integer] Total seconds.
+  def day; self * 24.hour end
+
+  # Converts the integer (assumed to be weeks) into seconds.
+  # @return [Integer] Total seconds.
+  def week; self * 7.day end
+
+  # Converts the integer (assumed to be months, approximated as 4 weeks) into seconds.
+  # @return [Integer] Total seconds.
+  def month; self * 4.week end
+
+  # Converts the integer (assumed to be years) into seconds.
+  # @return [Integer] Total seconds.
+  def year; self * 12.month end
+
+  # Returns the minimum of `self` and the given numeric values.
+  #
+  # @param `xs` [Array<Numeric>] Zero or more numeric values to compare against.
+  # @return [Numeric] The smallest value among `self` and `xs`.
+  # @example
+  #   5.min(3, 4, 2)  # => 2
+  #   -1.min(0, 1)    # => -1
+  #   10.min(20)      # => 10
+  def min(*xs)
+    xs.push(self)
+    xs.min
+  end
+
+  # Returns the maximum of `self` and the given numeric values.
+  #
+  # @param `xs` [Array<Numeric>] Zero or more numeric values to compare against.
+  # @return [Numeric] The largest value among `self` and `xs`.
+  # @example
+  #   5.max(3, 4, 11) # => 11
+  #   -1.max(-5, 0)   # => 0
+  #   10.max(2)       # => 10
+  def max(*xs)
+    xs.push(self)
+    xs.max
+  end
+end
+
+# Extends the String class with methods for system execution and output.
+class String
+  # Executes the string as a system command.
+  # Allows for substituting arguments into the string using `sprintf` format.
+  #
+  # @param args [Hash] A hash of arguments to be interpolated into the command string.
+  #   The keys are used in `sprintf`-style formatting (e.g., `%{key}`).
+  # @return [Boolean, nil] Returns `true` if the command was found and ran successfully (exit status 0),
+  #   `false` if the command returned a non-zero exit status, and `nil` if command execution failed
+  #   (e.g., command not found).
+  # @example
+  #   "ls -l %{dir}".exec(dir: "/tmp")
+  #   "echo 'Hello World'".exec # => true (prints "Hello World")
+  #   "ruby -e 'exit 1'".exec # => false
+  def exec(args = {})
+    system(self % args)
+  end
+
+  # Prints the string to the console, followed by a newline.
+  def echo
+    tap { puts self }
+  end
+end
+
+# Extends the Array class with methods for accessing elements.
+class Array
+  # Returns the rest of the array (all elements except the first).
+  # Returns an empty array if the original array has 0 or 1 element.
+  #
+  # @return [Array] A new array containing all elements except the first.
+  # @example
+  #   [1, 2, 3, 4].rest # => [2, 3, 4]
+  #   [1].rest          # => []
+  #   [].rest           # => []
+  def rest
+    drop 1
+  end
+
+  # Simplifies the array: if it contains exactly one element, returns that element.
+  # Otherwise, returns the array itself.
+  #
+  # @return [Object, Array] The single element if array size is 1, otherwise `self`.
+  # @example
+  #   [42].simplify    # => 42
+  #   ["hello"].simplify # => "hello"
+  #   [1, 2].simplify  # => [1, 2]
+  #   [].simplify      # => []
+  def simplify
+    size == 1 ? fetch(0) : self
+  end
+
+  # Defines methods `second`, `third`, ..., `tenth` for accessing elements or sub-arrays.
+  # Each method `arr.Nth(n=1)` (e.g., `arr.third` or `arr.third(2)`):
+  # - Skips `(index_of_Nth - 1)` elements (e.g., for `third`, skips 2 elements).
+  # - Takes `n` elements from that point.
+  # - Simplifies the result using {#simplify}.
+  #
+  # @example
+  #   arr = [10, 20, 30, 40, 50, 60]
+  #   arr.second       # => 20 (drops 1, takes 1, simplifies)
+  #   arr.third        # => 30 (drops 2, takes 1, simplifies)
+  #   arr.second(2)    # => [20, 30] (drops 1, takes 2, simplifies)
+  #   arr.fourth(3)    # => [40, 50, 60] (drops 3, takes 3, simplifies)
+  #   arr.sixth        # => 60
+  #   arr.seventh      # => nil (if out of bounds and simplified from empty array or single nil)
+  #   ["a","b"].third  # => nil
+  %i[second third fourth fifth sixth seventh eighth ninth tenth]
+    .zip(1..) # 1-based index for human-readable Nth
+    .each do |method_name, index|
+    define_method(method_name) do |n = 1|
+      # `index` is 1 for 'second', 2 for 'third', etc.
+      # So, for 'second' (index 1), drop 1. For 'third' (index 2), drop 2.
+      drop(index).take(n).simplify
+    end
+  end
+end
+
+# Extends the Symbol class for functional programming patterns.
+class Symbol
+  # Creates a Proc that functions as a curried instance method for objects
+  # It is possible to supply a block (to the instance method) for later use.
+  # This method allows for partial application of instance methods.
+  #
+  # @param `args` [Array<Object>] Arguments to be pre-supplied to the method.
+  # @param `block` [Proc] A block to be pre-supplied to the method.
+  # @return [Proc] A lambda that expects a receiver object and any further arguments.
+  #
+  # @example
+  #   plus_2 = :+.with(2)
+  #   plus_2.call(5) # => 7
+  #
+  #   mapper = :map.with { |x| x * x }
+  #   data = [1, 2, 3]
+  #   mapper.call(data) # => [1, 4, 9]
+  #
+  #   # Combining with map
+  #   [1, 2, 3].map(&:+.with(10)) # => [11, 12, 13]
+  def with(*args, &block)
+    ->(o, *more) { o.send(self, *args, *more, &block) }
+  end
+end
+
+# Extends the Thread class.
+class Thread
+  # Returns an array of all live threads except the current thread.
+  # A static class method.
+  #
+  # @return [Array<Thread>] An array of other live Thread objects.
+  #
+  # @example
+  #   thread1 = Thread.new { sleep 1 }
+  #   thread2 = Thread.new { sleep 1 }
+  #   # In the main thread:
+  #   Thread.others # => might include thread1, thread2 (depending on timing)
+  def self.others
+    Thread.list.reject { |x| x == Thread.current }
+  end
+end
+
+# Extends the Hash class with an alias
+class Hash
+  alias flip invert
+end

data/lib/patch/lambda.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+# Monkey patches for use in `Lambda`
+class Array
+  # Allows for this:
+  # -  `[1, 2, 3].op(:+) # => 6`
+  # -  `[1, 2, 3].op(:-) # => -4`
+  #
+  # Not the same as [reduce] or [inject]
+  # The `method` argument is supposed to be an instance method
+  # for the first element of the array.
+  def op(method)
+    first.send(method, slice(1..))
+  end
+
+  # Same as [Array#pop] but returns `default` if the array is empty.
+  def qoq(default = nil)
+    empty? ? default : pop
+  end
+end
+
+# A Lambda object (`_`) is building block for anonymous functions.
+# For instance, (`_ + _`) represents f(x,y) = x + y
+# (`_ * 2`) represents f(x) = 2x.
+# You can use any method or operator on a `_`, and it will work:
+# -   `[1, 2].map(&_.succ ** 3)      => [8, 27]`
+# -   `[[1,2], [3,4]].map(&_.sum / 2)  => [1.5, 3.5]`
+#
+# The `lift` method allows a `_` to be used like so:
+# -   `[[1, 2], [3, 4]].map(&(_ + _).lift) => [3, 7]`
+#
+# i.e. it treats the first arg (that is an array) as the actual arguments to be used
+# WARN: "lift" state is contagious (e.g. `(_ + _.lift) <=> (_ + _).lift`).
+#
+# You can similarly use [unlift] to convert a lifted `_` back to a normal.
+# [support_lambda] will allow for a _ to be used as the second operand (e.g. `2 - _`)
+#
+class Lambda < BasicObject
+  class Arg; end
+
+  class Block
+    def initialize(block)
+      @proc = block
+    end
+
+    def to_proc
+      @proc
+    end
+  end
+
+  class Function
+    def initialize(method)
+      @method = method
+    end
+
+    def to_proc
+      @method.to_proc
+    end
+  end
+
+  def __repr__; @__repr__ end
+  def __tuply__; @__tuply__ end
+
+  def initialize(repr = [Arg.new], *args)
+    @__tuply__ = args.include?(:lift)
+    @__repr__ = repr
+
+    return if repr != :lift
+
+    @__repr__ = [Arg.new]
+    @__tuply__ = true
+  end
+
+  def to_proc
+    ::Proc.new do |*args|
+      args = args.first if @__tuply__ && args.first.is_a?(::Array)
+      stack = []
+      index = 0
+
+      @__repr__.each do |element|
+        case element
+        when Arg
+          stack << args[index]
+          index += 1
+        when Function
+          f = element.to_proc
+          operands, block = stack.partition { |e| !e.is_a?(Block) }
+          empty = ::Object.new
+          xy = [operands.qoq(empty), operands.qoq(empty)]
+            .reject { |x| x.equal?(empty) }.reverse
+          stack = operands
+
+          if block.empty?
+            stack << f.call(*xy)
+          else
+            stack << f.call(*xy, &block[0].to_proc)
+          end
+        else
+          stack << element
+        end
+      end
+
+      stack.first
+    end
+  end
+
+  # Temporary wrapper for @__repr__
+  class Repr
+    attr_reader :repr
+
+    def initialize(repr)
+      @repr = repr
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    extra = [Function.new(method)]
+    extra.unshift Block.new(block) if block
+    tuply = @__tuply__
+
+    args.map do |arg|
+      if arg.is_a?(::Lambda)
+        tuply ||= arg.__tuply__
+        Repr.new(arg.__repr__)
+      else
+        arg
+      end
+    end.each_with_index do |arg, i|
+      if arg.is_a? Repr
+        args.insert(i, *arg.repr)
+        args.delete_at(i + arg.repr.size)
+      end
+    end
+
+    if tuply
+      ::Lambda.new(@__repr__ + args + extra, :lift)
+    else
+      ::Lambda.new(@__repr__ + args + extra)
+    end
+  end
+
+  def lift
+    ::Lambda.new(@__repr__, :lift)
+  end
+
+  def unlift
+    @__tuply__ ? ::Lambda.new(@__repr__) : self
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: emanlib
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- emanrdesu
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Convenience methods and features, mostly done through monkey patching.
+email:
+- janitor@waifu.club
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/emanlib.rb
+- lib/patch/define.rb
+- lib/patch/foobar.rb
+- lib/patch/lambda.rb
+homepage: https://github.com/emanrdesu/lib
+licenses:
+- GPL-3.0-only
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.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: emanrdesu's personal library
+test_files: []