feldspar 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9231039dc87d5d92019e68daae54d25a33b55d4f
+  data.tar.gz: 63dc198359931c4a147e1195006a9f7fd00cdcd3
+SHA512:
+  metadata.gz: 93e7050ca8e12c84cce36c406273cda60ac83fa4f2d23dcfeb25fdfebf880b738a948efa24046e3ad3a07b69fbde2a9803eb201a777b906c8f1c56526e7d8da0
+  data.tar.gz: bd1ba6210612ebd42433afc64b35e28c4b0cbaf373523ccde06fe3856b9ba16c875f84b54fc9d8abaf013482df2267993c23ad21d2bcbb6d9b5252ce38802e9c

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.gitconfig_local

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.3
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in feldspar.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: .
+  specs:
+    feldspar (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  feldspar!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/README.md

@@ -0,0 +1,35 @@
+# Feldspar
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/feldspar`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'feldspar'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install feldspar
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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 tags, 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/[USERNAME]/feldspar.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "feldspar"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/feldspar.gemspec

@@ -0,0 +1,26 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "feldspar/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "feldspar"
+  spec.version       = Feldspar::VERSION
+  spec.authors       = ["Conner Bryan"]
+  spec.email         = ["conner@amps.io"]
+
+  spec.summary       = %q{functional ruby}
+  # spec.description   = %q{TODO: Write a longer description or delete this line.}
+  # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/feldspar.rb

@@ -0,0 +1,18 @@
+require "feldspar/add"
+require "feldspar/always"
+require "feldspar/add_index"
+require "feldspar/adjust"
+require "feldspar/all"
+require "feldspar/all_pass"
+require "feldspar/curry"
+require "feldspar/identity"
+require "feldspar/filter"
+require "feldspar/map"
+require "feldspar/version"
+require "feldspar/splitme"
+
+
+module Feldspar
+end
+
+F = Feldspar

data/lib/feldspar/add.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def add(x, y)
+        x + y
+    end
+end

data/lib/feldspar/add_index.rb

@@ -0,0 +1,15 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def add_index(iteration_fn)
+        curry(-> (fn, list) {
+            i = 0
+            iteration_fn.(-> (x) {
+                r = fn.(x, i)
+                i = i + 1
+                r
+            }, list)
+        })
+    end
+end

data/lib/feldspar/adjust.rb

@@ -0,0 +1,10 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def adjust(fn, index, list)
+        copy = Array.new(list)
+        copy[index] = fn.(copy[index])
+        copy
+    end
+end

data/lib/feldspar/all.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def all?(fn, list)
+        list.all? { |x| fn.(x) }
+    end
+end

data/lib/feldspar/all_pass.rb

@@ -0,0 +1,12 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def all_pass(fns)
+        curry(-> (x) {
+            fns.reduce(true) { |memo, fn|
+                memo && fn.(x)
+            }
+        })
+    end
+end

data/lib/feldspar/always.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def always(x)
+        -> *args { x }
+    end
+end

data/lib/feldspar/curry.rb

@@ -0,0 +1,91 @@
+module Feldspar
+    module_function
+    def curry(fn)
+        # TODO: handle varargs after fixed args: (*a, b) or (a, *b, c)
+        if fn.arity == -1
+            fn
+        elsif fn.arity > 0
+            curry_n(fn.arity, fn)
+        else
+            fn.curry
+        end
+    end
+
+    def curry_n(n, fn)
+        if n == -1
+            -> *args { fn.(*args) }
+        else
+            _curry_n(n, [], fn)
+        end
+    end
+
+    def _curry_n(n, received, fn)
+        -> *args {
+            combined = []
+            args_index = 0
+            left = n
+            combined_index = 0
+            while(combined_index < received.length || args_index < args.length)
+                result = if combined_index < received.length && (!is_placeholder(received[combined_index]) || args_index >= args.length)
+                    result = received[combined_index]
+                else
+                    result_arg_index = args_index
+                    args_index = args_index + 1
+                    result = args[result_arg_index]
+                end
+                combined[combined_index] = result
+                if !is_placeholder(result)
+                    left = left - 1
+                end
+                combined_index = combined_index + 1
+            end
+            if left <= 0
+                fn.call(*combined)
+            else
+                _curry_n(n, combined, fn)
+                # _arity(left, )
+            end
+        }
+    end
+
+    def _arity(n, fn)
+        case n
+            when 0; -> { fn.() }
+            when 1; -> a { fn.(a) }
+            when 2; -> a, b { fn.(a, b) }
+            when 3; -> a, b, c { fn.(a, b, c) }
+            when 4; -> a, b, c, d { fn.(a, b, c, d) }
+            when 5; -> a, b, c, d, e { fn.(a, b, c, d, e) }
+            when 6; -> a, b, c, d, e, f { fn.(a, b, c, d, e, f) }
+            when 7; -> a, b, c, d, e, f, g { fn.(a, b, c, d, e, f, g) }
+            when 8; -> a, b, c, d, e, f, g, h { fn.(a, b, c, d, e, f, g, h) }
+            when 9; -> a, b, c, d, e, f, g, h, i { fn.(a, b, c, d, e, f, g, h, i) }
+            when 10; -> a, b, c, d, e, f, g, h, i, j { fn.(a, b, c, d, e, f, g, h, i, j) }
+            else; raise "Cannot create function arity > 10."
+        end
+    end
+
+    def is_placeholder(x)
+        x == :__feldspar__underscore
+    end
+
+    def curry_inject(target, meth)
+        target.instance_eval do
+            method_object = instance_method(meth)
+            define_singleton_method(meth, curry(method_object.bind(self)))
+        end
+    end
+
+
+    def curry_functions
+        @curry_calls_internal = false
+        def self.method_added(meth)
+            unless @curry_calls_internal
+                @curry_calls_internal = true
+                Feldspar::curry_inject(self, meth)
+                @curry_calls_internal = false
+            end
+        end
+    end
+
+end

data/lib/feldspar/filter.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def filter(fn, list)
+        list.select { |x| fn.(x) }
+    end
+end

data/lib/feldspar/identity.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def identity(x)
+        x
+    end
+end

data/lib/feldspar/map.rb

@@ -0,0 +1,16 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def map(fn, list)
+        if list.is_a?(Array)
+            list.map { |x| fn.(x) }
+        elsif list.is_a?(Hash)
+            list.map { |k, v| [k, fn.(v)] }.to_h
+        elsif list.respond_to?(:map)
+            list.map { |x| fn.(x) }
+        else
+            nil
+        end
+    end
+end

data/lib/feldspar/reject.rb

@@ -0,0 +1,8 @@
+require "feldspar/curry"
+
+module Feldspar
+    curry_functions
+    def reject(fn, list)
+        list.reject { |x| fn.(x) }
+    end
+end

data/lib/feldspar/splitme.rb

@@ -0,0 +1,1486 @@
+require "feldspar/curry"
+require "set"
+
+module Feldspar
+
+    curry_functions
+
+    def and(x, y)
+        x && y
+    end
+
+    def __
+        :__feldspar__underscore
+    end
+
+    def abs(x)
+        x.abs
+    end
+
+    def any?(predicate, list)
+        list.any? { |x| predicate.(x) }
+    end
+
+    def any_pass(fns)
+        curry(-> (x) {
+            fns.reduce(false) { |memo, fn|
+                memo || fn(x)
+            }
+        })
+    end
+
+    def ap(fns, list)
+        reduce(-> (memo, item) {
+            memo + fns.map { |fn| fn.(item) }
+        }, [], list)
+    end
+
+    def aperture(size, list)
+        list.each_slice(size).to_a
+    end
+
+    def append(item, list)
+        clone(list).push(item)
+    end
+
+    def apply(fn, list)
+        fn.call(*list)
+    end
+
+    def apply_spec(spec)
+        curry(-> *args {
+            spec.map { |k, fn|
+                v = if fn.is_a?(Hash)
+                        apply_spec.(fn).(*args)
+                    else
+                        apply(fn, args)
+                    end
+                [k, v]
+            }.to_h
+        })
+    end
+
+    def apply_to(value, fn)
+        fn.(value)
+    end
+
+    def thrush(value, fn)
+        apply_to.(value, fn)
+    end
+
+    def ascend(ord_fn, x, y)
+        ax = ord_fn.(x)
+        bx = ord_fn.(y)
+        if ax < bx
+            -1
+        elsif ax > bx
+            1
+        else
+            0
+        end
+    end
+
+    def assoc(key, value, hash)
+        copy = clone(hash)
+        copy[key] = value
+        copy
+    end
+
+    def assoc_path(path, value, hash)
+        copy = clone(hash)
+        nested = path[0, path.length - 1].reduce(copy) { |memo, n|
+            memo[n]
+        }
+        nested[path[-1]] = value
+        copy
+    end
+
+    def binary(fn)
+        n_ary(2, fn)
+    end
+
+    def bind()
+        raise "TODO" # even possible?
+    end
+
+    def both?(xfn, yfn, value)
+        xfn.(value) && yfn.(value)
+    end
+
+    def call(fn, *args)
+        apply.(fn, args)
+    end
+
+    def chain(fn, list)
+        flat_map.(fn, list)
+    end
+
+    def clamp(min, max, value)
+        if value < min
+            min
+        elsif value > max
+            max
+        else
+            value
+        end
+    end
+
+    def clone(value)
+        if value.is_a?(Hash)
+            value.map { |k, v| [clone.(k), clone.(v)] }.to_h
+        elsif value.is_a?(Array)
+            value.map { |v| clone(v) }.to_a
+        elsif value.respond_to?(:clone)
+            value.clone
+        else
+            value
+        end
+    end
+
+    def compact(list)
+        if list.respond_to?(:compact)
+            list.compact
+        else
+            filter(is_nil?, list)
+        end
+    end
+
+    def comparator(predicate)
+        curry(-> a, b {
+            if predicate.(a, b)
+                -1
+            elsif predicate.(b, a)
+                1
+            else
+                0
+            end
+        })
+    end
+
+    def complement(fn)
+        curry(-> x {
+            !(fn.(x))
+        })
+    end
+
+    def compose(*fns, fn)
+        curry_n(fn.arity, -> *args {
+            seed = fn.(*args)
+            fns.reverse.reduce(seed) { |memo, f|
+                f.(memo)
+            }
+        })
+    end
+
+    def compose_k(*fns, fn)
+        wrapped = map(flat_map, fns)
+        compose(*wrapped, fn)
+    end
+
+    def compose_p(*fns)
+        raise "TODO"
+    end
+
+    def concat(list_x, list_y)
+        # `.concat` covers `Array` and `String`
+        if list_x.respond_to?(:concat)
+            list_x.concat(list_y)
+        elsif list_x.is_a?(Hash)
+            list_x.merge(list_y)
+        else
+            raise "Cannot concat #{list_x.class} and #{list_y.class}. Consider adding a `concat` method to #{list_x.class}."
+        end
+    end
+
+    def cond(logic_pairs)
+        curry(-> x {
+            pair = logic_pairs.find { |k, v| k.(x) }
+            if pair.nil?
+                nil
+            else
+                pair.last.(x)
+            end
+        })
+    end
+
+    def construct(cons)
+        if cons.respond_to?(:new)
+            meth = cons.method(:new)
+            curry_n(meth.arity, meth)
+        else
+            raise "Invalid constructor (`#{cons}`). Constructor should respond to `.new`."
+        end
+    end
+
+    def construct_n(n, cons)
+        if cons.respond_to?(:new)
+            meth = cons.method(:new)
+            curry_n(n, meth)
+        else
+            raise "Invalid constructor (`#{cons}`). Constructor should respond to `.new`."
+        end
+    end
+
+    def contains?(value, list)
+        include?(value, list)
+    end
+
+    def include?(value, list)
+        list.include?(value)
+    end
+
+    def converge(fn, branch_fns)
+        -> *args {
+            branched = ap(branch_fns, args)
+            fn.(*branched)
+        }
+    end
+
+    def count_by(fn, list)
+        compose(map.(length), group_by(fn)).(list)
+    end
+
+    def dec(x)
+        x - 1
+    end
+
+    def default_to(default, x)
+        if is_nil_like?(x) then default else x end
+    end
+
+    def descend(ord_fn, x, y)
+        ax = ord_fn.(x)
+        bx = ord_fn.(y)
+        if ax > bx
+            -1
+        elsif ax < bx
+            1
+        else
+            0
+        end
+    end
+
+    def difference(listx, listy)
+        if listx.is_a?(Array)
+            Set.new(listx - listy)
+        else
+            raise "Cannot find difference for #{listx.class}."
+        end
+    end
+
+    def difference_with(cmp, listx, listy)
+        listy_mapping = listy.map { |x| cmp.(x) }
+        Set.new(listx.select { |x|
+            mapping = cmp.(x)
+            !listy_mapping.include?(mapping)
+        })
+    end
+
+    def dissoc(key, hash)
+        copy = clone(hash)
+        copy.delete(key)
+        copy
+    end
+
+    def div(x, y)
+        x / y
+    end
+
+    def drop(n, list)
+        list.drop(n)
+    end
+
+    def drop_last(n, list)
+        compose(reverse, drop(n), reverse).(list)
+    end
+
+    def drop_last_while(fn, list)
+        compose(reverse, drop_while(fn), reverse).(list)
+    end
+
+    def drop_repeats(list)
+        add_index(filter).(-> x, i {
+            if i == 0 then true else list[i - 1] != x end
+        }).(list)
+    end
+
+    def drop_repeats_with(fn, list)
+        mapping = list.map { |x| fn.(x) }
+        add_index(filter).(-> x, i {
+            if i == 0 then true else mapping[i] != mapping[i - 1] end
+        }).(list)
+    end
+
+    def drop_while(fn, list)
+        list.drop_while { |x| fn.(x) }
+    end
+
+    def either(fn_a, fn_b, x)
+        fn_a.(x) || fn_b.(x)
+    end
+
+    def empty(x)
+        if value.is_a?(Hash)
+            {}
+        elsif value.is_a?(Array)
+            []
+        elsif value.is_a?(String)
+            ""
+        elsif value.respond_to?(:empty)
+            value.empty
+        else
+            value
+        end
+    end
+
+    def ends_with?(x, list)
+        if list.is_a?(String)
+            list[negate(x.length), x.length] == x
+        elsif list.is_a?(Array)
+            list[negate(x.length), x.length] == x
+        else
+            raise "Cannot check `ends_with?` for #{list.class}"
+        end
+    end
+
+    def eq_by?(fn, x, y)
+        fn.(x) == fn.(y)
+    end
+
+    def eq_props?(key, x, y)
+        x[key] == y[key]
+    end
+
+    def equal?(x, y)
+        if x.respond_to?(:equal?) && y.respond_to?(:equal?)
+            x.equal?(y) && y.equal?(x)
+        elsif x.respond_to?(:equal?)
+            x.equal?(y)
+        elsif y.respond_to?(:equal?)
+            y.equal?(x)
+        else
+            x == y
+        end
+    end
+
+    def evolve(transformations, hash)
+        hash.map { |k, v|
+            transformed = if transformations.has_key?(k)
+                if v.is_a?(Hash)
+                    evolve(transformations[k], v)
+                else
+                    transformations[k].(v)
+                end
+            else
+                v
+            end
+            [k, transformed]
+        }.to_h
+    end
+
+    def f(*args)
+        false
+    end
+
+    def filter(fn, list)
+        if list.is_a?(Array)
+            list.select { |x| fn.(x) }
+        elsif list.is_a?(Hash)
+            list.select { |k, v| [k, fn.(v)] }.to_h
+        else
+            nil
+        end
+    end
+
+    def find(fn, list)
+        if list.respond_to?(:find)
+            list.find { |x| fn.(x) }
+        else
+            raise "Cannot `find` on #{list.class}"
+        end
+    end
+
+    def find_index(fn, list)
+        if list.respond_to?(:find_index)
+            list.find_index { |x| fn.(x) }
+        else
+            raise "Cannot `find_index` on #{list.class}"
+        end
+    end
+
+    def find_last(fn, list)
+        rev = reverse(list)
+        if rev.respond_to?(:find)
+            rev.find { |x| fn.(x) }
+        else
+            raise "Cannot `find_last` on #{list.class}"
+        end
+    end
+
+    def find_last_index(fn, list)
+        rev = reverse(list)
+        if list.respond_to?(:find_index)
+            index = rev.find_index { |x| fn.(x) }
+            list.length - index - 1
+        else
+            raise "Cannot `find_last_index` on #{list.class}"
+        end
+    end
+
+    # alias
+    def select(fn, list)
+        filter(fn, list)
+    end
+
+    def flat_map(fn, list)
+        compose(flatten, map(fn)).(list)
+    end
+
+    def flatten(list)
+        list.flatten(1)
+    end
+
+    def flip(fn)
+        curry_n(fn.arity, -> a, b, *c {
+            args = [b, a] + c
+            apply(fn, args)
+        })
+    end
+
+    def each(fn, list)
+        if list.respond_to?(:each)
+            list.each { |x| fn.(x) }
+        else
+            raise "Cannot `each` on #{list.class}"
+        end
+    end
+
+    def from_pairs(pairs)
+        pairs.reduce({}) { |memo, x|
+            memo[x[0]] = x[1]
+            memo
+        }
+    end
+
+    def group_by(fn, list)
+        list.reduce({}) { |memo, x|
+            mapping = fn.(x)
+            map = if memo.has_key?(mapping) then memo[mapping] else [] end
+            map.push(x)
+            memo[mapping] = map
+            memo
+        }
+    end
+
+    def group_with(fn, list)
+        group_by(fn, list).values
+    end
+
+    def >(x, y)
+        x > y
+    end
+
+    def >=(x, y)
+        x >= y
+    end
+
+    def <(x, y)
+        x < y
+    end
+
+    def <=(x, y)
+        x <= y
+    end
+
+    def has?(key, x)
+        x.has_key?(key)
+    end
+
+    def head(list)
+        list[0]
+    end
+
+    def first(list)
+        head(list)
+    end
+
+    def identical?(x, y)
+        object_id(x) == object_id(y)
+    end
+
+    def if_else(cond, true_fn, false_fn, x)
+        if cond.(x)
+            true_fn.(x)
+        else
+            false_fn.(x)
+        end
+    end
+
+    def inc(x)
+        x + 1
+    end
+
+    def index_by(fn, list)
+        compose(
+            map(last),
+            group_by(fn)
+        ).(list)
+    end
+
+    def init(list)
+        if list.length == 0
+           []
+        else
+            list[0, list.length - 1]
+        end
+    end
+
+    def inner_join(pred, xs, ys)
+        filter(-> x {
+            contains_with?(pred, x, ys)
+        }, xs)
+    end
+
+    def contains_with?(pred, x, list)
+        index = 0
+        l = list.length
+        while index < l
+            if pred.(x, list[index])
+                return true
+            end
+            index = index + 1
+        end
+        false
+    end
+
+    def insert(index, x, list)
+        list.insert(index, x)
+    end
+
+    def insert_all(index, xs, list)
+        list.insert(index, *xs)
+    end
+
+    def intersection(x, y)
+        Set.new(x & y)
+    end
+
+    def &(x, y)
+        intersection(x, y)
+    end
+
+    def intersperse(x, xs)
+        compose(flatten, map_indexed(-> y, i {
+            if i > 0 then [x, y] else [y] end
+        })).(xs)
+    end
+
+    def into(acc, xf, list)
+        raise "TODO"
+    end
+
+    def invert(x)
+        found = {}
+        invert_obj_by(-> key, existing, value {
+            if found.has_key?(key)
+                state = found[key]
+                base = if state == 1
+                    base = [existing]
+                elsif state == 2
+                    base = existing
+                end
+                found[key] = 2
+                base.push(value)
+                base
+            else
+                found[key] = 1
+                value
+            end
+        }, x)
+    end
+
+    def invert_obj(x)
+        invert_obj_by(-> key, existing, value {
+            value
+        }, x)
+    end
+
+    def invert_obj_by(fn, x)
+        if x.is_a?(String)
+            invert_obj_by(fn, x.split(""))
+        elsif x.is_a?(Array)
+            invert_obj_by(fn, Hash[(0...x.size).zip x])
+        elsif x.is_a?(Hash)
+            x.keys.reduce({}) { |memo, y|
+                original_value = x[y]
+                existing_value = if memo.has_key?(original_value)
+                    memo[original_value]
+                else
+                    nil
+                end
+                value = fn.(original_value, existing_value, y)
+                memo[original_value] = value
+                memo
+            }
+        else
+            raise "Cannot invert a `#{x.class}`"
+        end
+    end
+
+    def invoker(arity, meth)
+        curry_n(arity + 1, -> *args, target {
+            target.public_send(meth, *args)
+        })
+    end
+
+    def is_a?(t, x)
+        x.is_a?(t)
+    end
+
+    def is_empty?(x)
+        if x.is_a?(Array)
+            x.length == 0
+        elsif x.is_a?(String)
+            x.length == 0
+        elsif x.is_a?(Hash)
+            x.length == 0
+        else
+            x.nil?
+        end
+    end
+
+    def is_nil_like?(x)
+        is_nil?(x) || is_nan?(x)
+    end
+
+    def is_nil?(x)
+        x.nil?
+    end
+
+    def is_nan?(x)
+        x.is_a?(Float) && x.nan?
+    end
+
+    def join(separator, list)
+        list.join(separator)
+    end
+
+    def juxt(fns)
+        -> *args {
+            fns.map { |fn|
+                apply(fn, args)
+            }
+        }
+    end
+
+    def keys(x)
+        x.keys
+    end
+
+    def last(list)
+        list[-1]
+    end
+
+    def last_index_of(x, list)
+        find_last_index(equal?(x), list)
+    end
+
+    def length(x)
+        x.length
+    end
+
+    Lens = Struct.new(:getter, :setter)
+
+    def lens(getter, setter)
+        Lens.new(getter, setter)
+    end
+
+    def lens_index(index)
+        lens(nth(index), update(index))
+    end
+
+    def lens_path(p)
+        lens(path(p), assoc_path(p))
+    end
+
+    def lens_prop(key)
+        lens(prop(key), assoc(key))
+    end
+
+    def lift(fn)
+        lift_n(fn.arity, fn)
+    end
+
+    def lift_n(arity, fn)
+        lifted = curry_n(arity, fn)
+        curry_n(arity, -> arg, *args {
+            reduce(ap, map(lifted, arg), args)
+        })
+    end
+
+    def map_indexed(fn, xs)
+        add_index(map).(fn, xs)
+    end
+
+    def map_accum(fn, acc, list)
+        memo = acc
+        result = map(-> (x) {
+            memo, r = fn.(memo, x)
+            r
+        }, list)
+        [memo, result]
+    end
+
+    def map_accum_right(fn, acc, list)
+        result = []
+        index = list.length - 1
+        tuple = [acc]
+        while index >= 0
+            tuple = fn.(list[index], tuple[0])
+            result[index] = tuple[1]
+            index = index - 1
+        end
+        [result, tuple[0]]
+    end
+
+    def map_hash_indexed(fn, hash)
+        hash.reduce({}) { |memo, x|
+            k, v = x
+            memo[k] = fn.(v, k, hash)
+            memo
+        }
+    end
+
+    def match(pattern, x)
+        if x.is_a?(String)
+            x.scan(pattern).map { |m| m[0] }
+        else
+            pattern.match(x).to_a
+        end
+    end
+
+    def %(x, y)
+        x % y
+    end
+
+    def max(x, y)
+        if x > y then x else y end
+    end
+
+    def max_by(fn, list)
+        list.map { |x| [fn.(x), x] }
+            .to_h
+            .sort
+            .last[1]
+    end
+
+    def mean(list)
+        sum(list) / list.length
+    end
+
+    def median(list)
+        sorted = list.sort
+        half = (list.length / 2).round
+        sorted[half]
+    end
+
+    def memoize(cache_fn, fn)
+        cache = {}
+        _arity(fn.arity, -> *args {
+            key = cache_fn.(*args)
+            if cache.has_key?(key)
+                cache[key]
+            else
+                result = fn.(*args)
+                cache[key] = result
+                result
+            end
+        })
+    end
+
+    def merge(x, y)
+        merge_with(-> existing, value { value }, x, y)
+    end
+
+    def merge_all(hashes)
+        reduce(merge, {}, hashes)
+    end
+
+    def merge_deep_left(x, y)
+        merge_deep_with(-> existing, value { existing }, x, y)
+    end
+
+    def merge_deep_right(x, y)
+        merge_deep_with(-> existing, value { value }, x, y)
+    end
+
+    def merge_deep_with(fn, x, y)
+        merge_deep_with_key(-> key, existing, value { fn.(existing, value) }, x, y)
+    end
+
+    def merge_deep_with_key(fn, x, y)
+        reduce(-> memo, n {
+            key, value = n
+            memo[key] = if memo.has_key?(key)
+                existing = memo[key]
+                if existing.is_a?(Hash)
+                    merge_deep_with_key(fn, existing, value)
+                else
+                    fn.(key, existing, value)
+                end
+            else
+                value
+            end
+            memo
+        }, clone(x), y)
+    end
+
+    def merge_with(fn, x, y)
+        merge_with_key(-> key, existing, value { fn.(existing, value) }, x, y)
+    end
+
+    def merge_with_key(fn, x, y)
+        reduce(-> memo, n {
+            key, value = n
+            memo[key] = if memo.has_key?(key)
+                existing = memo[key]
+                fn.(key, existing, value)
+            else
+                value
+            end
+            memo
+        }, clone(x), y)
+    end
+
+
+    def min(x, y)
+        if x < y then x else y end
+    end
+
+    def min_by(fn, list)
+        list.map { |x| [fn.(x), x] }
+            .to_h
+            .sort
+            .first[1]
+
+    end
+
+    def mul(x, y)
+        x * y
+    end
+
+    def n_ary(n, fn)
+        _arity(n, -> *args {
+            actual_args = if fn.arity == -1 then args else args[0, fn.arity] end
+            fn.(*actual_args)
+        })
+    end
+
+    def negate(x)
+        -x
+    end
+
+    def none?(pred, list)
+        !any?(pred, list)
+    end
+
+    def not(x)
+        !x
+    end
+
+
+    def nth(index, list)
+        list[index]
+    end
+
+    def nth_arg(n)
+        -> *args {
+            args[n]
+        }
+    end
+
+    def o(*fns)
+        unary(compose(*fns))
+    end
+
+    def hash_of(key, value)
+        h = {}
+        h[key] = value
+        h
+    end
+
+    def of(x)
+        [x]
+    end
+
+    def omit(keys, hash)
+        hash.reduce({}) { |memo, x|
+            k, v = x
+            if !keys.include?(k)
+                memo[k] = v
+            end
+            memo
+        }
+    end
+
+    def once(fn)
+        memoize(-> *args { :once }, fn)
+    end
+
+    def or(x, y)
+        x || y
+    end
+
+    def over(lens, fn, x)
+        value = fn.(view(lens, x))
+        set(lens, value, x)
+    end
+
+    def pair(x, y)
+        [x, y]
+    end
+
+    def partial(fn, args)
+        apply(curry(fn), args)
+    end
+
+    def partial_right(fn, args)
+        pre_args = 0.upto(fn.arity - args.length - 1).map { |i| __ }
+        apply(curry(fn), pre_args + args)
+    end
+
+    def partition(predicate, list)
+        does_satisfy = []
+        does_not_satisfy = []
+        for x in list
+            if predicate.(x)
+                does_satisfy.push(x)
+            else
+                does_not_satisfy.push(x)
+            end
+        end
+        [does_satisfy, does_not_satisfy]
+    end
+
+    def path(path_elements, x)
+        path_elements.reduce(x) { |memo, n|
+            memo[n]
+        }
+    end
+
+    def prop(key, x)
+        x[key]
+    end
+
+    def path_eq?(path_elements, val, x)
+        path_satisfies?(equal?(val), path_elements, x)
+    end
+
+    def path_or(path_elements, default, x)
+        path_elements.reduce(x) { |memo, n|
+            if memo.respond_to?(:has_key?) && memo.has_key?(n)
+                memo[n]
+            else
+                break default
+            end
+        }
+    end
+
+    def path_satisfies?(fn, path_elements, x)
+        fn.(path(path_elements, x))
+    end
+
+    def pick(keys, x)
+        keys.reduce({}) { |memo, key|
+            memo[key] = x[key] if x.has_key?(key)
+            memo
+        }
+    end
+
+    def pick_all(keys, x)
+        keys.reduce({}) { |memo, key|
+            memo[key] = if x.has_key?(key) then x[key] else nil end
+            memo
+        }
+    end
+
+    def pick_by(fn, x)
+        keys(x).reduce({}) { |memo, key|
+            val = x[key]
+            if fn.(key, val)
+                memo[key] = val
+            end
+            memo
+        }
+    end
+
+    def pipe(fn, *fns)
+        curry_n(fn.arity, -> *args {
+            seed = fn.(*args)
+            fns.reduce(seed) { |memo, fn|
+                fn.(memo)
+            }
+        })
+    end
+
+    def pipe_k(fn, *fns)
+        wrapped = map(flat_map, fns)
+        pipe(fn, *wrapped)
+    end
+
+    def pipe_p(fn, *fns)
+        raise "TODO"
+    end
+
+    def pluck(key, f)
+        map(prop(key), f)
+    end
+
+    def prepend(x, list)
+        clone(list).unshift(x)
+    end
+
+    def product(list)
+        reduce(-> memo, x { memo * x }, 1, list)
+    end
+
+    def project(keys, hashes)
+        map(pick(keys), hashes)
+    end
+
+    def prop_eq?(key, val, hash)
+        equal?(val, prop(key, hash))
+    end
+
+    def prop_is?(kind, key, hash)
+        is_a?(kind, prop(key, hash)) == true
+    end
+
+    def prop_or(key, default, hash)
+        if hash.has_key?(key)
+            prop(key, hash)
+        else
+            default
+        end
+    end
+
+    def props(keys, hash)
+        map(prop(__, hash), keys)
+    end
+
+    def prop_satisfies?(fn, key, hash)
+        fn.(prop(key, hash)) == true
+    end
+
+    def range(x, y)
+        x.upto(y - 1).to_a
+    end
+
+    def reduce_by(value_fn, seed, key_fn, list)
+        raise "TODO"
+    end
+
+    def reduce_right(fn, seed, list)
+        result = seed
+        index = list.length - 1
+        while index >= 0
+            result = fn.(list[index], result)
+            index = index - 1
+        end
+        result
+    end
+
+    def reduce_while(predicate, fn, seed, list)
+        list.reduce(seed) { |memo, x|
+            if predicate.(x)
+                fn.(memo, x)
+            else
+                break memo
+            end
+        }
+    end
+
+    def remove(start, count, list)
+        concat(slice(0, start, list), slice(start + count, list.length, list))
+    end
+
+    def repeat(x, n)
+        times(always(x), n)
+    end
+
+    def scan(fn, seed, list)
+        accum = [seed]
+        result = reduce(-> memo, x {
+            r = fn.(memo, x)
+            accum.push(r)
+            r
+        }, seed, list)
+        accum
+    end
+
+    def sequence(of, traversable)
+        raise "TODO"
+    end
+
+    def sub(pattern, replacement, str)
+        str.sub(pattern, replacement)
+    end
+
+    def slice(from, to, list)
+        start_index = max(0, if from < 0 then list.length + from else from end)
+        final_index = min(list.length - 1, if to < 0 then list.length + to - 1 else to - 1 end)
+        result = map(-> i { nth(i, list) }, start_index.upto(final_index))
+        if list.is_a?(String)
+            result.join("")
+        else
+            result
+        end
+    end
+
+    def sort(fn, list)
+        list.sort { |x, y| fn.(x, y) }
+    end
+
+    def sort_by(fn, list)
+        raise "TODO"
+    end
+
+    def sort_with(fn, list)
+        raise "TODO"
+    end
+
+    def split(separator, str)
+        str.split(separator)
+    end
+
+    def split_at(index, list)
+        [slice(0, index, list), slice(index, list.length, list)]
+    end
+
+    def split_every(n, list)
+        indices = (0.upto(list.length - 1)).select { |x| x % n == 0 }
+        indices.map { |i| slice(i, i + n, list) }
+    end
+
+    def split_when(fn, list)
+        first = []
+        second = []
+        split = false
+        for x in list
+            if split
+                second.push(x)
+            else
+                if fn.(x)
+                    split = true
+                    second.push(x)
+                else
+                    first.push(x)
+                end
+            end
+        end
+        [first, second]
+    end
+
+    def starts_with?(start, str)
+        slice(0, start.length, str) == start
+    end
+
+
+    def raise(message)
+        Kernel.raise message
+    end
+
+    def reduce(fn, initial, list)
+        list.reduce(initial) { |memo, x| fn.(memo, x) }
+    end
+
+    def responds_to?(key, x)
+        if x.respond_to?(:respond_to?)
+            x.respond_to?(key)
+        else
+            raise "Cannot `respond_to?` on #{x.class}"
+        end
+    end
+
+    def reverse(list)
+        list.reverse
+    end
+
+    def set(lens, value, x)
+        lens.setter.(value, x)
+    end
+
+    def sub(x, y)
+        x - y
+    end
+
+    def sum(xs)
+        reduce(-> x, y { x + y }, 0, xs)
+    end
+
+    def symmetric_difference(x, y)
+        raise "TODO"
+    end
+
+    def symmetric_difference_with(fn, x, y)
+        raise "TODO"
+    end
+
+    def t(*args)
+        true
+    end
+
+    def tail(list)
+        slice(1, list.length, list)
+    end
+
+    def take(n, list)
+        slice(0, n, list)
+    end
+
+    def take_last(n, list)
+        slice(list.length - n, list.length, list)
+    end
+
+    def take_last_while(fn, list)
+        taken = []
+        for x in list.reverse
+            if fn.(x)
+                taken.unshift(x)
+            else
+                break
+            end
+        end
+        taken
+    end
+
+    def take_while(fn, list)
+        taken = []
+        for x in list
+            if fn.(x)
+                taken.push(x)
+            else
+                break
+            end
+        end
+        taken
+    end
+
+    def tap(fn, x)
+        fn.(x)
+        x
+    end
+
+    def test?(pattern, str)
+        str.match?(pattern)
+    end
+
+    def times(fn, n)
+        map(-> i { fn.(i) }, 0.upto(n - 1))
+    end
+
+    def to_pairs(hash)
+        hash.to_a
+    end
+
+    def to_s(x)
+        x.to_s
+    end
+
+    def to_upper(str)
+        str.upcase
+    end
+
+    def to_lower(str)
+        str.downcase
+    end
+
+    def transduce
+        raise "TODO"
+    end
+
+    def traverse
+        raise "TODO"
+    end
+
+    def trim(str)
+        str.strip
+    end
+
+    def strip(str)
+        trim(str)
+    end
+
+    def begin_rescue(beginner, rescuer)
+        -> *args {
+            begin
+                beginner.(*args)
+            rescue Exception => e
+                rescuer.(e)
+            end
+        }
+    end
+
+    def type(x)
+        x.class
+    end
+
+    def unapply(fn)
+        -> *args {
+            fn.(args)
+        }
+    end
+
+
+    def unary(fn)
+        n_ary(1, fn)
+    end
+
+    def uncurry_n(n, fn)
+       n_ary(n, -> *args {
+           0.upto(n - 1)
+            .reduce(fn) { |f, x|
+                arg = args[x]
+                f.(arg)
+            }
+       })
+    end
+
+    def unfold(fn, seed)
+        memo = seed
+        results = []
+        while true
+            result = fn.(memo)
+            if result == false
+                break
+            else
+                x, memo = result
+                results.push(x)
+            end
+        end
+        results
+    end
+
+    def union(x, y)
+        union_with(identity, x, y)
+    end
+
+    def union_with(fn, x, y)
+        map_pair = compose(invert, map(fn), from_pairs, map(-> v { [v, v ]}))
+        mapped_x = map_pair.(x)
+        mapped_y = map_pair.(y)
+        merge_deep_left(mapped_x, mapped_y).values
+    end
+
+    def uniq(list)
+        uniq_by(R::identity)
+    end
+
+    def uniq_by(fn, list)
+        found = {}
+        list.select { |x|
+            mapping = fn.(x)
+            if found.has_key?(mapping)
+                false
+            else
+                found[mapping] = true
+                true
+            end
+        }
+    end
+
+    def unless(predicate, fn, x)
+        if !predicate.(x)
+            fn.(x)
+        else
+            x
+        end
+    end
+
+    def unnest(x)
+        flat_map(identity, x)
+    end
+
+    def until(predicate, fn, seed)
+        result = seed
+        while !predicate.(result)
+            result = fn.(result)
+        end
+        result
+    end
+
+    def update(index, x, list)
+        list[index] = x
+        list
+    end
+
+    def use_with(fn, transformers)
+        curry_n(transformers.length, -> *args {
+            values = zip_with_index(args)
+                .map { |x| transformers[x[1]].(x[0]) }
+            apply(fn, values)
+        })
+    end
+
+    def m(sym)
+        curry(method(sym))
+    end
+
+    def pow(x, y)
+        x ** y
+    end
+
+    def values(x)
+        x.values
+    end
+
+    def view(lens, x)
+        lens.getter.(x)
+    end
+
+    def when(predicate, fn, x)
+        if predicate.(x)
+            fn.(x)
+        else
+            x
+        end
+    end
+
+    def where(spec, x)
+        results = spec.map { |k, v|
+            applied = v.(x[k])
+            applied
+        }
+        all?(equal?(true), results)
+    end
+
+    def where_eq(spec, x)
+        where(map(equal?, spec), x)
+    end
+
+    def without(x, y)
+        y - x
+    end
+
+    def xprod(xs, ys)
+        xs.product(ys)
+    end
+
+    def zip(xs, ys)
+        xs.zip(ys)
+    end
+
+    def zip_hash(xs, ys)
+        zip(xs, ys).to_h
+    end
+
+    def zip_with_index(list)
+        zip(list, 0.upto(list.length - 1))
+    end
+
+    def zip_with(fn, xs, ys)
+        0.upto(xs.length - 1)
+         .map { |x| fn.(xs[x], ys[x]) }
+    end
+
+end