flor 0.15.0 → 0.16.0

data/lib/flor/pcore/_ref.rb

@@ -0,0 +1,51 @@
+
+class Flor::Pro::Ref < Flor::Procedure
+
+  names %w[ _ref _rep ]
+
+  def pre_execute
+
+    @node['rets'] = []
+  end
+
+  def receive_last
+
+    rs = @node['rets']
+    rs = rs[0] if rs.size == 1 && rs[0].match(/[.\[]/)
+    pa = Dense::Path.make(rs).to_a
+
+    payload['ret'] =
+      if tree[0] == '_rep'
+        pa
+      elsif pa.size == 2 && pa[1] == 'ret' && field?(pa)
+        parent ?
+          parent_node_procedure.node_payload_ret :
+          node_payload_ret
+      else
+        lookup_value(pa)
+      end
+
+    super
+  end
+
+  protected
+
+  def field?(path)
+
+    (s = path[0]) && s.is_a?(String) && s.match(/\Af(ld|ield)?\z/)
+  end
+
+  def lookup_value(path)
+
+    super(path)
+
+  rescue KeyError => ke
+
+    return nil if field?(ke.work_path)
+    return nil if child_id == 1 && (n = parent_node) && n['heat0'] == '_head'
+    return nil if ke.miss[1].any? && ke.miss[4].empty?
+
+    raise
+  end
+end
+

data/lib/flor/pcore/_rxs.rb

@@ -0,0 +1,27 @@
+
+class Flor::Pro::RegularExpressionString < Flor::Procedure
+
+  name '_rxs'
+
+  def pre_execute
+
+    @node['rets'] = []
+    @node['atts'] = []
+  end
+
+  def execute_child(index=0, sub=nil, h=nil)
+
+    payload['ret'] = node_payload_ret
+      # always pass the noe_payload_ret to children
+
+    super
+  end
+
+  def receive_last
+
+    rex = [ '_rxs', "/#{@node['rets'].join}/#{att('rxopts')}", tree[2] ]
+
+    wrap('ret' => rex)
+  end
+end
+

data/lib/flor/pcore/_val.rb

@@ -5,15 +5,20 @@ class Flor::Pro::Val < Flor::Procedure
 
   def wrap_reply
 
-    if node_open?
+    payload['ret'] = tree_to_value(@node['heat']) \
+      if node_open?
 
-      heat = @node['heat']
-      heat = nil if heat[0] == '_nul'
+    super
+  end
 
-      payload['ret'] = heat
-    end
+  protected
 
-    super
+  def tree_to_value(t)
+
+    case t[0]
+    when '_func', '_proc', '_tasker' then t
+    else t[1]
+    end
   end
 end
 

data/lib/flor/pcore/{logo.rb → andor.rb}

@@ -1,5 +1,5 @@
 
-class Flor::Pro::Logo < Flor::Procedure
+class Flor::Pro::Andor < Flor::Procedure
   #
   # When `and` evaluates the children and returns false as soon
   # as one of returns a falsy value. Returns true else.
@@ -23,7 +23,7 @@ class Flor::Pro::Logo < Flor::Procedure
 
   def execute
 
-    payload['ret'] = @node['heat0'] == 'and'
+    payload['ret'] = (heap == 'and')
 
     super
   end
@@ -32,11 +32,9 @@ class Flor::Pro::Logo < Flor::Procedure
 
     c = children[@fcid]; return super if c[0] == '_att' && [1].size == 2
 
-    h0 = @node['heat0']
-
     ret = Flor.true?(payload['ret'])
 
-    return wrap_reply if ((h0 == 'or' && ret) || (h0 == 'and' && ! ret))
+    return wrap_reply if ((heap == 'or' && ret) || (heap == 'and' && ! ret))
 
     super
   end
@@ -51,7 +49,7 @@ class Flor::Pro::Logo < Flor::Procedure
 #  def receive_last
 #
 #    payload['ret'] =
-#      if @node['heat0'] == 'or'
+#      if heap == 'or'
 #        !! @node['rets'].index { |r| Flor.true?(r) }
 #      else
 #        ! @node['rets'].index { |r| Flor.false?(r) }

data/lib/flor/pcore/apply.rb

@@ -23,6 +23,41 @@ class Flor::Pro::Apply < Flor::Procedure
   # ```
   # where flor figures out by itself it has to use this "apply" procedure
   # to call the function.
+  #
+  # ## rubyesque blocks
+  #
+  # In Ruby, one case pass a block on a function call:
+  # ```ruby
+  # def f(i)
+  #   i * yield
+  # end
+  # p f(5) { |j| 10 }
+  # ```
+  # which just prints `50`.
+  #
+  # This can be achieved in flor like this:
+  # ```
+  # define f i
+  #   * i (yield _)
+  # f 5
+  #   10
+  # echo f.ret
+  # ```
+  #
+  # If one needs to have a "block" with parameters, it can be done by having
+  # an anonymous function definition has the only thing in the block:
+  # ```
+  # define f i
+  #   + i (yield i)
+  # f 5
+  #   def j
+  #     * 3 j
+  # f.ret #=> 20
+  # ```
+  #
+  # ## see also
+  #
+  # define.
 
   name 'apply'
 
@@ -38,22 +73,57 @@ class Flor::Pro::Apply < Flor::Procedure
     super
   end
 
+  def receive_last_att
+
+    return do_apply unless tree[1][@ncid]
+
+    rewrite_block_into_function
+
+    super
+  end
+
   def receive_last
 
-    args = @node['atts'].collect(&:last)
+    do_apply
+  end
 
+  protected
+
+  def do_apply
+
+    args = @node['atts']
     nht = @node['heat']
 
     src =
       Flor.is_proc_tree?(nht) && nht[1]['proc'] == 'apply' ?
-      args.shift :
+      args.shift[1] :
       nht
 
+    args << [ 'yield', payload_ret ] \
+      if ! from_att? && Flor.is_func_tree?(payload_ret)
+
     ms = apply(src, args, tree[2])
 
     @node['applied'] = ms.first['nid']
 
     ms
   end
+
+  def rewrite_block_into_function
+
+    t = tree
+    cn = t[1][@ncid..-1]
+    c0 = cn[0]
+
+    return if cn.size == 1 && %w[ def fun ].include?(c0[0])
+      #
+      # if the single child is a "def" or "fun", no need to rewrite,
+      # that single child function becomes the block
+
+    bt = [ 'def', cn, t[2] ]
+    t[1] = (@fcid ? t[1][0..@fcid] : []) + [ bt ]
+
+    @node['tree'] = t
+  end
 end
 

data/lib/flor/pcore/arith.rb

@@ -42,16 +42,28 @@ class Flor::Pro::Arith < Flor::Procedure
     fail Flor::FlorError.new('modulo % requires at least 2 arguments', self) \
       if sign == :% && count < 2
 
-    payload['ret'] =
+    ret =
       if @node['rets'].compact.empty?
         DEFAULTS[sign]
       elsif sign == :+
-        @node['rets'].reduce { |r, e| r + (r.is_a?(String) ? e.to_s : e) }
+        @node['rets'].reduce { |r, e|
+          # TODO use djan instead of #to_s?
+          # TODO use JSON instead of #to_s or djan?
+          r + (r.is_a?(String) ? e.to_s : e) }
       else
-        @node['rets'].reduce(&sign)
+        rets = @node['rets']
+        rets = rets.collect(&:to_f) \
+          if sign == :/ || rets.find { |r| r.is_a?(Float) }
+        rets.reduce(&sign)
       end
 
-    wrap_reply
+    unless ret.is_a?(String)
+      round = ret.round
+      ret = round if round.to_f.to_s == ret.to_f.to_s
+    end
+      # follow JSON somehow, in show "1.0" as "1"...
+
+    wrap_reply('ret' => ret)
   end
 end
 

data/lib/flor/pcore/array_qmark.rb

@@ -0,0 +1,100 @@
+
+class Flor::Pro::ArrayQmark < Flor::Procedure
+  #
+  # Returns true if the argument or the incoming ret matches in type.
+  #
+  # ```
+  # array? []        # => true,
+  # []; array? _     # => true,
+  # array? false     # => false,
+  # false; array? _  # => false,
+  #
+  # object? {}     # => true,
+  # object? false  # => false,
+  #
+  # number? 0       # => true,
+  # number? 0.1     # => true,
+  # number? "dang"  # => false,
+  # number? []      # => false,
+  #
+  # string? "hello"  # => true,
+  # string? []       # => false,
+  #
+  # true? true   # => true,
+  # true? false  # => false,
+  # true? 0      # => false,
+  #
+  # boolean? true   # => true,
+  # boolean? false  # => true,
+  # boolean? []     # => false,
+  #
+  # null? null  # => true,
+  # null? 0     # => false,
+  #
+  # false? false    # => true,
+  # false? true     # => false,
+  # false? "false"  # => false,
+  #
+  # nil? null  # => true,
+  # nil? 0     # => false,
+  #
+  # pair? [ 0 1 ]  # => true,
+  # pair? []       # => false,
+  # pair? 0        # => false,
+  #
+  # float? 1.0  # => true,
+  # float? 1    # => false,
+  # float? {}   # => false,
+  #
+  # boolean? true tag: "xxx"   # => true,
+  # true; boolean? tag: "xxx"  # => true,
+  # string? {} tag: "xxx"      # => false,
+  # {}; string? tag: "xxx"     # => false,
+  # ```
+  #
+  # ## see also
+  #
+  # type-of, type
+
+  names %w[
+    array? object? boolean? number? string? null?
+    list? dict? hash? nil?
+    false? true?
+    pair? float? ]
+
+  def pre_execute
+
+    @node['ret'] = receive_payload_ret
+
+    unatt_unkeyed_children
+  end
+
+  def receive_last
+
+    t = Flor.type(@node['ret'])
+
+    r =
+      case h = heap
+
+      when 'array?', 'list?' then t == :array
+      when 'object?', 'hash?' 'dict?' then t == :object
+      when 'boolean?' then t == :boolean
+      when 'number?' then t == :number
+      when 'string?' then t == :string
+      when 'null?', 'nil?' then t == :null
+
+      when 'false?' then @node['ret'] == false
+      when 'true?' then @node['ret'] == true
+
+      when 'pair?' then t == :array && @node['ret'].length == 2
+      when 'float?' then t == :number && @node['ret'].to_s.index('.') != nil
+
+      else fail(Flor::FlorError.new("#{h.inspect} not yet implemented", self))
+      end
+
+    wrap_reply('ret' => r)
+  end
+
+  def receive_payload_ret; payload['ret']; end # don't duplicate the ret
+end
+

data/lib/flor/pcore/break.rb

@@ -60,7 +60,6 @@ class Flor::Pro::Break < Flor::Procedure
 
     ref = att('ref')
     nid = tags_to_nids(ref).first || @node['heat'][1]['nid']
-#p [ :break, @node['heap'], nid ]
 
     payload['ret'] = att(nil) if has_att?(nil)
 
@@ -68,7 +67,7 @@ class Flor::Pro::Break < Flor::Procedure
 
     if nid
 
-      ms += wrap_cancel('nid' => nid, 'flavour' => @node['heap'])
+      ms += wrap_cancel('nid' => nid, 'flavour' => heap)
     end
 
     unless is_ancestor_node?(nid)

data/lib/flor/pcore/case.rb

@@ -87,7 +87,7 @@ class Flor::Pro::Case < Flor::Procedure
   #
   # ## see also
   #
-  # Match.
+  # Match, cond, if.
 
   name 'case'
 

data/lib/flor/pcore/cmp.rb

@@ -1,7 +1,7 @@
 
 class Flor::Pro::Cmp < Flor::Procedure
 
-  names %w[ = == < > ]
+  names %w[ = == < > <= >= != <> ]
 
   def pre_execute
 
@@ -14,7 +14,8 @@ class Flor::Pro::Cmp < Flor::Procedure
       if @node['rets'].size > 1
         case tree[0]
         when '=', '==' then check_equal
-        when '<', '>' then check_lesser
+        when '!=', '<>' then ! check_equal
+        when '<', '>', '>=', '<=' then check_lesser
         else true
         end
       else

data/lib/flor/pcore/collect.rb

@@ -4,7 +4,7 @@ require 'flor/pcore/iterator'
 
 class Flor::Pro::Collect < Flor::Macro::Iterator
   #
-  # Collect is a simplified version of [map](map.md).
+  # A simplified version of [map](map.md).
   #
   # ```
   # map [ 1, 2, 3 ]
@@ -38,7 +38,7 @@ class Flor::Pro::Collect < Flor::Macro::Iterator
   #
   # ## see also
   #
-  # Map.
+  # Map, cmap, ccollect.
 
   name 'collect'
 

data/lib/flor/pcore/cond.rb

@@ -35,9 +35,27 @@ class Flor::Pro::Cond < Flor::Procedure
   #   else | "ten or bigger"
   # ```
   #
+  # Please note that, as for [if](if.md), composite consequences have to be
+  # "packaged":
+  # ```
+  # cond
+  #   a < 4
+  #     sequence
+  #       do_this
+  #       do_that
+  #   a < 7
+  #     concurrence
+  #       do_this
+  #       do_that
+  #   else
+  #     sequence
+  #       do_this 'default'
+  #       do_that 'default'
+  # ```
+  #
   # ## see also
   #
-  # If, match.
+  # If, match, case.
 
   name 'cond'