sfrp 1.1.0

data/lib/sfrp/error.rb

@@ -0,0 +1,4 @@
+module SFRP
+  class CompileError < StandardError
+  end
+end

data/lib/sfrp/file.rb

@@ -0,0 +1,18 @@
+require 'sfrp/error'
+
+module SFRP
+  VirtualFile = Struct.new(:fmodule_uri, :file_ext, :content)
+  SourceFile = Struct.new(:fmodule_uri, :content)
+
+  class FileResolveError < CompileError
+    def initialize(fmodule_uri, include_paths)
+      @fmodule_uri = fmodule_uri
+      @include_paths = include_paths
+    end
+
+    def message
+      "cannot find '#{@fmodule_uri}' in include paths:\n" +
+      @include_paths.join("\n")
+    end
+  end
+end

data/lib/sfrp/flat/dsl.rb

@@ -0,0 +1,33 @@
+module SFRP
+  module Flat
+    extend SFRP::F = self
+
+    def t(tconst_str, args, sp = nil)
+      TypeAnnotationType.new(tconst_str, args, sp)
+    end
+
+    def tv(var_str, sp = nil)
+      TypeAnnotationVar.new(var_str, sp)
+    end
+
+    def ft(ret_t, arg_ts)
+      FuncTypeAnnotation.new(ret_t, arg_ts)
+    end
+
+    def v_e(var_str, sp = nil)
+      VarRefExp.new(var_str, sp)
+    end
+
+    def nr_e(node_str, last, sp = nil)
+      NodeRefExp.new(node_str, last, sp)
+    end
+
+    def call_e(func_str, args, sp = nil)
+      FuncCallExp.new(func_str, args, sp)
+    end
+
+    def vc_call_e(vconst_str, args, sp = nil)
+      VConstCallExp.new(vconst_str, args, sp)
+    end
+  end
+end

data/lib/sfrp/flat/elements.rb

@@ -0,0 +1,90 @@
+module SFRP
+  module Flat
+    class Function < Struct.new(:str, :ret_ta, :pstrs, :ptas, :exp, :ffi_str, :sp)
+      def to_poly(_src_set, dest_set)
+        pstrs.reject(&:nil?).each do |s|
+          raise DuplicatedVariableError.new(s) if pstrs.count(s) > 1
+        end
+        dest_set << P.func(str, ret_ta && ret_ta.to_poly) do |f|
+          pstrs.zip(ptas) do |s, ta|
+            f.param(s, ta && ta.to_poly)
+          end
+          if exp
+            f.exp do
+              table = Hash[pstrs.map { |s| [s, s] }]
+              exp.alpha_convert(table, (0..1000).to_a).to_poly
+            end
+          end
+          f.ffi_str(ffi_str) if ffi_str
+        end
+      end
+    end
+
+    class TConst < Struct.new(:str, :pstrs, :vc_strs, :native_str, :static, :sp)
+      def type_annot
+        TypeAnnotationType.new(str, pstrs.map { |s| TypeAnnotationVar.new(s) })
+      end
+
+      def to_poly(_src_set, dest_set)
+        argc = pstrs.size
+        dest_set << Poly::TConst.new(str, argc, vc_strs, static, native_str)
+      end
+    end
+
+    class VConst < Struct.new(:str, :tconst_str, :native_str, :param_tas, :sp)
+      def to_poly(src_set, dest_set)
+        tconst = src_set.tconst(tconst_str)
+        fta = FuncTypeAnnotation.new(tconst.type_annot, param_tas)
+        dest_set << Poly::VConst.new(str, tconst.pstrs, fta.to_poly, native_str)
+      end
+    end
+
+    class Node < Struct.new(:str, :ta, :exp, :init_exp, :sp)
+      def initialized?
+        !init_exp.nil?
+      end
+
+      def to_poly(src_set, dest_set)
+        dest_set << P.node(str, ta && ta.to_poly) do |n|
+          collected_node_refs = []
+          poly_exp = exp.alpha_convert({}, (0..1000).to_a)
+            .lift_node_ref(collected_node_refs).to_poly
+          collected_node_refs.each do |nr|
+            if nr.last && !src_set.node(nr.node_str).initialized?
+              raise NodeInvalidLastReferrenceError.new(nr.node_str)
+            end
+            nr.last ? n.l(nr.node_str) : n.c(nr.node_str)
+          end
+          dest_set << n.eval_func(str, ta && ta.to_poly) do |f|
+            f.exp { poly_exp }
+            collected_node_refs.each_with_index.map do |_, i|
+              f.param("__node_ref_#{i}")
+            end
+          end
+          next if init_exp.nil?
+          dest_set << n.init_func(str + '#init', ta && ta.to_poly) do |f|
+            f.exp { init_exp.alpha_convert({}, (0..1000).to_a).to_poly }
+          end
+        end
+      end
+    end
+
+    class FuncTypeAnnotation < Struct.new(:ret_ta, :arg_tas, :sp)
+      def to_poly
+        Poly::FuncTypeAnnotation.new(ret_ta.to_poly, arg_tas.map(&:to_poly))
+      end
+    end
+
+    class TypeAnnotationType < Struct.new(:tconst_str, :arg_tas, :sp)
+      def to_poly
+        P.t(tconst_str, *arg_tas.map(&:to_poly))
+      end
+    end
+
+    class TypeAnnotationVar < Struct.new(:var_str, :sp)
+      def to_poly
+        P.tv(var_str)
+      end
+    end
+  end
+end

data/lib/sfrp/flat/exception.rb

@@ -0,0 +1,45 @@
+require 'sfrp/error'
+
+module SFRP
+  module Flat
+    class NodeRefInIllegalPositionError < CompileError
+      def initialize(node_str)
+        @node_str = node_str
+      end
+
+      def message
+        "don't refer node '#{@node_str}'"
+      end
+    end
+
+    class DuplicatedVariableError < CompileError
+      def initialize(var_str)
+        @var_str = var_str
+      end
+
+      def message
+        "duplicated variable '#{@var_str}'"
+      end
+    end
+
+    class UnboundLocalVariableError < CompileError
+      def initialize(var_str)
+        @var_str = var_str
+      end
+
+      def message
+        "unbound variable '#{@var_str}'"
+      end
+    end
+
+    class NodeInvalidLastReferrenceError < CompileError
+      def initialize(node_str)
+        @node_str = node_str
+      end
+
+      def message
+        "node '#{@node_str}' should be initialized"
+      end
+    end
+  end
+end

data/lib/sfrp/flat/expression.rb

@@ -0,0 +1,125 @@
+module SFRP
+  module Flat
+    class FuncCallExp < Struct.new(:func_str, :arg_exps, :sp)
+      def lift_node_ref(collected_node_refs)
+        args = arg_exps.map { |e| e.lift_node_ref(collected_node_refs) }
+        FuncCallExp.new(func_str, args, sp)
+      end
+
+      def alpha_convert(table, serial)
+        args = arg_exps.map { |e| e.alpha_convert(table, serial) }
+        FuncCallExp.new(func_str, args)
+      end
+
+      def to_poly
+        P.call_e(func_str, *arg_exps.map(&:to_poly))
+      end
+    end
+
+    class VConstCallExp < Struct.new(:vconst_str, :arg_exps, :sp)
+      def lift_node_ref(collected_node_refs)
+        args = arg_exps.map { |e| e.lift_node_ref(collected_node_refs) }
+        VConstCallExp.new(vconst_str, args, sp)
+      end
+
+      def alpha_convert(table, serial)
+        args = arg_exps.map { |e| e.alpha_convert(table, serial) }
+        VConstCallExp.new(vconst_str, args)
+      end
+
+      def to_poly
+        P.vc_call_e(vconst_str, *arg_exps.map(&:to_poly))
+      end
+    end
+
+    class NodeRefExp < Struct.new(:node_str, :last, :sp)
+      NodeRef = Struct.new(:node_str, :last)
+
+      def lift_node_ref(collected_node_refs)
+        node_ref = NodeRef.new(node_str, last)
+        unless collected_node_refs.include?(node_ref)
+          collected_node_refs << node_ref
+        end
+        VarRefExp.new("__node_ref_#{collected_node_refs.index(node_ref)}", sp)
+      end
+
+      def alpha_convert(_table, _serial)
+        self
+      end
+
+      def to_poly
+        raise NodeRefInIllegalPositionError.new(node_str)
+      end
+    end
+
+    class MatchExp < Struct.new(:left_exp, :cases, :sp)
+      Case = Struct.new(:pattern, :exp)
+
+      class Pattern < Struct.new(:vconst_str, :ref_var_str, :args, :sp)
+        def alpha_convert(table, serial)
+          new_ref_var_str =
+            ref_var_str && (table[ref_var_str] = "_alpha#{serial.shift}")
+          new_args = args.map { |a| a.alpha_convert(table, serial) }
+          Pattern.new(vconst_str, new_ref_var_str, new_args)
+        end
+
+        def var_strs
+          [ref_var_str, *args.flat_map(&:var_strs)].reject(&:nil?)
+        end
+
+        def duplicated_var_check
+          vstrs = var_strs
+          vstrs.each do |s|
+            raise DuplicatedVariableError.new(s) if vstrs.count(s) > 1
+          end
+        end
+
+        def to_poly
+          Poly::Pattern.new(vconst_str, ref_var_str, args.map(&:to_poly))
+        end
+      end
+
+      def lift_node_ref(collected_node_refs)
+        new_left_exp = left_exp.lift_node_ref(collected_node_refs)
+        new_cases = cases.map do |c|
+          Case.new(c.pattern, c.exp.lift_node_ref(collected_node_refs))
+        end
+        MatchExp.new(new_left_exp, new_cases, sp)
+      end
+
+      def alpha_convert(table, serial)
+        new_left_exp = left_exp.alpha_convert(table, serial)
+        new_cases = cases.map do |c|
+          c.pattern.duplicated_var_check
+          new_table = table.clone
+          new_pattern = c.pattern.alpha_convert(new_table, serial)
+          new_exp = c.exp.alpha_convert(new_table, serial)
+          Case.new(new_pattern, new_exp)
+        end
+        MatchExp.new(new_left_exp, new_cases)
+      end
+
+      def to_poly
+        poly_cases = cases.map do |c|
+          Poly::MatchExp::Case.new(c.pattern.to_poly, c.exp.to_poly)
+        end
+        Poly::MatchExp.new(left_exp.to_poly, poly_cases)
+      end
+    end
+
+    class VarRefExp < Struct.new(:var_str, :sp)
+      def lift_node_ref(_collected_node_refs)
+        self
+      end
+
+      def alpha_convert(table, _)
+        raise UnboundLocalVariableError.new(var_str) unless table.key?(var_str)
+        VarRefExp.new(table[var_str])
+      end
+
+      def to_poly
+        P.v_e(var_str)
+      end
+    end
+  end
+end

data/lib/sfrp/flat/set.rb

@@ -0,0 +1,61 @@
+require 'sfrp/flat/elements'
+require 'sfrp/flat/exception'
+require 'sfrp/flat/expression'
+require 'sfrp/flat/dsl'
+
+module SFRP
+  module Flat
+    class Set
+      def initialize(&block)
+        @funcs = []
+        @tconsts = []
+        @vconsts = []
+        @nodes = []
+        @output_node_strs = []
+        @init_func_strs = []
+        block.call(self) if block
+      end
+
+      def to_poly
+        Poly::Set.new do |dest_set|
+          (@funcs + @tconsts + @vconsts + @nodes).each do |element|
+            element.to_poly(self, dest_set)
+          end
+          @output_node_strs.each { |s| dest_set.append_output_node_str(s) }
+          @init_func_strs.each { |s| dest_set.append_init_func_str(s) }
+        end
+      end
+
+      def append_output_node_str(node_str)
+        @output_node_strs << node_str
+      end
+
+      def append_init_func_str(init_func_str)
+        @init_func_strs << init_func_str
+      end
+
+      def <<(element)
+        case element
+        when Function
+          @funcs << element
+        when TConst
+          @tconsts << element
+        when VConst
+          @vconsts << element
+        when Node
+          @nodes << element
+        else
+          raise
+        end
+      end
+
+      def tconst(str)
+        @tconsts.find { |tconst| tconst.str == str }
+      end
+
+      def node(str)
+        @nodes.find { |node| node.str == str }
+      end
+    end
+  end
+end

data/lib/sfrp/input/exception.rb

@@ -0,0 +1,16 @@
+require 'sfrp/error'
+
+module SFRP
+  module Input
+    class ParseError < CompileError
+      def initialize(message)
+        @message = message
+      end
+
+      def message
+        "Syntax error. The raw error message from Parslet is as follows:\n" +
+        @message
+      end
+    end
+  end
+end

data/lib/sfrp/input/parser.rb

@@ -0,0 +1,417 @@
+require 'sfrp/input/exception'
+require 'parslet'
+
+module SFRP
+  module Input
+    module Parser
+      extend self
+
+      def parse(source_file)
+        parser = Parser.new
+        transformer = Transformer.new
+        defs = transformer.apply(parser.parse(source_file.content))
+        imports, others = defs.each_with_object([[], []]) do |a, o|
+          case a
+          when Raw::Import
+            o[0] << a
+          else
+            o[1] << a
+          end
+        end
+        ns = Raw::Namespace.new(source_file.fmodule_uri, imports)
+        others.each do |a|
+          a.ns = ns
+          a.vconsts.each { |b| b.ns = ns } if a.is_a?(Raw::TConst)
+        end
+        others
+      rescue Parslet::ParseFailed => err
+        raise ParseError.new(err.cause.ascii_tree)
+      end
+
+      class Parser < Parslet::Parser
+        # file
+        root(:file)
+        rule(:file) {
+          (ws? >> listing(toplevel_definition, ws_inc_newline).as(:defs) >> ws?)
+          .as(:file)
+        }
+
+        # toplevel definition
+        rule(:toplevel_definition) {
+          import_def |
+          init_def |
+          prim_type_def | prim_enum_type_def | type_def |
+          foreign_func_def | function_def | infix_def |
+          node_def | input_def | output_def
+        }
+        rule(:import_def) {
+          (str('import') >> ws >> listing(up_ident, str('.')).as(:path) >>
+          (ws >> str('as') >> ws >> up_ident.as(:qualifier_name))
+          .maybe.as(:as_maybe)).as(:import_def)
+        }
+        rule(:init_def) {
+          (str('init').as(:key) >> ws >> io_func_ref.as(:func_ref) >>
+          ws_inline? >>
+          str('(') >> ws? >> listing0(exp, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(')')).as(:init_def)
+        }
+        rule(:prim_type_def) {
+          (str('ptype') >> ws >> up_ident.as(:tconst_str) >> ws? >>
+          foreign_str.as(:c_type_str) >> ws? >> str('=') >> ws? >>
+          str('/') >> match['^/'].repeat(1).as(:rexp) >> str('/') >>
+          match['^/'].repeat(1).as(:replace) >> str('/')).as(:prim_type_def)
+        }
+        rule(:prim_enum_type_def) {
+          (str('ptype') >> ws >> up_ident.as(:tconst_str) >> ws? >>
+          foreign_str.as(:c_type_str) >> ws? >> str('=') >> ws? >>
+          listing(prim_enum_vconst_def, ws? >> str('|') >> ws?)
+          .as(:vconst_defs)).as(:prim_enum_type_def)
+        }
+        rule(:prim_enum_vconst_def) {
+          (up_ident.as(:vconst_str) >> ws? >> foreign_str.as(:c_value_str))
+          .as(:prim_enum_vconst_def)
+        }
+        rule(:type_def) {
+          tconst_params = (str('[') >> ws? >>
+          listing0(low_ident, ws? >> str(',') >> ws?).as(:params) >> ws? >>
+          str(']')).maybe.as(:params_maybe)
+          (str('type') >> ws? >> ((str('+') | str('*')).as(:m) >> ws?)
+          .maybe.as(:modifier) >> up_ident.as(:tconst_name) >> ws_inline? >>
+          tconst_params >> ws? >> str('=') >> ws? >> listing(vconst_def,
+          ws? >> str('|') >> ws?).as(:vconst_defs)).as(:type_def)
+        }
+        rule(:vconst_def) {
+          (up_ident.as(:vconst_name) >>
+          (ws_inline? >> str('(') >> ws? >> listing0(type_annot, ws? >>
+          str(',') >> ws?).as(:type_annots) >> ws? >> str(')'))
+          .maybe.as(:type_annots_maybe)).as(:vconst_def)
+        }
+        rule(:foreign_func_def) {
+          (str('foreign') >> ws >>
+          (low_ident | up_ident | op_ident).as(:c_func_name) >> ws >>
+          str('as') >> ws >>
+          ((str('$').maybe >> low_ident) | op_ident).as(:func_name) >>
+          ws_inline? >>
+          str('(') >> ws? >> listing0(fixed_type_annot, ws? >> str(',') >>
+          ws?).as(:params) >> ws? >>
+          str(')') >> ws? >> str(':') >> ws? >>
+          fixed_type_annot.as(:ret_type_annot))
+          .as(:foreign_func_def)
+        }
+        rule(:function_def) {
+          param = low_ident.as(:param_name) >> type_annot_maybe.as(:type_annot)
+          (((str('op') >> ws? >> op_ident.as(:func_name)) | (str('$').maybe >>
+          low_ident).as(:func_name)) >> ws_inline? >>
+          str('(') >> ws? >> listing0(param, ws? >> str(',') >> ws?)
+          .as(:params) >> ws? >>
+          str(')') >> type_annot_maybe.as(:ret_type_annot) >> ws? >> str('=') >>
+          ws? >> where_exp.as(:exp)).as(:function_def)
+        }
+        rule(:infix_def) {
+          (str('infix') >> (str('l') | str('r')).maybe.as(:direction) >>
+          ws >> (op_ref | bq_op_ref).as(:func_ref) >> ws >>
+          match['0-9'].repeat(1).as(:priority)).as(:infix_def)
+        }
+        rule(:node_def) {
+          ((str('@') >> low_ident).as(:node_name) >>
+          init_def_maybe.as(:init_exp) >> type_annot_maybe.as(:type_annot) >>
+          ws? >> str('=') >> ws? >> where_exp.as(:eval_exp)).as(:node_def)
+        }
+        rule(:input_def) {
+          (str('in') >> ws >> (str('@') >> low_ident).as(:node_name) >>
+          init_def_maybe.as(:init_exp) >>
+          type_annot_maybe.as(:type_annot) >>
+          ws >> str('from') >> ws >> io_func_ref.as(:func_ref) >> ws_inline? >>
+          str('(') >> ws? >> listing0(exp, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(')')).as(:input_def)
+        }
+        rule(:output_def) {
+          (str('out').as(:key) >> ws >> io_func_ref.as(:func_ref) >>
+          ws_inline? >>
+          str('(') >> ws? >> listing(exp, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(')')).as(:output_def)
+        }
+        rule(:init_def_maybe) {
+          (ws? >> exp.as(:init_exp)).maybe.as(:init_def_maybe)
+        }
+        rule(:foreign_str) {
+          (str('{') >> match['^}'].repeat(1).as(:str) >> str('}'))
+          .as(:foreign_str)
+        }
+
+        # type annotation
+        rule(:type_annot_maybe) {
+          (ws? >> str(':') >> ws? >> type_annot).maybe.as(:type_annot_maybe)
+        }
+        rule(:type_annot) {
+          type_annot_type | type_annot_var | type_annot_tuple
+        }
+        rule(:type_annot_type) {
+          whole = tconst_ref.as(:tconst_ref) >> (ws_inline? >> str('[') >>
+          ws? >> listing0(type_annot, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(']')).maybe.as(:args_maybe)
+          whole.as(:type_annot_type)
+        }
+        rule(:type_annot_tuple) {
+          (str('(') >> ws? >> listing2(type_annot, ws? >> str(',') >> ws?)
+          .as(:args) >> ws? >> str(')')).as(:type_annot_tuple)
+        }
+        rule(:type_annot_var) {
+          low_ident.as(:type_annot_var)
+        }
+
+        # fixed type annotation
+        rule(:fixed_type_annot) {
+          fixed_type_annot_type | fixed_type_annot_tuple
+        }
+        rule(:fixed_type_annot_type) {
+          whole = tconst_ref.as(:tconst_ref) >> (ws_inline? >> str('[') >>
+          ws? >> listing0(fixed_type_annot, ws? >> str(',') >>
+          ws?).as(:args) >> ws? >> str(']')).maybe.as(:args_maybe)
+          whole.as(:type_annot_type)
+        }
+        rule(:fixed_type_annot_tuple) {
+          (str('(') >> ws? >> listing2(fixed_type_annot, ws? >> str(',') >>
+          ws?).as(:args) >> ws? >> str(')')).as(:type_annot_tuple)
+        }
+
+        # expression
+        rule(:exp) {
+          seq_exp
+        }
+        rule(:where_exp) {
+          whole = seq_exp.as(:exp) >> (ws >> str('where') >> ws >>
+          dynamic { |s, _|
+            indent = str("\s").repeat(s.line_and_column[1] - 1)
+            separator = (ws_inline? >> newline >> indent) | ws? >> str(';') >> ws?
+            listing(assign, separator).as(:assignments)
+          }).maybe.as(:where_clause_maybe)
+          whole.as(:where_exp)
+        }
+        rule(:seq_exp) {
+          whole = single_exp.as(:exp) >> (ws? >>
+          (op_ref | bq_op_ref).as(:func_ref) >> ws? >>
+          single_exp.as(:exp)).repeat
+          whole.as(:seq_exp)
+        }
+        rule(:single_exp) {
+          # controling
+          if_exp | let_exp | match_exp | unary_op_exp |
+          # calling
+          func_call_exp | io_func_call_exp |
+          vc_call_exp_with_paren | vc_call_exp_without_paren |
+          tuple_exp |
+          # reference
+          node_last_ref_exp | node_current_ref_exp | var_ref_exp |
+          # parenthesis
+          str('(') >> ws? >> exp >> ws? >> str(')')
+        }
+
+        # ref exp
+        rule(:node_last_ref_exp) {
+          node_last_ref.as(:node_ref).as(:node_last_ref_exp)
+        }
+        rule(:node_current_ref_exp) {
+          node_current_ref.as(:node_ref).as(:node_current_ref_exp)
+        }
+        rule(:var_ref_exp) {
+          low_ident.as(:var_ref_exp)
+        }
+
+        # call exp
+        rule(:func_call_exp) {
+          whole = func_ref.as(:func_ref) >> ws_inline? >>
+          paren(listing0(exp, ws? >> str(',') >> ws?)).as(:args)
+          whole.as(:func_call_exp)
+        }
+        rule(:io_func_call_exp) {
+          whole = io_func_ref.as(:func_ref) >> ws_inline? >>
+          paren(listing0(exp, ws? >> str(',') >> ws?)).as(:args)
+          whole.as(:io_func_call_exp)
+        }
+        rule(:vc_call_exp_with_paren) {
+          whole = vconst_ref.as(:vconst_ref) >> ws_inline? >> str('(') >> ws? >>
+          listing0(exp, ws? >> str(',') >> ws?).as(:args) >> ws? >> str(')')
+          whole.as(:vc_call_exp_with_paren)
+        }
+        rule(:vc_call_exp_without_paren) {
+          vconst_ref.as(:vconst_ref).as(:vc_call_exp_without_paren)
+        }
+        rule(:tuple_exp) {
+          whole = str('(') >> ws? >>
+          listing2(exp, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(')')
+          whole.as(:tuple_exp)
+        }
+
+        # if exp
+        rule(:if_exp) {
+          whole = str('if') >> ws >> exp.as(:cond_exp) >> ws >> str('then') >>
+          ws >> exp.as(:then_exp) >> ws >> str('else') >> ws >>
+          exp.as(:else_exp)
+          whole.as(:if_exp)
+        }
+
+        # let exp
+        rule(:let_exp) {
+          whole = str('let') >> ws >> dynamic { |s, _|
+            indent = str("\s").repeat(s.line_and_column[1] - 1)
+            separator = (ws_inline? >> newline >> indent) | ws? >> str(';') >> ws?
+            listing(assign, separator).as(:assignments)
+          } >> ws >> str('in') >> ws >> exp.as(:in_exp)
+          whole.as(:let_exp)
+        }
+        rule(:assign) {
+          whole = pattern.as(:left_pattern) >> ws? >> str('=') >> ws? >>
+          (where_exp | exp).as(:right_exp)
+          whole.as(:assign)
+        }
+
+        # match exp
+        rule(:match_exp) {
+          whole = str('case') >> ws >> exp.as(:left_exp) >> ws >> str('of') >>
+          ws? >> dynamic { |s, _|
+            indent = str("\s").repeat(s.line_and_column[1] - 1)
+            separator = (ws_inline? >> newline >> indent) | ws? >> str(';') >> ws?
+            listing(match_case, separator).as(:cases)
+          }
+          whole.as(:match_exp)
+        }
+        rule(:match_case) {
+          (
+            pattern.as(:pattern) >> ws? >> str('->') >> ws? >> exp.as(:exp)
+          ).as(:match_case)
+        }
+
+        # unary op exp
+        rule(:unary_op_exp) {
+          (op_ref.as(:func_ref) >> ws? >> single_exp.as(:exp))
+          .as(:unary_op_exp)
+        }
+
+        # pattern
+        rule(:pattern) {
+          vc_pattern_with_paren | vc_pattern_without_paren |
+          tuple_pattern | any_pattern
+        }
+        rule(:vc_pattern_with_paren) {
+          whole = vconst_ref.as(:vconst_ref) >> ws_inline? >> str('(') >> ws? >>
+          listing0(pattern, ws? >> str(',') >> ws?).as(:args) >> ws? >>
+          str(')') >> (ws? >> as).maybe.as(:var_ref)
+          whole.as(:vc_pattern_with_paren)
+        }
+        rule(:vc_pattern_without_paren) {
+          whole = vconst_ref.as(:vconst_ref) >> (ws? >> as).maybe.as(:var_ref)
+          whole.as(:vc_pattern_without_paren)
+        }
+        rule(:tuple_pattern) {
+          whole = str('(') >> ws? >>
+          listing2(pattern, ws? >> str(',') >> ws?).as(:args) >>
+          ws? >> str(')') >> (ws? >> as).maybe.as(:var_ref)
+          whole.as(:tuple_pattern)
+        }
+        rule(:any_pattern) {
+          low_ident.as(:any_pattern)
+        }
+        rule(:as) {
+          (str('as') >> ws? >> low_ident.as(:str)).as(:as)
+        }
+
+        # reference
+        rule(:node_last_ref) {
+          qualifier >> str('@') >> (str('@') >> low_ident).as(:name)
+        }
+        rule(:node_current_ref) {
+          qualifier >> (str('@') >> low_ident).as(:name)
+        }
+        rule(:func_ref) {
+          qualifier >> low_ident.as(:name)
+        }
+        rule(:io_func_ref) {
+          qualifier >> (str('$') >> low_ident).as(:name)
+        }
+        rule(:op_ref) {
+          qualifier >> op_ident.as(:name)
+        }
+        rule(:bq_op_ref) {
+          str('`') >> qualifier >> low_ident.as(:name) >> str('`')
+        }
+        rule(:vconst_ref) {
+          qualifier >> (up_ident | num_ident).as(:name)
+        }
+        rule(:tconst_ref) {
+          qualifier >> up_ident.as(:name)
+        }
+        rule(:qualifier) {
+          (up_ident.as(:str) >> str('.')).maybe.as(:qualifier)
+        }
+
+        rule(:num_ident) {
+          match['0-9'] >> match['a-zA-Z0-9.'].repeat
+        }
+        rule(:op_ident) {
+          enabled_char = "!#%&*+/<=>?\\^|-~'.".chars.map { |c| str(c) }.reduce(&:|)
+          enabled_char.repeat(1).capture(:name) >> dynamic { |_, c|
+            disabled_strs = ["=", "."]
+            disabled_strs.include?(c.captures[:name].to_s) ? str('*') : str('')
+          }
+        }
+        rule(:low_ident) {
+          (match['a-z_'] >> match['a-zA-Z0-9_'].repeat).capture(:name) >>
+          dynamic { |_, c|
+            keywords = ['from']
+            keywords.include?(c.captures[:name].to_s) ? str('a') : str('')
+          }
+        }
+        rule(:up_ident) {
+          match['A-Z'] >> match['a-zA-Z0-9_'].repeat
+        }
+        rule(:ws) {
+          (str("\s") | line_feed).repeat(1)
+        }
+        rule(:ws?) {
+          ws.maybe
+        }
+        rule(:ws_inline) {
+          str("\s").repeat(1)
+        }
+        rule(:ws_inline?) {
+          ws_inline.maybe
+        }
+        rule(:newline) {
+          line_feed.repeat(1)
+        }
+        rule(:line_feed) {
+          (str('--') >> (str("\n").absent? >> any).repeat).maybe >> str("\n")
+        }
+        rule(:ws_inc_newline) {
+          ws_inline? >> newline >> ws?
+        }
+
+        def listing(e, separator)
+          (e.as(:e) >> (separator >> e.as(:e)).repeat).as(:listing)
+        end
+
+        def listing0(e, separator)
+          listing(e, separator).maybe.as(:listing0)
+        end
+
+        def listing2(e, separator)
+          (e.as(:e) >> (separator >> e.as(:e)).repeat(1)).as(:listing)
+        end
+
+        def opt(left_separator, optional_rule)
+          (left_separator >> optional_rule.as(:entity)).maybe.as(:opt)
+        end
+
+        def paren(rule)
+          wrap('(', rule, ')')
+        end
+
+        def wrap(lstr, rule, rstr)
+          str(lstr) >> ws? >> rule >> ws? >> str(rstr)
+        end
+      end
+    end
+  end
+end