fun-ruby 0.0.1

data/lib/fun_ruby/common/helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../../fun_ruby"
+require_relative "../function"
+
+module FunRuby
+  module Common
+    # Helpers for shorting internal implementations
+    module Helpers
+      private
+
+      def curry_implementation(method_name, *args)
+        F::Function.curry(method("_#{method_name}")).(*args)
+      end
+    end
+  end
+
+  private_constant :Common
+end

data/lib/fun_ruby/container/define.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../container"
+require_relative "../container/resolve"
+
+module FunRuby
+  class Container
+    # @private
+    class Define
+      private_class_method :new
+
+      # @private
+      def self.build(container: FunRuby.container, namespaces: [])
+        raise TypeError, "namespaces: should be an array" unless namespaces.is_a?(::Array)
+        raise TypeError, "container: should be an instance of #{Container.name}" unless container.is_a?(Container)
+
+        namespaces = namespaces.map(&:to_s)
+        resolve = Resolve.build(
+          container: container,
+          aliases: (0...namespaces.size).reduce([]) do |combos, index|
+            [namespaces[0..index].join(NAMESPACE_SEPARATOR), *combos]
+          end
+        )
+        new(
+          container: container,
+          namespaces: namespaces,
+          resolve: resolve
+        )
+      end
+
+      # @private
+      def initialize(container:, namespaces:, resolve:)
+        @container = container
+        @namespaces = namespaces
+        @resolve = resolve
+      end
+
+      # @private
+      def namespace(namespace, &block)
+        self.class.build(container: container, namespaces: [*namespaces, namespace]).tap do |define|
+          define.instance_exec(&block)
+        end
+      end
+
+      # @private
+      def call(&block)
+        instance_exec(&block)
+      end
+
+      # @private
+      def function(key, &block)
+        if block.nil?
+          resolve.(key)
+        else
+          full_key = [*namespaces, key].join(NAMESPACE_SEPARATOR)
+          container.define(full_key, &block)
+        end
+      end
+      alias f function
+
+      private
+
+      attr_reader :container, :namespaces, :resolve
+    end
+  end
+end

data/lib/fun_ruby/container/mixin.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "resolve"
+
+module FunRuby
+  class Container
+    # @private
+    module Mixin
+      # @private
+      def self.build(aliases:)
+        mixin = Module.new
+        mixin.send(:define_method, :_resolve) { Resolve.build(aliases: aliases) }
+        mixin.send(:include, self)
+        mixin
+      end
+
+      private
+
+      def _resolve
+        @_resolve ||= Resolve.build
+      end
+
+      def f(key)
+        _resolve.(key)
+      end
+    end
+  end
+end

data/lib/fun_ruby/container/resolve.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module FunRuby
+  class Container
+    # @private
+    class Resolve
+      private_class_method :new
+
+      # @private
+      def self.build(aliases: [], container: FunRuby.container)
+        formatted = aliases.each_with_object({}) do |key, namespace|
+          if key.is_a?(::Hash)
+            namespace.merge!(key.map { |k, v| [k, v].map(&:to_s) }.to_h)
+          else
+            namespace[key.to_s] = nil
+          end
+        end
+        new(aliases: formatted.to_a.reverse.to_h, container: container)
+      end
+
+      # @private
+      def initialize(aliases:, container:)
+        @aliases = aliases
+        @container = container
+      end
+
+      # @private
+      def call(key)
+        key = key.to_s
+        aliases.each do |(namespace, shortcut)|
+          full_key = build_full_key(namespace, shortcut, key)
+          begin
+            return container.fetch(full_key)
+          rescue KeyError
+            next
+          end
+        end
+
+        container.fetch(key) do
+          raise KeyError, "key #{key.inspect} has not been registered"
+        end
+      end
+
+      private
+
+      def build_full_key(namespace, shortcut, key)
+        if shortcut.nil?
+          [namespace, key].join(NAMESPACE_SEPARATOR)
+        else
+          key.gsub(/(?<=\A|\.)#{shortcut}(?=\z|\.)/, namespace)
+        end
+      end
+
+      attr_reader :aliases, :container
+    end
+  end
+end

data/lib/fun_ruby/container.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "container/mixin"
+
+module FunRuby
+  # @private
+  class Container
+    NAMESPACE_SEPARATOR = "."
+    NOT_EVALUATED = Object.new.freeze
+
+    # @private
+    def initialize
+      @storage = {}
+      @mutex = Mutex.new
+    end
+
+    # @private
+    def define(key, &block)
+      key = key.to_s
+
+      raise KeyError, "#{key.inspect} is already defined" if storage.key?(key)
+      raise TypeError, "block should be given" unless block_given?
+
+      storage[key] = init_meta(block)
+    end
+
+    # @private
+    def fetch(key)
+      key = key.to_s
+      meta = storage.fetch(key)
+      value = storage[key].fetch(:value)
+      return value unless value.equal?(NOT_EVALUATED)
+
+      meta.fetch(:definition).().tap do |evaluated|
+        storage[key][:value] = evaluated
+      end
+    end
+
+    # @private
+    def import(*aliases)
+      Mixin.build(aliases: aliases)
+    end
+
+    private
+
+    attr_reader :storage, :mutex
+
+    def init_meta(definition)
+      {
+        definition: definition,
+        value: NOT_EVALUATED
+      }
+    end
+  end
+end

data/lib/fun_ruby/enum.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative "common/helpers"
+
+module FunRuby
+  # Module containing methods for enumerables
+  module Enum
+    include Common::Helpers
+
+    extend self
+
+    # Returns a boolean which represents if all results
+    # of applying a function to each element are truthy
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/1]
+    # @param enumerable [#to_enum]
+    #
+    # @return [Boolean]
+    #
+    # @example Basic returning true
+    #   F::Enum.all?(->(x) { x % 2 == 0 }, [2, 4, 6]) #=> true
+    #
+    # @example Basic returning false
+    #   F::Enum.all?(->(x) { x % 2 == 0 }, [2, 5, 6]) #=> false
+    #
+    # @example Curried
+    #   curried = F::Enum.all?
+    #   curried.(->(x) { x % 2 == 0 }).([1, 2, 3]) #=> false
+    #
+    # @example Curried with placeholder
+    #   curried = F::Enum.all?(F._, [2, 4, 6])
+    #   curried.(->(x) { x % 2 == 0 }) # => true
+    def all?(function = F._, enumerable = F._)
+      curry_implementation(:all?, function, enumerable)
+    end
+
+    # Applies a function to each element of an enumerable and
+    # returns the initial enumerable
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/1]
+    # @param enumerable [#to_enum]
+    #
+    # @return [::Array] the passed enumerable
+    #
+    # @example Basic
+    #   F::Enum.each(->(x) { puts x }, [1, 2, 3]) #=> [1, 2, 3]
+    #
+    # @example Curried
+    #   curried = F::Enum.each
+    #   curried.(->(x) { puts x }).([1, 2, 3]) #=> [1, 2, 3]
+    #
+    # @example Curried with placeholder
+    #   curried = F::Enum.each(F._, [1, 2, 3])
+    #   curried.(->(x) { puts x }) #=> [1, 2, 3]
+    def each(function = F._, enumerable = F._)
+      curry_implementation(:each, function, enumerable)
+    end
+
+    # Returns a new enumerable with new values calculated
+    # by applying a function to each element of a passed enumerable
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/1]
+    # @param enumerable [#to_enum]
+    #
+    # @return [::Array] a new enumerable with calculated values
+    #
+    # @example Basic
+    #   F::Enum.map(->(x) { x * 2 }, [1, 2, 3]) #=> [2, 4, 6]
+    #
+    # @example Curried
+    #   curried = F::Enum.map
+    #   curried.(->(x) { x * 2 }).([1, 2, 3]) #=> [2, 4, 6]
+    #
+    # @example Curried with placeholder
+    #   curried = F::Enum.map(F._, [1, 2, 3])
+    #   curried.(->(x) { x * 2 }) # => [2, 4, 6]
+    def map(function = F._, enumerable = F._)
+      curry_implementation(:map, function, enumerable)
+    end
+
+    # Returns a new enumerable containing only these elements
+    # results of calling a function on them are truthy
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/1]
+    # @param enumerable [#to_enum]
+    #
+    # @return [::Array] a new enumerable with selected values
+    #
+    # @example Basic
+    #   F::Enum.select(->(x) { x % 2 == 0 }, [1, 2, 3, 4, 5]) #=> [2, 4]
+    #
+    # @example Curried
+    #   curried = F::Enum.select
+    #   curried.(->(x) { x % 2 == 0 }).( [1, 2, 3, 4, 5]) #=> [2, 4]
+    #
+    # @example Curried with placeholder
+    #   curried = F::Enum.select(F._, [1, 2, 3, 4, 5])
+    #   curried.(->(x) { x % 2 == 0 }) #=> [2, 4]
+    def select(function = F._, enumerable = F._)
+      curry_implementation(:select, function, enumerable)
+    end
+
+    # Returns a single item by iterating through the list, successively
+    # calling the iterator function and passing it an accumulator value
+    # and the current value from the array, and then passing the result
+    # to the next call.
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/2] ->(accumulator, element) {}
+    # @param accumulator Object
+    # @param enumerable [#to_enum]
+    #
+    # @return Object a result of reducing the enumerable
+    #
+    # @example Basic: sum of all elements
+    #   F::Enum.reduce(->(acc, x) { acc + x }, 0, [1, 2, 3]) #=> 6
+    #
+    # @example Basic: subtraction of all elements
+    #   F::Enum.reduce(->(acc, x) { acc - x }, 0, [1, 2, 3]) #=> -6
+    #
+    # @example Basic: histogram
+    #   F::Enum.reduce(
+    #     ->(acc, x) { acc[x] += 1; acc },
+    #     Hash.new(0),
+    #     [1, 1, 1, 2, 2, 3]
+    #   ) #=> { 1 => 3, 2 => 2, 3 => 1 }
+    #
+    # @example Curried: sum
+    #   curried = F::Enum.reduce
+    #   curried.(->(acc, x) { acc + x }).(0).([1, 2, 3]) #=> 6
+    #
+    # @example Curried: sum with placeholder for function
+    #   curried = F::Enum.reduce(F._, 0, [1, 2, 3])
+    #   curried.(->(acc, x) { acc + x }) #=> 6
+    #
+    # @example Curried: sum with placeholder for accumulator
+    #   curried = F::Enum.reduce(->(acc, x) { acc + x }, F._, [1, 2, 3])
+    #   curried.(0) #=> 6
+    #
+    # @example Curried: sum with placeholder for function and accumulator
+    #   curried = F::Enum.reduce(F._, F._, [1, 2, 3])
+    #   curried.(->(acc, x) { acc + x }, 0) # => 6
+    #   curried.(->(acc, x) { acc + x }).(0) # => 6
+    def reduce(function = F._, accumulator = F._, enumerable = F._)
+      curry_implementation(:reduce, function, accumulator, enumerable)
+    end
+
+    # Goes through a given enumerable and count the amount of elements
+    # for which a passed function returned true
+    #
+    # @since 0.1.0
+    #
+    # @param function [#call/1] ->(item) { returns Boolean }
+    # @param enumerable [#to_enum]
+    #
+    # @return [Integer]
+    #
+    # @example Basic: count odd elements
+    #   F::Enum.count(->(x) { x % 2 == 1 }, [1, 2, 3]) #=> 2
+    #
+    # @example Curried: count odd elements
+    #   curried = F::Enum.count
+    #   curried.(->(x) { x % 2 == 1 }).([1, 2, 3]) #=> 2
+    #
+    # @example Curried with placeholder: count odd elements
+    #   curried = F::Enum.count(F._, [1, 2, 3])
+    #   curried.(->(x) { x % 2 == 1 }) #=> 2
+    #
+    #   curried = F::Enum.count(->(x) { x % 2 == 1 }, F._)
+    #   curried.([1, 2, 3]) #=> 2
+    def count(function = F._, enumerable = F._)
+      curry_implementation(:count, function, enumerable)
+    end
+
+    private
+
+    def _all?(function, enumerable)
+      _enum(enumerable).all?(&function)
+    end
+
+    def _each(function, enumerable)
+      _enum(enumerable).each(&function)
+    end
+
+    def _map(function, enumerable)
+      _enum(enumerable).map(&function)
+    end
+
+    def _select(function, enumerable)
+      _enum(enumerable).select(&function)
+    end
+
+    def _reduce(function, accumulator, enumerable)
+      _enum(enumerable).reduce(accumulator, &function)
+    end
+
+    def _count(function, enumerable)
+      _enum(enumerable).count(&function)
+    end
+
+    def _enum(enumerable)
+      enumerable.to_enum
+    end
+  end
+end

data/lib/fun_ruby/file.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module FunRuby
+  # Module containing methods for files
+  module File
+    include Common::Helpers
+
+    extend self
+
+    # Writes a given content to a given file
+    #
+    # @since 0.1.0
+    #
+    # @param filepath [::String]
+    # @param content [::String]
+    #
+    # @example Basics
+    #   tmp = Tempfile.new("file.txt")
+    #   F::File.write(tmp.path, "abc")
+    #   File.read(tmp.path) #=> "abc"
+    #   tmp.unlink
+    def write(filepath = F._, content = F._)
+      curry_implementation(:write, filepath, content)
+    end
+
+    private
+
+    def _write(filepath, content)
+      ::File.open(filepath, "w") { |file| file.write(content) }
+    end
+  end
+end

data/lib/fun_ruby/function.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "common/helpers"
+
+# Top-level
+module FunRuby
+  # Module for useful manipulations with functions
+  module Function
+    extend self
+
+    # Performs right-to-left function composition
+    #
+    # @since 0.1.0
+    #
+    # @param required [#call]
+    # @param *functions [#call]
+    #
+    # @return [#call]
+    #
+    # @example Basic: one function
+    #   plus_2 = ->(x) { x + 2 }
+    #
+    #   curried = F::Function.compose(plus_2)
+    #   curried.(2) # => 4
+    #
+    # @example Basic: two functions
+    #   plus_2 = ->(x) { x + 2 }
+    #   multiply_3 = ->(x) { x * 3 }
+    #
+    #   # multiplying -> adding
+    #   curried = F::Function.compose(plus_2, multiply_3)
+    #
+    #   curried.(2) # => 8
+    #
+    #   # adding ->  multiplying
+    #   curried = F::Function.compose(multiply_3, plus_2)
+    #
+    #   curried.(2) # => 12
+    #
+    # @example Basic: three functions
+    #   plus_2 = ->(x) { x + 2 }
+    #   multiply_3 = ->(x) { x * 3 }
+    #   mod_4 = ->(x) { x % 4 }
+    #
+    #   # multiplying -> adding -> mod
+    #   curried = F::Function.compose(mod_4, plus_2, multiply_3)
+    #   curried.(4) # => 2
+    def compose(required = F._, *functions)
+      curry(method(:_compose)).(required, *functions)
+    end
+
+    # Performs left-to-right function composition
+    #
+    # @since 0.1.0
+    #
+    # @param required [#call]
+    # @param *functions [#call]
+    #
+    # @return [#call]
+    #
+    # @example Basic: one function
+    #   plus_2 = ->(x) { x + 2 }
+    #
+    #   curried = F::Function.pipe(plus_2)
+    #   curried.(2) # => 4
+    #
+    # @example Basic: two functions
+    #   plus_2 = ->(x) { x + 2 }
+    #   multiply_3 = ->(x) { x * 3 }
+    #
+    #   # multiplying -> adding
+    #   curried = F::Function.pipe(multiply_3, plus_2)
+    #
+    #   curried.(2) # => 8
+    #
+    #   # adding ->  multiplying
+    #   curried = F::Function.pipe(plus_2, multiply_3)
+    #
+    #   curried.(2) # => 12
+    #
+    # @example Basic: three functions
+    #   plus_2 = ->(x) { x + 2 }
+    #   multiply_3 = ->(x) { x * 3 }
+    #   mod_4 = ->(x) { x % 4 }
+    #
+    #   # multiplying -> adding -> mod
+    #   curried = F::Function.pipe(multiply_3, plus_2,  mod_4)
+    #   curried.(4) # => 2
+    def pipe(required = F._, *functions)
+      curry(method(:_pipe)).(required, *functions)
+    end
+
+    # @example
+    #   build_ary = ->(a, b, c) { [a, b, c] }
+    #   curry = F::Function.curry
+    #   curried = curry.(build_ary)
+    #
+    #   curried.(1, 2, 3) # => [1, 2, 3]
+    #   curried.(1).(2).(3) # => [1, 2, 3]
+    #   curried.(F._, 2).(F._, 3).(1) # => [1, 2, 3]
+    #   curried.(F._, 2, F._).(1).(3) # => [1, 2, 3]
+    #   curried.(F._, F._, 3).(F._, 2).(1) # => [1, 2, 3]
+    #   curried.(F._, 2, F._).(1, 3) # => [1, 2, 3]
+    #   curried.(F._, 2, F._).(1, 3) # => [1, 2, 3]
+    def curry(function = F._)
+      handling_placeholders(method(:_curry).curry, [function])
+    end
+
+    private
+
+    def _pipe(required, *functions)
+      functions = [required, *functions]
+      functions.reduce do |composed, function|
+        ->(*args) { function.(composed.(*args)) }
+      end
+    end
+
+    def _compose(required, *functions)
+      _pipe(*functions, required)
+    end
+
+    def _curry(function)
+      handling_placeholders(function.curry)
+    end
+
+    def handling_placeholders(function, processed_args = [], *new_args)
+      processed_args, _ = new_args.reduce([processed_args, 0], &method(:apply_arg))
+      values, with_placeholders = bisect_args(processed_args)
+      result = function.(*values)
+      return result unless result.respond_to?(:call)
+
+      ->(*args) { handling_placeholders(result, with_placeholders, *args) }
+    end
+
+    def apply_arg((processed_args, shift), new_arg)
+      processed_args = processed_args.dup
+      placeholder_index = processed_args[shift..-1].to_a.index(F._)
+      if placeholder_index
+        real_position = placeholder_index + shift
+        processed_args[real_position] = new_arg
+        [processed_args, real_position + 1]
+      else
+        processed_args << new_arg
+        [processed_args, processed_args.size]
+      end
+    end
+
+    def bisect_args(args)
+      index = args.index(F._)
+      return [args, []] if index.nil?
+
+      values = args[0...index]
+      placeholders = args[index..-1] || []
+      [values, placeholders]
+    end
+  end
+end