tiny_frp 0.0.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a0da64a0deadc5d35504fb31fa7c0bfc93a3b7a
-  data.tar.gz: 1ee140957c306bdc7d6d08fc8a80b464e56d1e2c
+  metadata.gz: 95461bc9e9bcaec52bd9d693befbab7f761c4596
+  data.tar.gz: 864a0e822365a039c315192d02c509b8a15ddeef
 SHA512:
-  metadata.gz: 255e6f5b217918fe1e1ffc7228a8662d063119317a73d1e7ac9e5479267d953b561ea8d638bee75ed9345a27149d8ed8a95f198de4b7dd2a00d898d123406073
-  data.tar.gz: 3bc5920a8e340e1b02d1df34c33c95a09cb388110dd7bc50826dbad65f3db44a46027135c278cad21d7c86e6edfc543b2b2c3cd4fa3ceb8fb169e548d5ae0e45
+  metadata.gz: 68ee1322327823da24345bbd919030bec4e33990d2379612c1d3efa09d982215c73c39d4171489edda8786a90aa22a4c29334e64e7220fbdd9b47fbf6e64e719
+  data.tar.gz: 34f5f5cdd816f06c61a22a07ff5625d24b43370a0784e48127d4b281bef255cebb18dceb478e1e66f41f611508ed2a8586145921632e772e0a16402b4e241344

data/lib/tiny_frp/version.rb

@@ -1,3 +1,3 @@
 module TinyFRP
-  VERSION = "0.0.3"
+  VERSION = "1.0.0"
 end

data/lib/tiny_frp.rb

@@ -1,144 +1,121 @@
 require "tiny_frp/version"
 
 module TinyFRP
-  class Runtime
-    def initialize(signal)
-      @parents = Runtime.make_map(signal)
-      @children = Runtime.traverse(signal)
-      @inputs = @parents.keys.select{|node| @parents[node] == []}
-    end
+  def self.process(node, n)
+    n.times.inject(res: [], last_memo: {}){|acc|
+      memo = node.call({}, acc[:last_memo])
+      {res: acc[:res] + [memo[node]], last_memo: memo}
+    }[:res]
+  end
 
-    def self.make_map(signal)
-      signal.assigned_signals.inject({}){|h, s|
-        h.merge(make_map(s))
-      }.merge(signal.node => signal.assigned_signals.map{|s| s.node})
+  def self.loop(node, &proc)
+    last_memo = {}
+    loop {
+      memo = node.call({}, last_memo)
+      proc.call(*memo[node])
+      last_memo = memo
+    }
+  end
+
+  class Node
+    def >>(node)
+      Composite.new(self, node)
     end
 
-    def self.traverse(signal)
-      signal.assigned_signals.each_with_index.inject({signal.node =>[]}) do |h, a|
-        s, i = *a
-        edges = traverse(s).merge(s.node => [[i, signal.node]]){|k, old, new| (old + new).uniq}
-        h.merge(edges){|k, old, new| (old + new).uniq}
-      end
+    def <<(node)
+      Composite.new(node, self)
     end
 
-    def conduct
-      received = Hash.new([])
-      queue = Array.new(@inputs)
-      until queue.empty?
-        node = queue.shift
-        val = node.call(*received[node].sort{|a, b| a[0] <=> b[0]}.map{|idx, val| val})
-        @children[node].each do |idx, ch_node|
-          received[ch_node] = received[ch_node] + [[idx, val]]
-          if received[ch_node].size == @parents[ch_node].size
-            queue << ch_node
-          end
-        end
-      end
-      return val
+    def +(node)
+      Bundle.new(self, node)
     end
 
-    def run(mode=:loop, &proc)
-      case mode
-      when :loop
-        loop{ 
-          v = conduct
-          proc.call(v) if proc
-        }
-      when 0
-        []
-      when 1
-        [conduct]
-      when Integer
-        [conduct] + run(mode - 1)
+    def call(memo, last_memo, *args)
+      if memo.has_key?(self)
+        memo
+      else
+        calc(memo, last_memo, *args)
       end
     end
   end
 
-  class Signal
-    attr_reader :node, :assigned_signals
-    def initialize(node, assigned_signals)
-      @node, @assigned_signals = node, assigned_signals
+  class Lift < Node
+    def initialize(&proc)
+      @proc = proc
     end
-  end
-
-  class Node
-    attr_reader :fixed_argc
 
-    def >>(node)
-      node.apply([self])
+    def argc
+      @argc ||= @proc.parameters.select{|t, n| t == :opt}.count
     end
 
-    def apply(args)
-      signals = args.map{|s| s.is_a?(Node) && s.fixed_argc == 0 ? Signal.new(s, []) : s}
-      if signals.any?{|s| !s.is_a?(Signal)}
-        raise "Error: cannot apply SignalFunction to Non-Signal Object."
-      end
-      if signals.size < @fixed_argc || (!@rest_arg && signals.size != @fixed_argc)
-        raise "Error: cannot apply SignalFunction to Signals."
-      end
-      Signal.new(self, signals)
+    def calc(memo, last_memo, *args)
+      memo.merge(self => [@proc.call(*args)])
     end
   end
 
   class Foldp < Node
-    def initialize(initial_state, proc, fixed_argc, rest_arg)
-      @state, @proc  = initial_state, proc
-      @fixed_argc, @rest_arg = fixed_argc, rest_arg
+    def initialize(initial_state, &proc)
+      @initial_state, @proc  = initial_state, proc
     end
 
-    def update(diff)
-      @state.keys.map{|k| 
-        if diff.has_key?(k)
-          [k, diff[k]]
-        else
-          [k, @state[k]]
-        end
-      }.to_h
+    def argc
+      @argc ||= @proc.parameters.select{|t, n| t == :opt}.count - 1
     end
 
-    def call(*raw_args)
-      @state = update(@proc.call(@state, *raw_args))
-    end
-  end
-
-  class Lift < Node
-    def initialize(proc, fixed_argc, rest_arg=false)
-      @proc, @fixed_argc, @rest_arg = proc, fixed_argc, rest_arg
+    def update(last_state, diff)
+      case diff
+      when Hash
+        last_state.keys.map{|k| 
+          if diff.has_key?(k)
+            [k, diff[k]]
+          else
+            [k, last_state[k]]
+          end
+        }.to_h
+      else
+        diff
+      end
     end
 
-    def call(*raw_args)
-      @proc.call(*raw_args)
+    def call(memo, last_memo, *args)
+      last_state = last_memo.has_key?(self) ? last_memo[self].first : @initial_state
+      memo.merge(self => [update(last_state, @proc.call(last_state, *args))])
     end
   end
-   
-  class Bundler
-    def initialize(signals)
-      @signals = signals
+
+  class Composite < Node
+    def initialize(pnode, cnode)
+      @pnode, @cnode = pnode, cnode
     end
 
-    def >>(node)
-      node.apply(@signals)
+    def argc
+      @pnode.argc
     end
-  end
 
-  def self.foldp(initial_state, &proc)
-    fixed_argc = proc.parameters.select{|t, n| t == :opt}.count - 1
-    rest_arg = proc.parameters.any?{|t, n| t == :rest}
-    Foldp.new(initial_state, proc, fixed_argc, rest_arg)
+    def calc(memo, last_memo, *args)
+      p_res = @pnode.call(memo, last_memo, *args)
+      n_res = @cnode.call(p_res, last_memo, *p_res[@pnode])
+      n_res.merge(self => n_res[@cnode])
+    end
   end
 
-  def self.bundle(*signals)
-    Bundler.new(signals)
-  end
+  class Bundle < Node
+    def initialize(*nodes)
+      @nodes = nodes
+    end
 
-  def self.lift(&proc)
-    fixed_argc = proc.parameters.select{|t, n| t == :opt}.count
-    rest_arg = proc.parameters.any?{|t, n| t == :rest}
-    Lift.new(proc, fixed_argc, rest_arg)
-  end
+    def argc
+      @argc ||= @nodes.inject(0){|acc, n| acc + n.argc}
+    end
 
-  def self.bottom
-    Lift.new(proc{|*_| nil}, 0, true)
+    def calc(memo, last_memo, *args)
+      res = @nodes.inject(memo: memo, rest_args: args){|acc, n|
+        {
+          memo: n.call(acc[:memo], last_memo, *acc[:rest_args].take(n.argc)),
+          rest_args: acc[:rest_args].drop(n.argc)
+        }
+      }[:memo]
+      res.merge(self => @nodes.inject([]){|acc, n| acc + res[n]})
+    end
   end
 end

data/unit_test/test_tiny_frp.rb

@@ -5,79 +5,41 @@ module TinyFRP
     require 'test/unit'
     require $LIBRARY_ROOT_PATH + '/lib/tiny_frp.rb'
 
-    class RuntimeTest < Test::Unit::TestCase
-      def test_make_map
-        s1 = Signal.new(:node_a, [])
-        s2 = Signal.new(:node_b, [])
-        s3 = Signal.new(:node_c, [s1, s2])
-        s4 = Signal.new(:node_d, [s3])
-        s5 = Signal.new(:node_e, [s3])
-        s6 = Signal.new(:node_f, [s4, s5])
-        ps = Runtime.make_map(s6)
-
-        assert_equal([],                 ps[:node_a])
-        assert_equal([],                 ps[:node_b])
-        assert_equal([:node_a, :node_b], ps[:node_c])
-        assert_equal([:node_c],          ps[:node_d])
-        assert_equal([:node_c],          ps[:node_e])        
-        assert_equal([:node_d, :node_e], ps[:node_f])
+    module Util
+      def lift(&proc)
+        TinyFRP::Lift.new(&proc)
       end
 
-      def test_traverse
-        s1 = Signal.new(:node_a, [])
-        s2 = Signal.new(:node_b, [])
-        s3 = Signal.new(:node_c, [s1, s2])
-        s4 = Signal.new(:node_d, [s3])
-        s5 = Signal.new(:node_e, [s3])
-        s6 = Signal.new(:node_f, [s4, s5])
-        cs = Runtime.traverse(s6)
-
-        assert_equal(1, cs[:node_a].size)
-        assert(cs[:node_a].include? [0, :node_c])
-
-        assert_equal(1, cs[:node_b].size)
-        assert(cs[:node_b].include? [1, :node_c])
-
-        assert_equal(2, cs[:node_c].size)
-        assert(cs[:node_c].include? [0, :node_d])
-        assert(cs[:node_c].include? [0, :node_e])
-
-        assert_equal(1, cs[:node_d].size)
-        assert(cs[:node_d].include? [0, :node_f])
-
-        assert_equal(1, cs[:node_e].size)
-        assert(cs[:node_e].include? [1, :node_f])
-
-        assert_equal(0, cs[:node_f].size)
+      def foldp(init_state, &proc)
+        TinyFRP::Foldp.new(init_state, &proc)
       end
+    end
 
-      def test_conduct
-        v1, v2 = 0, 1
-        s1 = Signal.new(proc{ v1 = v1 + 1}, [])
-        s2 = Signal.new(proc{ v2 = v2 * 2}, [])
-        s3 = Signal.new(proc{|a, b| a + b}, [s1, s2])
-
-        assert_equal([1+2, 2+4, 3+8, 4+16, 5+32], Runtime.new(s3).run(5))
-      end
+    class TinyFRPTest < Test::Unit::TestCase
+      include Util
 
       def test_lift
         v1, v2 = 0, 1
-        l1 = TinyFRP.lift{v1 = v1 + 1}
-        l2 = TinyFRP.lift{v2 = v2 * 2}
-        signal = TinyFRP.bundle(l1, l2) >> TinyFRP.lift{|a, b| a + b}
-        
-        assert_equal([1+2, 2+4, 3+8, 4+16, 5+32], Runtime.new(signal).run(5))
+        node = lift{|a, b| a + b} << lift{v1 = v1 + 1} + lift{v2 = v2 * 2}
+        assert_equal([[1+2], [2+4], [3+8], [4+16], [5+32]], TinyFRP.process(node, 5))
       end
 
       def test_foldp
-        f1 = TinyFRP.foldp(val: 0){|acc| {val: acc[:val] + 1}}
-        f2 = TinyFRP.foldp(val: 1){|acc| {val: acc[:val] * 2}}
-        signal = TinyFRP.bundle(f1, f2) >> TinyFRP.lift{|a, b| a[:val] + b[:val]}
+        node = lift{|a, b| a + b} << foldp(0){|acc| acc + 1} + foldp(1){|acc| acc * 2}
+        assert_equal([[1+2], [2+4], [3+8], [4+16], [5+32]], TinyFRP.process(node, 5))
+      end
 
-        assert_equal([1+2, 2+4, 3+8, 4+16, 5+32], Runtime.new(signal).run(5))
+      def test_composite
+        node1 = foldp(0){|a| a + 1} >> lift{|a| a + 1}
+        node2 = foldp(0){|a| a + 1} >> lift{|a| a - 1}
+        node3 = lift{|a, b| a * b} << node1 + node2
+        assert_equal([[1 * 1 - 1], [2 * 2 - 1], [3 * 3 - 1]], TinyFRP.process(node3, 3))
+      end
+
+      def test_bundle
+        node = foldp(0){|a| a + 1} + foldp(1){|a| a + 1} + foldp(2){|a| a + 1}
+        assert_equal([[1, 2, 3], [2, 3, 4], [3, 4, 5]], TinyFRP.process(node, 3))
       end
     end
   end
 end
-
-      

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiny_frp
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - sawaken
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler