File: concrete-syntax/core/expression/binary/infix/infix.rb

Overview
Module Structure
Class Hierarchy
Code

Overview

Module Structure

  module: <Toplevel Module>
  module: Umu#6
  module: ConcreteSyntax#8
  module: Core#10
  module: Expression#12
has properties
function: make_infix / 4 #114
function: make_kindof / 4 #126
function: make_andalso / 4 #138
function: make_orelse / 4 #150
  module: Binary#14
  module: Infix#16
  class: Redefinable#18
inherits from
  Simple ( Umu::ConcreteSyntax::Core::Expression::Binary::Infix::Abstraction )
has properties
method: __desugar__ / 2 #22
  class: KindOf#36
inherits from
  Abstract ( Umu::ConcreteSyntax::Core::Expression::Binary::Infix::Abstraction )
has properties
alias: rhs_ident rhs_opnd #37
method: initialize / 4 #39
method: __desugar__ / 2 #50
  class: AndAlso#63
inherits from
  Simple ( Umu::ConcreteSyntax::Core::Expression::Binary::Infix::Abstraction )
has properties
method: __desugar__ / 2 #67
  class: OrElse#86
inherits from
  Simple ( Umu::ConcreteSyntax::Core::Expression::Binary::Infix::Abstraction )
has properties
method: __desugar__ / 2 #90

Code

   1  # coding: utf-8
   2  # frozen_string_literal: true
   3 
   4 
   5 
   6  module Umu
   7 
   8  module ConcreteSyntax
   9 
  10  module Core
  11 
  12  module Expression
  13 
  14  module Binary
  15 
  16  module Infix
  17 
  18  class Redefinable < Abstraction::Simple
  19 
  20  private
  21 
  22      def __desugar__(env, event)
  23          new_env = env.enter event
  24 
  25          ASCE.make_apply(
  26              self.loc,
  27              ASCE.make_identifier(loc, self.opr_sym),
  28              self.lhs_opnd.desugar(new_env),
  29              [self.rhs_opnd.desugar(new_env)]
  30          )
  31      end
  32  end
  33 
  34 
  35 
  36  class KindOf < Abstraction::Abstract
  37      alias rhs_ident rhs_opnd
  38 
  39      def initialize(loc, lhs_opnd, opr_sym, rhs_ident)
  40          ASSERT.kind_of lhs_opnd,    CSCE::Abstract
  41          ASSERT.kind_of opr_sym,     ::Symbol
  42          ASSERT.kind_of rhs_ident,   CSCEU::Identifier::Short
  43 
  44          super
  45      end
  46 
  47 
  48  private
  49 
  50      def __desugar__(env, event)
  51          new_env = env.enter event
  52 
  53          ASCE.make_test_kind_of(
  54              self.loc,
  55              self.lhs_opnd.desugar(new_env),
  56              self.rhs_ident.desugar(new_env)
  57          )
  58      end
  59  end
  60 
  61 
  62 
  63  class AndAlso < Abstraction::Simple
  64 
  65  private
  66 
  67      def __desugar__(env, event)
  68          new_env = env.enter event
  69 
  70          ASCE.make_if(
  71              self.loc,
  72              [
  73                  ASCE.make_rule(
  74                      self.loc,
  75                      self.lhs_opnd.desugar(new_env),
  76                      self.rhs_opnd.desugar(new_env)
  77                  )
  78              ],
  79              ASCE.make_bool(self.loc, false)
  80          )
  81      end
  82  end
  83 
  84 
  85 
  86  class OrElse < Abstraction::Simple
  87 
  88  private
  89 
  90      def __desugar__(env, event)
  91          new_env = env.enter event
  92 
  93          ASCE.make_if(
  94              self.loc,
  95              [
  96                  ASCE.make_rule(
  97                      self.loc,
  98                      self.lhs_opnd.desugar(new_env),
  99                      ASCE.make_bool(loc, true)
 100                  )
 101              ],
 102              self.rhs_opnd.desugar(new_env)
 103          )
 104      end
 105  end
 106 
 107  end # Umu::ConcreteSyntax::Core::Expression::Binary::Infix
 108 
 109  end # Umu::ConcreteSyntax::Core::Expression::Binary
 110 
 111 
 112  module_function
 113 
 114      def make_infix(loc, lhs_opnd, opr_sym, rhs_opnd)
 115          ASSERT.kind_of loc,         LOC::Entry
 116          ASSERT.kind_of lhs_opnd,    CSCE::Abstract
 117          ASSERT.kind_of opr_sym,     ::Symbol
 118          ASSERT.kind_of rhs_opnd,    CSCE::Abstract
 119 
 120          Binary::Infix::Redefinable.new(
 121              loc, lhs_opnd, opr_sym, rhs_opnd
 122          ).freeze
 123      end
 124 
 125 
 126      def make_kindof(loc, lhs_opnd, opr_sym, rhs_ident)
 127          ASSERT.kind_of loc,         LOC::Entry
 128          ASSERT.kind_of lhs_opnd,    CSCE::Abstract
 129          ASSERT.kind_of opr_sym,     ::Symbol
 130          ASSERT.kind_of rhs_ident,   CSCEU::Identifier::Short
 131 
 132          Binary::Infix::KindOf.new(
 133              loc, lhs_opnd, opr_sym, rhs_ident
 134          ).freeze
 135      end
 136 
 137 
 138      def make_andalso(loc, lhs_opnd, opr_sym, rhs_opnd)
 139          ASSERT.kind_of loc,         LOC::Entry
 140          ASSERT.kind_of lhs_opnd,    CSCE::Abstract
 141          ASSERT.kind_of opr_sym,     ::Symbol
 142          ASSERT.kind_of rhs_opnd,    CSCE::Abstract
 143 
 144          Binary::Infix::AndAlso.new(
 145              loc, lhs_opnd, opr_sym, rhs_opnd
 146          ).freeze
 147      end
 148 
 149 
 150      def make_orelse(loc, lhs_opnd, opr_sym, rhs_opnd)
 151          ASSERT.kind_of loc,         LOC::Entry
 152          ASSERT.kind_of lhs_opnd,    CSCE::Abstract
 153          ASSERT.kind_of opr_sym,     ::Symbol
 154          ASSERT.kind_of rhs_opnd,    CSCE::Abstract
 155 
 156          Binary::Infix::OrElse.new(
 157              loc, lhs_opnd, opr_sym, rhs_opnd
 158          ).freeze
 159      end
 160 
 161  end # Umu::ConcreteSyntax::Core::Expression
 162 
 163  end # Umu::ConcreteSyntax::Core
 164 
 165  end # Umu::ConcreteSyntax
 166 
 167  end # Umu