1  # coding: utf-8
   2  # frozen_string_literal: true
   3 
   4 
   5 
   6  module Umu
   7 
   8  module AbstractSyntax
   9 
  10  module Core
  11 
  12  module Expression
  13 
  14  module Unary
  15 
  16  module Container
  17 
  18  class CellStream < Abstraction::Expressions
  19      attr_reader :opt_last_expr
  20 
  21 
  22      def initialize(loc, exprs, opt_last_expr, is_memorized)
  23          ASSERT.kind_of     exprs,           ::Array
  24          ASSERT.opt_kind_of opt_last_expr,   ASCE::Abstract
  25          ASSERT.bool        is_memorized
  26          ASSERT.assert (
  27              if exprs.empty? then opt_last_expr.nil? else true end
  28          )
  29 
  30          super(loc, exprs)
  31 
  32          @opt_last_expr = opt_last_expr
  33          @is_memorized  = is_memorized
  34      end
  35 
  36 
  37      def empty?
  38          self.exprs.empty? && self.opt_last_expr.nil?
  39      end
  40 
  41 
  42      def memorized?
  43          @is_memorized
  44      end
  45 
  46 
  47      def to_s
  48          [
  49              '&',
  50 
  51              __bb_str__,
  52 
  53              self.map(&:to_s).join(', '),
  54 
  55              if self.opt_last_expr
  56                  '|' + self.opt_last_expr.to_s
  57              else
  58                  ''
  59              end,
  60 
  61              __eb_str__
  62          ].join
  63      end
  64 
  65 
  66      def pretty_print(q)
  67          bb = '&' + __bb_str__
  68          eb = __eb_str__
  69 
  70          if self.opt_last_expr
  71              PRT.group_for_enum q, self, bb:bb, join:', '
  72              PRT.group q, bb:'|', eb:eb do
  73                  q.pp self.opt_last_expr
  74              end
  75          else
  76              PRT.group_for_enum q, self, bb:bb, eb:eb, join:', '
  77          end
  78      end
  79 
  80 
  81  private
  82 
  83      def __bb_str__
  84          self.memorized? ? '{' : '['
  85      end
  86 
  87 
  88      def __eb_str__
  89          self.memorized? ? '}' : ']'
  90      end
  91 
  92 
  93      def __evaluate__(env, event)
  94          new_env = env.enter event
  95 
  96          result = (
  97              if self.memorized?
  98                  VC.make_memo_stream_entry self, new_env.va_context
  99              else
 100                  init_stream =
 101                      if self.opt_last_expr
 102                          VC.make_expr_stream_entry(
 103                              self.opt_last_expr,
 104                              new_env.va_context
 105                          )
 106                      else
 107                          VC.make_cell_stream_nil new_env.va_context
 108                      end
 109 
 110                  self.exprs.reverse.inject(init_stream) {
 111                      |stream, expr|
 112 
 113                      VC.make_cell_stream_cons(
 114                          expr, stream, new_env.va_context
 115                      )
 116                  }
 117              end
 118          )
 119 
 120          ASSERT.kind_of result, VCM::Stream::Entry::Abstract
 121      end
 122  end
 123 
 124  end # Umu::AbstractSyntax::Core::Expression::Unary::Container
 125 
 126  end # Umu::AbstractSyntax::Core::Expression::Unary
 127 
 128 
 129  module_function
 130 
 131      def make_stream(loc, exprs, opt_last_expr = nil, is_memorized = false)
 132          ASSERT.kind_of     loc,             LOC::Entry
 133          ASSERT.kind_of     exprs,           ::Array
 134          ASSERT.opt_kind_of opt_last_expr,   ASCE::Abstract
 135          ASSERT.bool        is_memorized
 136 
 137          Unary::Container::CellStream.new(
 138              loc, exprs.freeze, opt_last_expr, is_memorized
 139          ).freeze
 140      end
 141 
 142  end # Umu::AbstractSyntax::Core::Expression
 143 
 144  end # Umu::AbstractSyntax::Core
 145 
 146  end # Umu::AbstractSyntax
 147 
 148  end # Umu