fn_space 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 811602e26a532105f37e6c56e20b81c60c6c9440
-  data.tar.gz: a49df20d40c2c6260ef58f66e9c0ed7a6b446a68
+  metadata.gz: ef2eda95f4d90d23f7159493efab4a5d2e27443c
+  data.tar.gz: f14a79bff5994467498973e2470b6a770ca952cc
 SHA512:
-  metadata.gz: 79be1355ea6761017771e5c9f1b7a9e3b8b99fdc221113af0df860063781bf856324b80b873b78359e8b049a982c6e7327c33c7186c39aadd532cc50ac2b036e
-  data.tar.gz: 239e101d091b49c410e31c1fc83c0a5c80b916bb78c2f701fca24b262c5357ce6d0d8533d91ba2a1b606c47e190d117f127f7d90a05681854483b640548b4bfa
+  metadata.gz: d28c17beb0190f6e029dc9ec2434659cddd3658d0345d3c468535b320ed62ad004ce67955b442dea5e675c70f58fd61f1da92bc544b212572c0acfbd980e17be
+  data.tar.gz: d92fd1d315563e6093b9a7982e71157069bb34f4c1479d1181c794f3e3d6f92aa6ac5d3d9f50ef453962d4a2185539203f5f09f8befd57796d6865b5bb9d7c01

data/README.md

@@ -1,36 +1,147 @@
 # FnSpace
 
-A Ruby class for explicit function importing and exporting.
+FnSpace is a space where functions can be treated as first class objects. It
+provides import and export helpers that prioritize functions and utility
+methods to enable functional paradigms.
 
 ## Example
 
 ``` ruby
+# my_awsome_project/formula.rb
 require 'fn_space'
 
-module Foo
-  def self.add(a, b)
-    a + b
-  end
+fn_space(:Formula) do |import, exports|
+  pi = 3.14
+  exports.circ = ->(r) { 2 * pi * r }
+  exports.area = ->(r) { pi * r ** 2 }
+end
+```
+
+``` ruby
+# my_awsome_project/other_file.rb
+require 'fn_space'
+require_relative 'formula'
+
+fn_space do |import|
+  fn1, fn2 = import.(:area, :circ).from Formula
+  fn1.(8) # 200.96
+  fn2.(8) # 50.24
+end
+```
+
+## Usage
+
+### `fn_space(const = nil) { |import, exports| block }`
+
+`fn_space` is a global method that executes a block passed to it in an
+anonymous module. It passes two arguments to the provided block, `import` and
+`exports`.
+
+It optionally takes a new constant's name as it first argument, which will then
+be used to store any properties added to the `exports` OpenStruct.
+
+### `import.(*names).from Source`
+
+`import.()` can be used to import properties from a source. If only a single
+property is requested then only a single value will be return, otherwise an
+array will be.
+
+``` ruby
+MagicNumbers = Struct.new(:a, :b, :c).new(5, 7, 19)
+
+fn_space do |import|
+  b = import.(:b).from MagicNumbers
+  c, a = import.(:c, :a).from MagicNumbers
+
+  a + b + c # 31
+end
+```
+
+### `import.methods.(*names).from Source`
+
+`import.methods.()` can be used to import methods from a source as method objects.
+
+``` ruby
+fn_space do |import|
+  tan = import.methods.(:tan).from Math
+  sin, cos = import.methods.(:sin, :cos).from Math
+  pi = Math::PI
 
-  def self.take(a, b)
-    a - b
-  end
+  tan.(0) # 0
+  sin.(pi/2) # 1.0
+  cos.(pi) # -1.0
 end
+```
+
+## Utils
+
+### `mod.()`
+
+`mod.()` creates a new anonymous module with an `assign` singleton method that
+can be used to create singleton methods in a chain.
+
+``` ruby
+fn_space do |import|
+  mod = import.(:mod).from FnSpace::Utils
+  foo = mod.()
+    .assign(:add) { |a, b| a + b }
+    .assign(:take) { |a, b| a - b }
+
+  foo.add(3, 4) # 7
+  foo.take(5, 2) # 3
+end
+```
+
+### `struct.(hash)`
+
+`struct.()` takes a hash and creates a new anonymous module with properties
+taken from the hash.
+
+``` ruby
+fn_space do |import|
+  struct = import.(:struct).from FnSpace::Utils
+  crds = struct.(x: 0.5, y: 1.5, z: -1.0)
+  crds.x  + crds.y + crds.z # 1.0
+end
+```
+
+### `chain.(value)`
+
+`chain.()` wraps around a value and can be used to chain functions to be applied
+to the value. It does this by providing the following methods:
+
+* `>>` - Applies a function to the value and replaces the value with the result.
+* `<<` - Applies a function to the value but does not replace the value.
+* `|`  - Applies a function to the chain object itself.
+* `value` - Returns the value.
 
-Bar = {
-  times: ->(a, b) { a * b }
-}
+Function arguments have their `#to_proc` method called first such that symbols
+can be used to call methods on an object.
 
-class FnSpace
-  add, take = import(:add, :take).from 'Foo'
-  times = import(:times).from 'Bar'
+``` ruby
+fn_space do |import|
+  chain = import.(:chain).from FnSpace::Utils
 
-  result = ->(a, b) { add.(times.(a, b), take.(a, b)) }
+  double = ->(v) { v * 2 }
+  log = ->(v) { puts v }
 
-  export(result: result).to 'Sums'
+  res = chain.(3) >> double >> :next << log >> double << log >> :next | :value
+  # 7
+  # 14
+  puts res # 15
 end
+```
+
+### `apply_send.(*args)`
 
-Sums[:result].(5, 8) # 37
+`apply_send.()` can be used to apply arguments to an object's `send` method.
+This can useful used in conjunction with the `chain` utility.
+
+``` ruby
+fn_space do |import|
+  chain, send = import.(:chain, :apply_send).from FnSpace::Utils
+  chain.(2) >> send.(:**, 3) >> send.(:/, 4) | :value # 2
+end
 ```
 
 ## Installation

data/lib/fn_space.rb

@@ -1,36 +1,10 @@
-class FnSpace < BasicObject
-  def self.import(*names)
-    Importer.new(names)
-  end
-
-  def self.export(obj)
-    Exporter.new(obj)
-  end
-
-  class Importer
-    def initialize(names)
-      @names = names
-    end
-
-    def from(constant)
-      obj = ::Object.const_get(constant)
-      is_hash = obj.respond_to?(:has_key?)
-      functions = @names.map { |m| is_hash ? obj[m].to_proc : obj.method(m) }
-      functions.length == 1 ? functions.first : functions
-    end
-  end
-
-  class Exporter
-    def initialize(obj)
-      @obj = obj
-    end
-
-    def to(constant)
-      if ::Object.const_defined?(constant)
-        ::Object.const_get(constant).merge!(@functions)
-      else
-        ::Object.const_set(constant, @functions)
-      end
-    end
-  end
-end
+require 'ostruct'
+require_relative 'fn_space/utils'
+require_relative 'fn_space/import'
+require_relative 'fn_space/export'
+
+def fn_space(const = nil, &b)
+  exports = OpenStruct.new
+  Module.new.instance_exec(FnSpace::Import, exports, &b)
+  FnSpace::Export.(const, FnSpace::Utils.struct.(exports.to_h)) if const
+end

data/lib/fn_space/assignable.rb

@@ -0,0 +1,8 @@
+module FnSpace
+  module Assignable
+    def assign(name, &b)
+      define_singleton_method(name, &b)
+      self
+    end
+  end
+end

data/lib/fn_space/export.rb

@@ -0,0 +1,5 @@
+FnSpace::Export = ->(const, obj) do
+  parent, _, child = const.to_s.rpartition('::')
+  parent = parent.empty? ? Object : Object.const_get(parent)
+  parent.const_set(child, obj)
+end

data/lib/fn_space/import.rb

@@ -0,0 +1,21 @@
+require_relative 'utils'
+chain = FnSpace::Utils.chain
+mod = FnSpace::Utils.mod
+
+first_or_all = ->(array) { array.length == 1 ? array.first : array }
+map = ->(array) { ->(map_fn) { array.map(&map_fn) } }
+send_map_fn = ->(obj) { ->(name) { obj.send(name) } }
+method_map_fn = ->(obj) { ->(name) { obj.method(name) } }
+
+importer = ->(names, map_fn) do
+  mod.().assign(:from) do |source|
+    chain.(source) >> map_fn >> map.(names) >> first_or_all | :value
+  end
+end
+
+import = ->(*names) { importer.(names, send_map_fn) }
+import_methods = ->(*names) { importer.(names, method_map_fn) }
+
+FnSpace::Import = mod.()
+  .assign(:call, &import)
+  .assign(:methods){import_methods}

data/lib/fn_space/utils.rb

@@ -0,0 +1,15 @@
+require_relative 'assignable'
+
+mod = ->(&b) { Module.new(&b).extend(FnSpace::Assignable) }
+struct = ->(hash) { hash.reduce(mod.()) { |obj, (k, v)| obj.assign(k){v} } }
+apply_send = ->(method, *args) { ->(obj) { obj.send(method, *args) } }
+
+chain = ->(value) do
+  monad = mod.()
+    .assign(:>>) { |fn| value = fn.to_proc.(value); monad }
+    .assign(:<<) { |fn| fn.to_proc.(value); monad }
+    .assign(:|) { |fn| fn.to_proc.(monad) }
+    .assign(:value) { value }
+end
+
+FnSpace::Utils = struct.(mod: mod, struct: struct, apply_send: apply_send, chain: chain)

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: fn_space
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Max White
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
-dependencies: []
+date: 2015-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
 description: 
 email: mushishi78@gmail.com
 executables: []
@@ -19,6 +39,10 @@ files:
 - LICENSE.txt
 - README.md
 - lib/fn_space.rb
+- lib/fn_space/assignable.rb
+- lib/fn_space/export.rb
+- lib/fn_space/import.rb
+- lib/fn_space/utils.rb
 homepage: https://github.com/mushishi78/fn_space
 licenses:
 - MIT
@@ -42,5 +66,5 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: A Ruby class for explicit function importing and exporting
+summary: A Ruby class for explicit importing and exporting
 test_files: []