kansuu 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd9e82d8aeef5bd77a965b435623f4eb84bcfdf5
+  data.tar.gz: 155ed2774101cd8a7b57e824a4b3be172cb983b4
+SHA512:
+  metadata.gz: 5d576bf6139b7dc4c3c791277cfe295f5d5a5fef3946735e6886f49d0be042048293fa477b35634ad24125a40a3da935ae6d275a039519e46bd2f8be1aee0e13
+  data.tar.gz: 25e6f7861c8cef56572e81c6147139a3dec6a957d616e3aaba0c0901138e59f5f11d96ebed9411773186c5eea4ffaa91a4d532741aa8e62a115d629c792390d3

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kansuu.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# Kansuu
+
+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/kansuu`. 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 'kansuu'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kansuu
+
+## 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]/kansuu.
+

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 "kansuu"
+
+# 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

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/kansuu.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kansuu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kansuu"
+  spec.version       = Kansuu::VERSION
+  spec.authors       = ["Akihito Fujiwara"]
+  spec.email         = ["akitoha1207@gmail.com"]
+
+  spec.summary       = %q{Functions (Procedures)}
+  spec.description   = %q{Functions (Procedures)}
+  spec.homepage      = "https://github.com/akihitofujiwara/kansuu.git"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+#  if spec.respond_to?(:metadata)
+#    spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+#  else
+#    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+#  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "lambda_driver", "~> 1.2.4"
+end

data/lib/kansuu/cast.rb

@@ -0,0 +1,21 @@
+require "lambda_driver"
+require "kansuu/util"
+
+module Kansuu::Cast
+  extend Kansuu::Util
+
+  __define_funcs_from_method < {
+    to_str: [:to_s, 1],
+    to_sym: [:to_sym, 1],
+    to_a: [:to_a, 1],
+    to_arr: [:to_arr, 1],
+    to_i: [:to_i, 1],
+    to_int: [:to_int, 1],
+    to_c: [:to_c, 1],
+    to_r: [:to_r, 1],
+    to_f: [:to_f, 1],
+    to_enum: [:to_enum, 1],
+    to_h: [:to_h, 1],
+  }
+end
+

data/lib/kansuu/combinator.rb

@@ -0,0 +1,23 @@
+require "lambda_driver"
+require "kansuu/util"
+
+module Kansuu::Combinator
+  extend Kansuu::Util
+
+  __define_func_from_method.(:flip, :flip, 2)
+
+  def id
+    -> x { x }
+  end
+
+  def const
+    -> x, y { x } % 2
+  end
+
+  def i; id end
+
+  def k; const end
+
+  def c; flip end
+end
+

data/lib/kansuu/control.rb

@@ -0,0 +1,15 @@
+require "lambda_driver"
+
+module Kansuu::Control
+  def when_
+    -> f, g, x {
+      f[x] ? g[x] : x
+    } % 3
+  end
+
+  def except
+    -> f, g, x {
+      f[x] ? x : g[x]
+    } % 3
+  end
+end

data/lib/kansuu/enum.rb

@@ -0,0 +1,107 @@
+require "lambda_driver"
+require "kansuu/util"
+require "kansuu/func"
+
+module Kansuu::Enum
+  extend Kansuu::Util
+
+  __define_funcs_from_method < {
+    sort: [:sort, 1],
+    sort_by: [:sort_by, 2, true],
+    grep: [:grep, 2],
+    count: [:count, 1],
+    find: [:find, 2, true],
+    detect: [:detect, 2, true],
+    find_index: [:find_index, 2, true],
+    find_all: [:find_all, 2, true],
+    select: [:select, 2, true],
+    filter: [:select, 2, true],
+    reject: [:reject, 2, true],
+    collect: [:collect, 2, true],
+    map: [:map, 2, true],
+    flat_map: [:flat_map, 2, true],
+    collect_concat: [:collect_concat, 2, true],
+    inject: [:inject, 3, true],
+    reduce: [:reduce, 3, true],
+    fold: [:reduce, 3, true],
+    foldl: [:reduce, 3, true],
+    fold1: [:reduce, 2, true],
+    foldl1: [:reduce, 2, true],
+    partition: [:partition, 2, true],
+    group_by: [:group_by, 2, true],
+    first: [:first, 1],
+    all: [:all?, 2, true],
+    any: [:any?, 2, true],
+    one: [:one?, 2, true],
+    none: [:none?, 2, true],
+    min: [:min, 1],
+    max: [:max, 1],
+    minmax: [:minmax, 1],
+    min_by: [:min_by, 2, true],
+    max_by: [:max_by, 2, true],
+    minmax_by: [:minmax_by, 2, true],
+    is_member: [:member?, 2],
+    include_: [:include?, 2],
+    each_with_index: [:each_with_index, 2, true],
+    reverse_each: [:reverse_each, 2, true],
+    each_entry: [:each_entry, 2, true],
+    each_slice: [:each_slice, 3, true],
+    each_cons: [:each_cons, 3, true],
+    each_with_object: [:each_with_object, 3, true],
+    zipr: [:zip, 2],
+    take: [:take, 2],
+    take_while: [:take_while, 2, true],
+    drop: [:drop, 2],
+    drop_while: [:drop_while, 2, true],
+    cycle: [:cycle, 3, true],
+    chunk: [:chunk, 2, true],
+    slice_before: [:slice_before, 2, true],
+    slice_after: [:slice_after, 2, true],
+    slice_when: [:slice_when, 2, true],
+    lazy: [:lazy, 1],
+    force: [:force, 1],
+    at: [:at, 2],
+    last: [:last, 1],
+    concat: [:concat, 2],
+    each: [:each, 2, true],
+    each_index: [:each_index, 2, true],
+    length: [:length, 1],
+    size: [:size, 1],
+    empty: [:empty?, 1],
+    index: [:index, 2],
+    rindex: [:rindex, 2],
+    join: [:join, 2],
+    reverse: [:reverse, 1],
+    rotate: [:rotate, 2],
+    slice: [:slice, 3],
+    uniq: [:uniq, 1],
+    unique: [:uniq, 1],
+    compact: [:compact, 1],
+    flatten: [:flatten, 1],
+    shuffle: [:shuffle, 1],
+    sample: [:sample, 1],
+    samples: [:sample, 2],
+    permutation: [:permutation, 2],
+    combination: [:combination, 2],
+    repeated_permutation: [:repeated_permutation, 2],
+    repeated_combination: [:repeated_combination, 2],
+    product: [:product, 2],
+  }
+
+  def zipl; zipr.flip 2 end
+
+  def zip; zipl end
+
+  def zip_with
+    -> f, xs, ys {
+      xs.zip(ys).map &app[f]
+    } % 3
+  end
+
+  def pick
+    -> ns, xs {
+      xs.values_at *ns
+    }
+  end
+end
+

data/lib/kansuu/eq.rb

@@ -0,0 +1,15 @@
+require "lambda_driver"
+require "kansuu/util"
+
+module Kansuu::Eq
+  extend Kansuu::Util
+
+  __define_funcs_from_method < {
+    is: [:===, 2],
+    eq: [:===, 2],
+    equals: [:===, 2],
+    isnt: [:!=, 2],
+    not_eq: [:!=, 2],
+    not_equals: [:!=, 2],
+  }
+end

data/lib/kansuu/func.rb

@@ -0,0 +1,82 @@
+require "lambda_driver"
+
+module Kansuu::Func
+  def ap
+    -> f, x { f[x] } % 2
+  end
+
+  def app
+    -> f, xs { f[*xs] } % 2
+  end
+
+  def ap_all
+    -> fs, x { fs.map &(ap * x) } % 2
+  end
+
+  def ap_at
+    -> n, f, xs { 
+      xs[0...n] + [(f[xs[n]])] + xs[(n+1)...xs.length]
+    } % 3
+  end
+
+  def ap_zip
+    -> fs, ys {
+      fs.zip(ys).map &app[ap]
+    } % 2
+  end
+
+  def ap_head
+    ap_at[0]
+  end
+
+  def ap_last
+    -> f, xs {
+      ap_at[xs.length - 1, f, xs]
+    }
+  end
+
+  def dest
+    ap_all.flip % 2
+  end
+
+  def withl
+    -> f, x {
+      [f[x], x]
+    } % 2
+  end
+
+  def withr
+    -> f, x {
+      [x, f[x]]
+    } % 2
+  end
+
+  def args
+    -> *xs { xs }
+  end
+
+  def arg
+    -> n, *xs { xs[n] } % 2
+  end
+
+  def ap_arg
+    -> n, f, g {
+      args >> ap_at[n, f] >> app[g]
+    } % 3
+  end
+
+  def ap_find
+    -> f, g, xs {
+      ap_at[find_index[f, xs], g, xs]
+    } % 3
+  end
+
+  def ap_select
+    -> f, g, xs {
+      xs.map &-> x {
+        f[x] ? g[x] : x
+      }
+    } % 3
+  end
+end
+

data/lib/kansuu/num.rb

@@ -0,0 +1,49 @@
+require "lambda_driver"
+require "kansuu/util"
+
+module Kansuu::Num
+  extend Kansuu::Util
+
+  __define_funcs_from_method < {
+    plus: [:+, 2],
+    minus: [:-, 2],
+    subtract: [:-, 2],
+    sub: [:-, 2],
+    multiply: [:*, 2],
+    mul: [:*, 2],
+    pow: [:**, 2],
+    div: [:div, 2],
+    modulo: [:modulo, 2],
+    remainder: [:remainder, 2],
+    rem: [:remainder, 2],
+    divmod: [:divmod, 2],
+    fdiv: [:fdiv, 2],
+    abs: [:abs, 1],
+    magnitude: [:magnitude, 1],
+    bit_length: [:bit_length, 1],
+    odd: [:odd?, 1],
+    even: [:even?, 1],
+    succ: [:succ, 1],
+    upto: [:upto, 2],
+    downto: [:downto, 2],
+    repeat: [:times, 2, true],
+    next: [:next, 1],
+    pred: [:pred, 1],
+    chr: [:chr, 1],
+    ord: [:ord, 1],
+    floor: [:floor, 1],
+    ceil: [:ceil, 1],
+    truncate: [:truncate, 1],
+    round: [:round, 1],
+    gcd: [:gcd, 2],
+    lcm: [:lcm, 2],
+    gcdlcm: [:gcdlcm, 2],
+    rationalize: [:rationalize, 1],
+    quo: [:quo, 2],
+    abs2: [:abs2, 1],
+    between: [:between?, 3],
+  }
+end
+
+
+

data/lib/kansuu/obj.rb

@@ -0,0 +1,34 @@
+require "lambda_driver"
+
+module Kansuu::Obj
+  def let
+    -> o, m, *args {
+      o._(m)[*args]
+    } % 3
+  end
+
+  def disp
+    -> m, *args, o {
+      o._(m)[*args]
+    } % 3
+  end
+
+  def get
+    -> k, o {
+      o.send(k)
+    } % 2
+  end
+
+  def set
+    -> k, v, o {
+      o.send("#{k}=", v)
+    } % 3
+  end
+
+  def set_ap
+    -> k, f, o {
+      set[k, f[get[k, o]], o]
+    } % 3
+  end
+end
+

data/lib/kansuu/ord.rb

@@ -0,0 +1,13 @@
+require "lambda_driver"
+require "kansuu/util"
+
+module Kansuu::Ord
+  extend Kansuu::Util
+
+  __define_funcs_from_method < {
+    lt: [:<, 2],
+    lte: [:<=, 2],
+    gt: [:>, 2],
+    gte: [:>=, 2],
+  }
+end

data/lib/kansuu/util.rb

@@ -0,0 +1,17 @@
+require "lambda_driver"
+
+module Kansuu::Util
+  def __define_func_from_method
+    -> name, method, arity, with_proc = false {
+      define_method name, (
+        with_proc ?
+          -> *a, p, o { o._(method).(*a, &p) } % arity
+        : -> *a, o { o._(method).(*a) } % arity
+      )
+    }
+  end
+
+  def __define_funcs_from_method
+    -> hash { hash.each &-> k, v { __define_func_from_method.(k, *v) } }
+  end
+end

data/lib/kansuu/version.rb

@@ -0,0 +1,3 @@
+module Kansuu
+  VERSION = "0.0.0"
+end

data/lib/kansuu.rb

@@ -0,0 +1,24 @@
+require "lambda_driver"
+require "kansuu/version"
+require "kansuu/cast"
+require "kansuu/combinator"
+require "kansuu/control"
+require "kansuu/enum"
+require "kansuu/eq"
+require "kansuu/func"
+require "kansuu/num"
+require "kansuu/obj"
+require "kansuu/ord"
+
+module Kansuu
+  include Kansuu::Cast
+  include Kansuu::Combinator
+  include Kansuu::Control
+  include Kansuu::Enum
+  include Kansuu::Eq
+  include Kansuu::Func
+  include Kansuu::Num
+  include Kansuu::Obj
+  include Kansuu::Ord
+end
+

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: kansuu
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Akihito Fujiwara
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: lambda_driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.4
+description: Functions (Procedures)
+email:
+- akitoha1207@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- kansuu.gemspec
+- lib/kansuu.rb
+- lib/kansuu/cast.rb
+- lib/kansuu/combinator.rb
+- lib/kansuu/control.rb
+- lib/kansuu/enum.rb
+- lib/kansuu/eq.rb
+- lib/kansuu/func.rb
+- lib/kansuu/num.rb
+- lib/kansuu/obj.rb
+- lib/kansuu/ord.rb
+- lib/kansuu/util.rb
+- lib/kansuu/version.rb
+homepage: https://github.com/akihitofujiwara/kansuu.git
+licenses: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Functions (Procedures)
+test_files: []