fubby 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ad6780eea6f05146816180477723f9863c9d861e
+  data.tar.gz: 8381795af6662e96c9a84fe3669ca5b53f70b371
+SHA512:
+  metadata.gz: a458b1f8e734bce354a079dbafa4780231f9d0e5b1aae1897a61b0f36b4ee7292acd210f5e0ae7242f18a1fa81bdcd1ab366515d44d49763a26f2b2a8678cc37
+  data.tar.gz: 0a115ce3487eefcfcaca1c7492756c08399bea0d1d4697bd16d37d4f1f438ca4cdb0d4496f594b4b2d396bd35793dfb2989a9655c6608dfdc3efa7097b0e10bf

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.2)
+    minitest (5.8.4)
+    minitest-reporters (1.1.8)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    ruby-progressbar (1.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  minitest-reporters
+
+BUNDLED WITH
+   1.11.2

data/README.md

@@ -0,0 +1,3 @@
+# Fubby
+
+Functional library for ruby

data/fubby.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |gem|
+  gem.authors       = ['JaredShay']
+  gem.email         = ['jared.shay@gmail.com']
+  gem.description   = %q{Functional library for ruby}
+  gem.summary       = %q{Functional library for ruby}
+  gem.homepage      = 'https://github.com/jaredshay/fubby'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = 'fubby'
+  gem.require_paths = ['lib']
+  gem.version       = '0.0.0'
+  gem.license       = 'MIT'
+
+  gem.add_development_dependency 'miniest'
+  gem.add_development_dependency 'minitest-reporters'
+end

data/lib/fubby.rb

@@ -0,0 +1,7 @@
+require_relative './fubby/core'
+require_relative './fubby/std_lib'
+
+class F
+  extend Core
+  extend StdLib
+end

data/lib/fubby/array_utils.rb

@@ -0,0 +1,6 @@
+module ArrayUtils
+  # concat :: [a] -> [a] -> [a]
+  def concat
+    ->(a1, a2) { a1 + a2 }
+  end
+end

data/lib/fubby/core.rb

@@ -0,0 +1,62 @@
+module Core
+  # identity :: a -> a
+  def identity
+    ->(x) { x }
+  end
+
+  # curry :: (a -> b) -> (a -> b)
+  def curry
+    _curry = ->(f, *given_args) {
+      ->(*remaining_args) {
+        total_args = given_args + remaining_args
+
+        total_args.length == f.arity ? f.(*total_args) : _curry.(f, *total_args)
+      }
+    }
+
+    ->(f) {
+      ->(*x) {
+        f.arity == x.length ? f.(*x) : _curry.(f, *x)
+      }
+    }
+  end
+
+  # reduce :: a, (b -> a), [b] -> a
+  def reduce
+    curry.(->(memo, f, array) {
+      if memo == nil
+        case array.length
+        when 0 then nil
+        when 1 then array[0]
+        else reduce.(f.(array[0], array[1]), f, array[2..-1])
+        end
+      else
+        case array.length
+        when 0 then memo
+        else reduce.(f.(memo, array[0]), f, array[1..-1])
+        end
+      end
+    })
+  end
+
+  # TODO: figure out how to notate many args. [f] isn't correct here.
+  # compose :: [f] -> (a -> b)
+  def compose
+    ->(*f) {
+      _compose = ->(x, *f) {
+        f.length == 1 ? f[0].(x) : f[0].(_compose.(x, *f[1..-1]))
+      }
+
+      ->(x) { _compose.(x, *f) }
+    }
+  end
+
+  # flip :: (a -> b) -> (a -> b)
+  def flip
+    ->(f) {
+      ->(*args) {
+        f.(*reverse.(args))
+      }
+    }
+  end
+end

data/lib/fubby/std_lib.rb

@@ -0,0 +1,113 @@
+require_relative './core.rb'
+require_relative './array_utils.rb'
+
+module StdLib
+  C = Class.new { extend Core }
+  private_constant :C
+
+  A = Class.new { extend ArrayUtils }
+  private_constant :A
+
+  # length :: [a] -> Number
+  def length
+    ->(x) {
+      C.reduce.(0, ->(memo, _) { memo + 1 }, x)
+    }
+  end
+
+  # map :: (a -> b) -> [a] -> [b]
+  def map
+    C.curry.(
+      ->(f, x) {
+        fx = ->(memo, x) {
+          A.concat.(memo, [f.(x)])
+        }
+
+        C.reduce.([], fx, x)
+      }
+    )
+  end
+
+  # select :: (a -> Bool) -> [a] -> [a]
+  def select
+    C.curry.(
+      ->(f, x) {
+        fx = ->(memo, x) {
+          f.(x) == true ? A.concat.(memo, [x]) : memo
+        }
+
+        C.reduce.([], fx, x)
+      }
+    )
+  end
+
+  # reject :: (a -> Bool) -> [a] -> [a]
+  def reject
+    C.curry.(->(f, x) { x - select.(f, x) })
+  end
+
+  # any :: (a -> Bool) -> Bool
+  def any
+    C.curry.(
+      ->(f, x) {
+        fx = ->(memo, x) {
+          f.(x) ? true : memo
+        }
+
+        C.reduce.(fx, x, false)
+      }
+    )
+  end
+
+  # any :: (a -> Bool) -> Bool
+  def f_all
+    C.curry.(
+      ->(f, x) {
+        !any.(->(x) { x == false }, map.(f, x))
+      }
+    )
+  end
+
+  # add :: Int -> Int -> Int
+  def add
+    ->(x, y) { x + y }
+  end
+
+  # head :: [a] -> a
+  def head
+    ->(x) { x[0] }
+  end
+
+  # reverse :: [a] -> [a]
+  def reverse
+    ->(array) {
+      if array.empty? || length.(array) == 1
+        array
+      else
+        add.(reverse.(array[1..-1]), array[0])
+      end
+    }
+  end
+
+  # tail :: [a] -> a
+  def tail
+    C.compose.(head, reverse)
+  end
+
+  # TODO: figure out how to handle Strings and Chars
+  def str_head
+    ->(x) { x[0] }
+  end
+
+  # TODO implement this without `downcase`
+  # downcase :: String -> String
+  def downcase
+    ->(x) { x.downcase }
+  end
+
+  # TODO implement this without `capitalize`
+  # downcase :: String -> String
+  def upcase
+    ->(x) { x.capitalize }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "minitest/autorun"
+require "minitest/reporters"
+
+Minitest::Reporters.use!(Minitest::Reporters::DefaultReporter.new)

data/test/unit/core_test.rb

@@ -0,0 +1,130 @@
+require_relative '../test_helper.rb'
+require_relative '../../lib/fubby/core.rb'
+
+class T
+  extend Core
+end
+
+module Test
+  class IdentityTest < MiniTest::Test
+    def test_success
+      assert_equal 'x', T.identity.('x')
+    end
+
+    def test_fail
+      assert 'x' != T.identity.('y')
+    end
+  end
+
+  class CurryTest < MiniTest::Test
+    def test_defining_a_method_with_no_args
+      f = T.curry.(-> { 'x' })
+
+      assert_equal 'x', f.()
+    end
+
+    def test_defining_a_method_with_one_argument
+      f = T.curry.(->(x) { x })
+
+      assert_equal 'x', f.('x')
+      assert_equal 'x', f.().('x')
+      assert_equal 'x', f.().().('x')
+    end
+
+    def test_defining_a_method_with_two_arguments
+      f = T.curry.(->(x, y) { x + y })
+
+      assert_equal 3, f.(1, 2)
+      assert_equal 3, f.().(1, 2)
+      assert_equal 3, f.().().(1, 2)
+      assert_equal 3, f.(1).(2)
+      assert_equal 3, f.().(1).(2)
+      assert_equal 3, f.(1).().(2)
+      assert_equal 3, f.(1).().().(2)
+      assert_equal 3, f.().(1).().(2)
+      assert_equal 3, f.().(1).().().(2)
+    end
+
+    def test_defining_a_method_with_three_arguments
+      f = T.curry.(->(x, y, z) { x + y + z })
+
+      assert_equal 6, f.(1, 2, 3)
+      assert_equal 6, f.().(1, 2, 3)
+      assert_equal 6, f.().().(1, 2, 3)
+      assert_equal 6, f.(1, 2).(3)
+      assert_equal 6, f.().(1, 2).(3)
+      assert_equal 6, f.().(1, 2).().(3)
+      assert_equal 6, f.(1, 2).().(3)
+      assert_equal 6, f.(1).(2, 3)
+      assert_equal 6, f.().(1).(2, 3)
+      assert_equal 6, f.().(1).().(2, 3)
+      assert_equal 6, f.(1).(2).(3)
+      assert_equal 6, f.().(1).(2).(3)
+      assert_equal 6, f.().(1).().(2).(3)
+      assert_equal 6, f.().(1).().(2).().(3)
+      assert_equal 6, f.(1).().(2).(3)
+      assert_equal 6, f.(1).().(2).().(3)
+      assert_equal 6, f.(1).(2).().(3)
+    end
+  end
+
+  class ReduceTest < MiniTest::Test
+    def test_reducing_a_zero_element_array_with_no_memo
+      assert_equal nil, T.reduce.(nil, ->(x, y) { x + y }, [])
+    end
+
+    def test_reducing_a_zero_element_array_with_a_memo
+      assert_equal 'memo', T.reduce.('memo', ->(x, y) { x + y }, [])
+    end
+
+    def test_reducing_a_one_element_array_with_no_memo
+      assert_equal 1, T.reduce.(nil, ->(x, y) { x + y }, [1])
+    end
+
+    def test_reducing_a_one_element_array_with_a_memo
+      assert_equal 2, T.reduce.(1, ->(x, y) { x + y }, [1])
+    end
+
+    def test_reducing_a_two_element_array_with_no_memo
+      assert_equal 3, T.reduce.(nil, ->(x, y) { x + y }, [1, 2])
+    end
+
+    def test_reducing_a_two_element_array_with_a_memo
+      assert_equal 6, T.reduce.(1, ->(x, y) { x + y }, [2, 3])
+    end
+
+    def test_reducing_a_three_element_array_with_no_memo
+      assert_equal 6, T.reduce.(nil, ->(x, y) { x + y }, [1, 2, 3])
+    end
+
+    def test_reducing_a_three_element_array_with_a_memo
+      assert_equal 10, T.reduce.(1, ->(x, y) { x + y }, [2, 3, 4])
+    end
+
+    def test_currying
+      sum = T.reduce.(nil, ->(x, y) { x + y })
+
+      assert_equal 6, sum.([1, 2, 3])
+    end
+  end
+
+  class ComposeTest < MiniTest::Test
+    def test_composing_a_single_function
+      f = T.compose.(->(x) { x })
+
+      assert_equal 'x', f.('x')
+    end
+
+    def test_composing_two_functions
+      f = T.compose.(->(x) { x + 1 }, ->(x) { x * 2 })
+
+      assert_equal 5, f.(2)
+    end
+
+    def test_composing_three_functions
+      f = T.compose.(->(x) { x + 1 }, ->(x) { x * 2 }, ->(x) { x + 3 })
+
+      assert_equal 11, f.(2)
+    end
+  end
+end

data/test/unit/std_lib_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper.rb'
+require_relative '../../lib/fubby/std_lib.rb'
+
+class T
+  extend StdLib
+end
+
+class LengthTest < MiniTest::Test
+  def test_zero_length_array
+    assert_equal 0, T.length.([])
+  end
+
+  def test_array_with_one_element
+    assert_equal 1, T.length.([1])
+  end
+
+  def test_array_with_two_elements
+    assert_equal 2, T.length.(['a', 'b'])
+  end
+
+  def test_array_with_three_elements
+    assert_equal 3, T.length.([1, 2, 3])
+  end
+end
+
+class MapTest < MiniTest::Test
+  def test_zero_length_array
+    assert_equal [], T.map.(->(x) { x }, [])
+  end
+
+  def test_array_with_one_element
+    assert_equal [2], T.map.(->(x) { x + 1 }, [1])
+  end
+
+  def test_currying
+    double = T.map.(->(x) { x * 2 })
+
+    assert_equal [2, 4], double.([1, 2])
+  end
+end
+
+class SelectTest < MiniTest::Test
+  def test_zero_length_array
+    assert_equal [], T.select.(->(x) { x == 1 }, [])
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: fubby
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- JaredShay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: miniest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Functional library for ruby
+email:
+- jared.shay@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- fubby.gemspec
+- lib/fubby.rb
+- lib/fubby/array_utils.rb
+- lib/fubby/core.rb
+- lib/fubby/std_lib.rb
+- test/test_helper.rb
+- test/unit/core_test.rb
+- test/unit/std_lib_test.rb
+homepage: https://github.com/jaredshay/fubby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Functional library for ruby
+test_files:
+- test/test_helper.rb
+- test/unit/core_test.rb
+- test/unit/std_lib_test.rb