module DhallishGrammar

Public Instance Methods

_nt_add_sub_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3862
def _nt_add_sub_expression
  start_index = index
  if node_cache[:add_sub_expression].has_key?(index)
    cached = node_cache[:add_sub_expression][index]
    if cached
      node_cache[:add_sub_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_mult_div_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6 = index
        if (match_len = has_terminal?("+", false, index))
          r7 = true
          @index += match_len
        else
          terminal_parse_failure('"+"')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          if (match_len = has_terminal?("-", false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('"-"')
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            @index = i6
            r6 = nil
          end
        end
        s3 << r6
        if r6
          r10 = _nt_space
          if r10
            r9 = r10
          else
            r9 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r9
          if r9
            r11 = _nt_mult_div_expression
            s3 << r11
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(AddSubExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AddSubExpression1)
    r0.extend(AddSubExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:add_sub_expression][start_index] = r0

  r0
end
_nt_and_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3577
def _nt_and_expression
  start_index = index
  if node_cache[:and_expression].has_key?(index)
    cached = node_cache[:and_expression][index]
    if cached
      node_cache[:and_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_comparison_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?("&&", false, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"&&"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_comparison_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(AndExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AndExpression1)
    r0.extend(AndExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:and_expression][start_index] = r0

  r0
end
_nt_annotated_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3241
def _nt_annotated_expression
  start_index = index
  if node_cache[:annotated_expression].has_key?(index)
    cached = node_cache[:annotated_expression][index]
    if cached
      node_cache[:annotated_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_function_type_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?(":", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('":"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_function_type_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(AnnotatedExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(AnnotatedExpression1)
    r0.extend(AnnotatedExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:annotated_expression][start_index] = r0

  r0
end
_nt_application_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 4506
def _nt_application_expression
  start_index = index
  if node_cache[:application_expression].has_key?(index)
    cached = node_cache[:application_expression][index]
    if cached
      node_cache[:application_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_proj_sel_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6, s6 = index, []
        i7 = index
        r8 = _nt_reserved
        if r8
          @index = i7
          r7 = nil
        else
          @index = i7
          r7 = instantiate_node(SyntaxNode,input, index...index)
        end
        s6 << r7
        if r7
          r9 = _nt_proj_sel_expression
          s6 << r9
        end
        if s6.last
          r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
          r6.extend(ApplicationExpression0)
        else
          @index = i6
          r6 = nil
        end
        s3 << r6
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(ApplicationExpression1)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ApplicationExpression2)
    r0.extend(ApplicationExpression3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:application_expression][start_index] = r0

  r0
end
_nt_bool_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 959
def _nt_bool_literal
  start_index = index
  if node_cache[:bool_literal].has_key?(index)
    cached = node_cache[:bool_literal][index]
    if cached
      node_cache[:bool_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?("True", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    r1.extend(BoolLiteral0)
    @index += match_len
  else
    terminal_parse_failure('"True"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("False", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      r2.extend(BoolLiteral1)
      @index += match_len
    else
      terminal_parse_failure('"False"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:bool_literal][start_index] = r0

  r0
end
_nt_comparison_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3683
def _nt_comparison_expression
  start_index = index
  if node_cache[:comparison_expression].has_key?(index)
    cached = node_cache[:comparison_expression][index]
    if cached
      node_cache[:comparison_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_add_sub_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6 = index
        if (match_len = has_terminal?("==", false, index))
          r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"=="')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          if (match_len = has_terminal?("!=", false, index))
            r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"!="')
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            if (match_len = has_terminal?("<=", false, index))
              r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"<="')
              r9 = nil
            end
            if r9
              r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
              r6 = r9
            else
              if (match_len = has_terminal?("<", false, index))
                r10 = true
                @index += match_len
              else
                terminal_parse_failure('"<"')
                r10 = nil
              end
              if r10
                r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                r6 = r10
              else
                if (match_len = has_terminal?(">=", false, index))
                  r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('">="')
                  r11 = nil
                end
                if r11
                  r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                  r6 = r11
                else
                  if (match_len = has_terminal?(">", false, index))
                    r12 = true
                    @index += match_len
                  else
                    terminal_parse_failure('">"')
                    r12 = nil
                  end
                  if r12
                    r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                    r6 = r12
                  else
                    @index = i6
                    r6 = nil
                  end
                end
              end
            end
          end
        end
        s3 << r6
        if r6
          r14 = _nt_space
          if r14
            r13 = r14
          else
            r13 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r13
          if r13
            r15 = _nt_add_sub_expression
            s3 << r15
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(ComparisonExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ComparisonExpression1)
    r0.extend(ComparisonExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:comparison_expression][start_index] = r0

  r0
end
_nt_double_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 758
def _nt_double_literal
  start_index = index
  if node_cache[:double_literal].has_key?(index)
    cached = node_cache[:double_literal][index]
    if cached
      node_cache[:double_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i2 = index
  if (match_len = has_terminal?("+", false, index))
    r3 = true
    @index += match_len
  else
    terminal_parse_failure('"+"')
    r3 = nil
  end
  if r3
    r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
    r2 = r3
  else
    if (match_len = has_terminal?("-", false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"-"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r2 = r4
    else
      @index = i2
      r2 = nil
    end
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    s5, i5 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
        r6 = true
        @index += 1
      else
        terminal_parse_failure('[0-9]')
        r6 = nil
      end
      if r6
        s5 << r6
      else
        break
      end
    end
    if s5.empty?
      @index = i5
      r5 = nil
    else
      r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
    end
    s0 << r5
    if r5
      i7 = index
      i8, s8 = index, []
      if (match_len = has_terminal?(".", false, index))
        r9 = true
        @index += match_len
      else
        terminal_parse_failure('"."')
        r9 = nil
      end
      s8 << r9
      if r9
        s10, i10 = [], index
        loop do
          if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
            r11 = true
            @index += 1
          else
            terminal_parse_failure('[0-9]')
            r11 = nil
          end
          if r11
            s10 << r11
          else
            break
          end
        end
        if s10.empty?
          @index = i10
          r10 = nil
        else
          r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
        end
        s8 << r10
        if r10
          r13 = _nt_exponent
          if r13
            r12 = r13
          else
            r12 = instantiate_node(SyntaxNode,input, index...index)
          end
          s8 << r12
        end
      end
      if s8.last
        r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
        r8.extend(DoubleLiteral0)
      else
        @index = i8
        r8 = nil
      end
      if r8
        r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
        r7 = r8
      else
        r14 = _nt_exponent
        if r14
          r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
          r7 = r14
        else
          @index = i7
          r7 = nil
        end
      end
      s0 << r7
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(DoubleLiteral1)
    r0.extend(DoubleLiteral2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:double_literal][start_index] = r0

  r0
end
_nt_empty_list_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 1021
def _nt_empty_list_literal
  start_index = index
  if node_cache[:empty_list_literal].has_key?(index)
    cached = node_cache[:empty_list_literal][index]
    if cached
      node_cache[:empty_list_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("[", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"["')
    r1 = nil
  end
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      if (match_len = has_terminal?("]", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('"]"')
        r4 = nil
      end
      s0 << r4
      if r4
        r6 = _nt_space
        if r6
          r5 = r6
        else
          r5 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r5
        if r5
          if (match_len = has_terminal?(":", false, index))
            r7 = true
            @index += match_len
          else
            terminal_parse_failure('":"')
            r7 = nil
          end
          s0 << r7
          if r7
            r9 = _nt_space
            if r9
              r8 = r9
            else
              r8 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r8
            if r8
              if (match_len = has_terminal?("List", false, index))
                r10 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"List"')
                r10 = nil
              end
              s0 << r10
              if r10
                r11 = _nt_space
                s0 << r11
                if r11
                  r12 = _nt_expression
                  s0 << r12
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EmptyListLiteral0)
    r0.extend(EmptyListLiteral1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:empty_list_literal][start_index] = r0

  r0
end
_nt_empty_union_type_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2828
def _nt_empty_union_type_literal
  start_index = index
  if node_cache[:empty_union_type_literal].has_key?(index)
    cached = node_cache[:empty_union_type_literal][index]
    if cached
      node_cache[:empty_union_type_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("<", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"<"')
    r1 = nil
  end
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      if (match_len = has_terminal?(">", false, index))
        r4 = true
        @index += match_len
      else
        terminal_parse_failure('">"')
        r4 = nil
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(EmptyUnionTypeLiteral0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:empty_union_type_literal][start_index] = r0

  r0
end
_nt_eol() click to toggle source
# File lib/DhallishGrammar.rb, line 173
def _nt_eol
  start_index = index
  if node_cache[:eol].has_key?(index)
    cached = node_cache[:eol][index]
    if cached
      node_cache[:eol][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("\r", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"\\r"')
    r2 = nil
  end
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?("\n", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"\\n"')
      r3 = nil
    end
    s0 << r3
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Eol0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:eol][start_index] = r0

  r0
end
_nt_exponent() click to toggle source
# File lib/DhallishGrammar.rb, line 656
def _nt_exponent
  start_index = index
  if node_cache[:exponent].has_key?(index)
    cached = node_cache[:exponent][index]
    if cached
      node_cache[:exponent][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("e", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"e"')
    r1 = nil
  end
  s0 << r1
  if r1
    i3 = index
    if (match_len = has_terminal?("+", false, index))
      r4 = true
      @index += match_len
    else
      terminal_parse_failure('"+"')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r3 = r4
    else
      if (match_len = has_terminal?("-", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"-"')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r3 = r5
      else
        @index = i3
        r3 = nil
      end
    end
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      s6, i6 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
          r7 = true
          @index += 1
        else
          terminal_parse_failure('[0-9]')
          r7 = nil
        end
        if r7
          s6 << r7
        else
          break
        end
      end
      if s6.empty?
        @index = i6
        r6 = nil
      else
        r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      end
      s0 << r6
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Exponent0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:exponent][start_index] = r0

  r0
end
_nt_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 102
def _nt_expression
  start_index = index
  if node_cache[:expression].has_key?(index)
    cached = node_cache[:expression][index]
    if cached
      node_cache[:expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_if_then_else_expression
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Expression0)
    r1.extend(Expression1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_let_expression
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(Expression2)
      r3.extend(Expression3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      i5, s5 = index, []
      r6 = _nt_import_alternative_expression
      s5 << r6
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(Expression4)
        r5.extend(Expression5)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r0 = r5
      else
        @index = i0
        r0 = nil
      end
    end
  end

  node_cache[:expression][start_index] = r0

  r0
end
_nt_forall_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2321
def _nt_forall_literal
  start_index = index
  if node_cache[:forall_literal].has_key?(index)
    cached = node_cache[:forall_literal][index]
    if cached
      node_cache[:forall_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("forall", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"forall"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("∀", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"∀"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    r5 = _nt_space
    if r5
      r4 = r5
    else
      r4 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r4
    if r4
      if (match_len = has_terminal?("(", false, index))
        r6 = true
        @index += match_len
      else
        terminal_parse_failure('"("')
        r6 = nil
      end
      s0 << r6
      if r6
        r8 = _nt_space
        if r8
          r7 = r8
        else
          r7 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r7
        if r7
          r9 = _nt_label
          s0 << r9
          if r9
            r11 = _nt_space
            if r11
              r10 = r11
            else
              r10 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r10
            if r10
              if (match_len = has_terminal?(":", false, index))
                r12 = true
                @index += match_len
              else
                terminal_parse_failure('":"')
                r12 = nil
              end
              s0 << r12
              if r12
                r14 = _nt_space
                if r14
                  r13 = r14
                else
                  r13 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r13
                if r13
                  r15 = _nt_expression
                  s0 << r15
                  if r15
                    r17 = _nt_space
                    if r17
                      r16 = r17
                    else
                      r16 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r16
                    if r16
                      if (match_len = has_terminal?(")", false, index))
                        r18 = true
                        @index += match_len
                      else
                        terminal_parse_failure('")"')
                        r18 = nil
                      end
                      s0 << r18
                      if r18
                        r20 = _nt_space
                        if r20
                          r19 = r20
                        else
                          r19 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s0 << r19
                        if r19
                          i21 = index
                          if (match_len = has_terminal?("->", false, index))
                            r22 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"->"')
                            r22 = nil
                          end
                          if r22
                            r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
                            r21 = r22
                          else
                            if (match_len = has_terminal?("→", false, index))
                              r23 = true
                              @index += match_len
                            else
                              terminal_parse_failure('"→"')
                              r23 = nil
                            end
                            if r23
                              r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
                              r21 = r23
                            else
                              @index = i21
                              r21 = nil
                            end
                          end
                          s0 << r21
                          if r21
                            r25 = _nt_space
                            if r25
                              r24 = r25
                            else
                              r24 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s0 << r24
                            if r24
                              r26 = _nt_expression
                              s0 << r26
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ForallLiteral0)
    r0.extend(ForallLiteral1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:forall_literal][start_index] = r0

  r0
end
_nt_forbidden_label() click to toggle source
# File lib/DhallishGrammar.rb, line 6292
def _nt_forbidden_label
  start_index = index
  if node_cache[:forbidden_label].has_key?(index)
    cached = node_cache[:forbidden_label][index]
    if cached
      node_cache[:forbidden_label][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_reserved
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("Text", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"Text"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("Bool", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"Bool"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("Optional", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"Optional"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?("None", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"None"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?("Some", false, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"Some"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              if (match_len = has_terminal?("True", false, index))
                r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                @index += match_len
              else
                terminal_parse_failure('"True"')
                r7 = nil
              end
              if r7
                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                r0 = r7
              else
                if (match_len = has_terminal?("False", false, index))
                  r8 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"False"')
                  r8 = nil
                end
                if r8
                  r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
                  r0 = r8
                else
                  if (match_len = has_terminal?("Type", false, index))
                    r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"Type"')
                    r9 = nil
                  end
                  if r9
                    r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                    r0 = r9
                  else
                    i10, s10 = index, []
                    if (match_len = has_terminal?("Natural", false, index))
                      r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"Natural"')
                      r11 = nil
                    end
                    s10 << r11
                    if r11
                      i13, s13 = index, []
                      if (match_len = has_terminal?("/", false, index))
                        r14 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"/"')
                        r14 = nil
                      end
                      s13 << r14
                      if r14
                        i15 = index
                        if (match_len = has_terminal?("show", false, index))
                          r16 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"show"')
                          r16 = nil
                        end
                        if r16
                          r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
                          r15 = r16
                        else
                          if (match_len = has_terminal?("toInteger", false, index))
                            r17 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"toInteger"')
                            r17 = nil
                          end
                          if r17
                            r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
                            r15 = r17
                          else
                            if (match_len = has_terminal?("toDouble", false, index))
                              r18 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"toDouble"')
                              r18 = nil
                            end
                            if r18
                              r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
                              r15 = r18
                            else
                              @index = i15
                              r15 = nil
                            end
                          end
                        end
                        s13 << r15
                      end
                      if s13.last
                        r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
                        r13.extend(ForbiddenLabel0)
                      else
                        @index = i13
                        r13 = nil
                      end
                      if r13
                        r12 = r13
                      else
                        r12 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s10 << r12
                    end
                    if s10.last
                      r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
                      r10.extend(ForbiddenLabel1)
                    else
                      @index = i10
                      r10 = nil
                    end
                    if r10
                      r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                      r0 = r10
                    else
                      i19, s19 = index, []
                      if (match_len = has_terminal?("Integer", false, index))
                        r20 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                        @index += match_len
                      else
                        terminal_parse_failure('"Integer"')
                        r20 = nil
                      end
                      s19 << r20
                      if r20
                        i22, s22 = index, []
                        if (match_len = has_terminal?("/", false, index))
                          r23 = true
                          @index += match_len
                        else
                          terminal_parse_failure('"/"')
                          r23 = nil
                        end
                        s22 << r23
                        if r23
                          i24 = index
                          if (match_len = has_terminal?("show", false, index))
                            r25 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"show"')
                            r25 = nil
                          end
                          if r25
                            r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
                            r24 = r25
                          else
                            if (match_len = has_terminal?("toNatural", false, index))
                              r26 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"toNatural"')
                              r26 = nil
                            end
                            if r26
                              r26 = SyntaxNode.new(input, (index-1)...index) if r26 == true
                              r24 = r26
                            else
                              if (match_len = has_terminal?("toDouble", false, index))
                                r27 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"toDouble"')
                                r27 = nil
                              end
                              if r27
                                r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
                                r24 = r27
                              else
                                @index = i24
                                r24 = nil
                              end
                            end
                          end
                          s22 << r24
                        end
                        if s22.last
                          r22 = instantiate_node(SyntaxNode,input, i22...index, s22)
                          r22.extend(ForbiddenLabel2)
                        else
                          @index = i22
                          r22 = nil
                        end
                        if r22
                          r21 = r22
                        else
                          r21 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s19 << r21
                      end
                      if s19.last
                        r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
                        r19.extend(ForbiddenLabel3)
                      else
                        @index = i19
                        r19 = nil
                      end
                      if r19
                        r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
                        r0 = r19
                      else
                        i28, s28 = index, []
                        if (match_len = has_terminal?("Double", false, index))
                          r29 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                          @index += match_len
                        else
                          terminal_parse_failure('"Double"')
                          r29 = nil
                        end
                        s28 << r29
                        if r29
                          i31, s31 = index, []
                          if (match_len = has_terminal?("/", false, index))
                            r32 = true
                            @index += match_len
                          else
                            terminal_parse_failure('"/"')
                            r32 = nil
                          end
                          s31 << r32
                          if r32
                            i33 = index
                            if (match_len = has_terminal?("show", false, index))
                              r34 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"show"')
                              r34 = nil
                            end
                            if r34
                              r34 = SyntaxNode.new(input, (index-1)...index) if r34 == true
                              r33 = r34
                            else
                              if (match_len = has_terminal?("toNatural", false, index))
                                r35 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"toNatural"')
                                r35 = nil
                              end
                              if r35
                                r35 = SyntaxNode.new(input, (index-1)...index) if r35 == true
                                r33 = r35
                              else
                                if (match_len = has_terminal?("toInteger", false, index))
                                  r36 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"toInteger"')
                                  r36 = nil
                                end
                                if r36
                                  r36 = SyntaxNode.new(input, (index-1)...index) if r36 == true
                                  r33 = r36
                                else
                                  @index = i33
                                  r33 = nil
                                end
                              end
                            end
                            s31 << r33
                          end
                          if s31.last
                            r31 = instantiate_node(SyntaxNode,input, i31...index, s31)
                            r31.extend(ForbiddenLabel4)
                          else
                            @index = i31
                            r31 = nil
                          end
                          if r31
                            r30 = r31
                          else
                            r30 = instantiate_node(SyntaxNode,input, index...index)
                          end
                          s28 << r30
                        end
                        if s28.last
                          r28 = instantiate_node(SyntaxNode,input, i28...index, s28)
                          r28.extend(ForbiddenLabel5)
                        else
                          @index = i28
                          r28 = nil
                        end
                        if r28
                          r28 = SyntaxNode.new(input, (index-1)...index) if r28 == true
                          r0 = r28
                        else
                          i37, s37 = index, []
                          if (match_len = has_terminal?("List", false, index))
                            r38 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"List"')
                            r38 = nil
                          end
                          s37 << r38
                          if r38
                            i40, s40 = index, []
                            if (match_len = has_terminal?("/", false, index))
                              r41 = true
                              @index += match_len
                            else
                              terminal_parse_failure('"/"')
                              r41 = nil
                            end
                            s40 << r41
                            if r41
                              i42 = index
                              if (match_len = has_terminal?("length", false, index))
                                r43 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                @index += match_len
                              else
                                terminal_parse_failure('"length"')
                                r43 = nil
                              end
                              if r43
                                r43 = SyntaxNode.new(input, (index-1)...index) if r43 == true
                                r42 = r43
                              else
                                if (match_len = has_terminal?("reduce", false, index))
                                  r44 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"reduce"')
                                  r44 = nil
                                end
                                if r44
                                  r44 = SyntaxNode.new(input, (index-1)...index) if r44 == true
                                  r42 = r44
                                else
                                  if (match_len = has_terminal?("head", false, index))
                                    r45 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                    @index += match_len
                                  else
                                    terminal_parse_failure('"head"')
                                    r45 = nil
                                  end
                                  if r45
                                    r45 = SyntaxNode.new(input, (index-1)...index) if r45 == true
                                    r42 = r45
                                  else
                                    if (match_len = has_terminal?("tail", false, index))
                                      r46 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                      @index += match_len
                                    else
                                      terminal_parse_failure('"tail"')
                                      r46 = nil
                                    end
                                    if r46
                                      r46 = SyntaxNode.new(input, (index-1)...index) if r46 == true
                                      r42 = r46
                                    else
                                      @index = i42
                                      r42 = nil
                                    end
                                  end
                                end
                              end
                              s40 << r42
                            end
                            if s40.last
                              r40 = instantiate_node(SyntaxNode,input, i40...index, s40)
                              r40.extend(ForbiddenLabel6)
                            else
                              @index = i40
                              r40 = nil
                            end
                            if r40
                              r39 = r40
                            else
                              r39 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s37 << r39
                          end
                          if s37.last
                            r37 = instantiate_node(SyntaxNode,input, i37...index, s37)
                            r37.extend(ForbiddenLabel7)
                          else
                            @index = i37
                            r37 = nil
                          end
                          if r37
                            r37 = SyntaxNode.new(input, (index-1)...index) if r37 == true
                            r0 = r37
                          else
                            i47, s47 = index, []
                            if (match_len = has_terminal?("Optional", false, index))
                              r48 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                              @index += match_len
                            else
                              terminal_parse_failure('"Optional"')
                              r48 = nil
                            end
                            s47 << r48
                            if r48
                              i50, s50 = index, []
                              if (match_len = has_terminal?("/", false, index))
                                r51 = true
                                @index += match_len
                              else
                                terminal_parse_failure('"/"')
                                r51 = nil
                              end
                              s50 << r51
                              if r51
                                if (match_len = has_terminal?("fold", false, index))
                                  r52 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                  @index += match_len
                                else
                                  terminal_parse_failure('"fold"')
                                  r52 = nil
                                end
                                s50 << r52
                              end
                              if s50.last
                                r50 = instantiate_node(SyntaxNode,input, i50...index, s50)
                                r50.extend(ForbiddenLabel8)
                              else
                                @index = i50
                                r50 = nil
                              end
                              if r50
                                r49 = r50
                              else
                                r49 = instantiate_node(SyntaxNode,input, index...index)
                              end
                              s47 << r49
                            end
                            if s47.last
                              r47 = instantiate_node(SyntaxNode,input, i47...index, s47)
                              r47.extend(ForbiddenLabel9)
                            else
                              @index = i47
                              r47 = nil
                            end
                            if r47
                              r47 = SyntaxNode.new(input, (index-1)...index) if r47 == true
                              r0 = r47
                            else
                              @index = i0
                              r0 = nil
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end

  node_cache[:forbidden_label][start_index] = r0

  r0
end
_nt_function_definition() click to toggle source
# File lib/DhallishGrammar.rb, line 6073
def _nt_function_definition
  start_index = index
  if node_cache[:function_definition].has_key?(index)
    cached = node_cache[:function_definition][index]
    if cached
      node_cache[:function_definition][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("\\", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"\\\\"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("λ", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"λ"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    r5 = _nt_space
    if r5
      r4 = r5
    else
      r4 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r4
    if r4
      if (match_len = has_terminal?("(", false, index))
        r6 = true
        @index += match_len
      else
        terminal_parse_failure('"("')
        r6 = nil
      end
      s0 << r6
      if r6
        r8 = _nt_space
        if r8
          r7 = r8
        else
          r7 = instantiate_node(SyntaxNode,input, index...index)
        end
        s0 << r7
        if r7
          r9 = _nt_label
          s0 << r9
          if r9
            r11 = _nt_space
            if r11
              r10 = r11
            else
              r10 = instantiate_node(SyntaxNode,input, index...index)
            end
            s0 << r10
            if r10
              if (match_len = has_terminal?(":", false, index))
                r12 = true
                @index += match_len
              else
                terminal_parse_failure('":"')
                r12 = nil
              end
              s0 << r12
              if r12
                r14 = _nt_space
                if r14
                  r13 = r14
                else
                  r13 = instantiate_node(SyntaxNode,input, index...index)
                end
                s0 << r13
                if r13
                  r15 = _nt_expression
                  s0 << r15
                  if r15
                    r17 = _nt_space
                    if r17
                      r16 = r17
                    else
                      r16 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r16
                    if r16
                      if (match_len = has_terminal?(")", false, index))
                        r18 = true
                        @index += match_len
                      else
                        terminal_parse_failure('")"')
                        r18 = nil
                      end
                      s0 << r18
                      if r18
                        r20 = _nt_space
                        if r20
                          r19 = r20
                        else
                          r19 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s0 << r19
                        if r19
                          i21 = index
                          if (match_len = has_terminal?("->", false, index))
                            r22 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                            @index += match_len
                          else
                            terminal_parse_failure('"->"')
                            r22 = nil
                          end
                          if r22
                            r22 = SyntaxNode.new(input, (index-1)...index) if r22 == true
                            r21 = r22
                          else
                            if (match_len = has_terminal?("→", false, index))
                              r23 = true
                              @index += match_len
                            else
                              terminal_parse_failure('"→"')
                              r23 = nil
                            end
                            if r23
                              r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
                              r21 = r23
                            else
                              @index = i21
                              r21 = nil
                            end
                          end
                          s0 << r21
                          if r21
                            r25 = _nt_space
                            if r25
                              r24 = r25
                            else
                              r24 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s0 << r24
                            if r24
                              r26 = _nt_expression
                              s0 << r26
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FunctionDefinition0)
    r0.extend(FunctionDefinition1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:function_definition][start_index] = r0

  r0
end
_nt_function_type_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3353
def _nt_function_type_expression
  start_index = index
  if node_cache[:function_type_expression].has_key?(index)
    cached = node_cache[:function_type_expression][index]
    if cached
      node_cache[:function_type_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_or_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6 = index
        if (match_len = has_terminal?("->", false, index))
          r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"->"')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          if (match_len = has_terminal?("→", false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('"→"')
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            @index = i6
            r6 = nil
          end
        end
        s3 << r6
        if r6
          r10 = _nt_space
          if r10
            r9 = r10
          else
            r9 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r9
          if r9
            r11 = _nt_or_expression
            s3 << r11
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(FunctionTypeExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(FunctionTypeExpression1)
    r0.extend(FunctionTypeExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:function_type_expression][start_index] = r0

  r0
end
_nt_if_then_else_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 5466
def _nt_if_then_else_expression
  start_index = index
  if node_cache[:if_then_else_expression].has_key?(index)
    cached = node_cache[:if_then_else_expression][index]
    if cached
      node_cache[:if_then_else_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("if", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"if"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_space
    s0 << r2
    if r2
      r3 = _nt_expression
      s0 << r3
      if r3
        r4 = _nt_space
        s0 << r4
        if r4
          if (match_len = has_terminal?("then", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"then"')
            r5 = nil
          end
          s0 << r5
          if r5
            r6 = _nt_space
            s0 << r6
            if r6
              r7 = _nt_expression
              s0 << r7
              if r7
                r8 = _nt_space
                s0 << r8
                if r8
                  if (match_len = has_terminal?("else", false, index))
                    r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                    @index += match_len
                  else
                    terminal_parse_failure('"else"')
                    r9 = nil
                  end
                  s0 << r9
                  if r9
                    r10 = _nt_space
                    s0 << r10
                    if r10
                      r11 = _nt_expression
                      s0 << r11
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IfThenElseExpression0)
    r0.extend(IfThenElseExpression1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:if_then_else_expression][start_index] = r0

  r0
end
_nt_import_alternative_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3139
def _nt_import_alternative_expression
  start_index = index
  if node_cache[:import_alternative_expression].has_key?(index)
    cached = node_cache[:import_alternative_expression][index]
    if cached
      node_cache[:import_alternative_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_annotated_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?("?", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"?"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_annotated_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(ImportAlternativeExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ImportAlternativeExpression1)
    r0.extend(ImportAlternativeExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:import_alternative_expression][start_index] = r0

  r0
end
_nt_import_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 6968
def _nt_import_expression
  start_index = index
  if node_cache[:import_expression].has_key?(index)
    cached = node_cache[:import_expression][index]
    if cached
      node_cache[:import_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("../", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"../"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("./", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"./"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      if (match_len = has_terminal?("~/", false, index))
        r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"~/"')
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r1 = r4
      else
        if (match_len = has_terminal?("env:", false, index))
          r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"env:"')
          r5 = nil
        end
        if r5
          r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
          r1 = r5
        else
          if (match_len = has_terminal?("http:", false, index))
            r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"http:"')
            r6 = nil
          end
          if r6
            r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
            r1 = r6
          else
            if (match_len = has_terminal?("https:", false, index))
              r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"https:"')
              r7 = nil
            end
            if r7
              r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
              r1 = r7
            else
              @index = i1
              r1 = nil
            end
          end
        end
      end
    end
  end
  s0 << r1
  if r1
    r8 = _nt_import_source
    s0 << r8
    if r8
      i10, s10 = index, []
      r11 = _nt_space
      s10 << r11
      if r11
        if (match_len = has_terminal?("as", false, index))
          r12 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"as"')
          r12 = nil
        end
        s10 << r12
        if r12
          r13 = _nt_space
          s10 << r13
          if r13
            if (match_len = has_terminal?("Text", false, index))
              r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"Text"')
              r14 = nil
            end
            s10 << r14
          end
        end
      end
      if s10.last
        r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
        r10.extend(ImportExpression0)
      else
        @index = i10
        r10 = nil
      end
      if r10
        r9 = r10
      else
        r9 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r9
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ImportExpression1)
    r0.extend(ImportExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:import_expression][start_index] = r0

  r0
end
_nt_import_source() click to toggle source
# File lib/DhallishGrammar.rb, line 7119
def _nt_import_source
  start_index = index
  if node_cache[:import_source].has_key?(index)
    cached = node_cache[:import_source][index]
    if cached
      node_cache[:import_source][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1, s1 = index, []
    i2 = index
    i3 = index
    if has_terminal?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r4 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r3 = r4
    else
      if (match_len = has_terminal?("\\", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"\\\\"')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r3 = r5
      else
        if (match_len = has_terminal?("<", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"<"')
          r6 = nil
        end
        if r6
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          r3 = r6
        else
          if (match_len = has_terminal?(">", false, index))
            r7 = true
            @index += match_len
          else
            terminal_parse_failure('">"')
            r7 = nil
          end
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r3 = r7
          else
            if (match_len = has_terminal?("?", false, index))
              r8 = true
              @index += match_len
            else
              terminal_parse_failure('"?"')
              r8 = nil
            end
            if r8
              r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
              r3 = r8
            else
              if (match_len = has_terminal?(",", false, index))
                r9 = true
                @index += match_len
              else
                terminal_parse_failure('","')
                r9 = nil
              end
              if r9
                r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
                r3 = r9
              else
                if (match_len = has_terminal?("[", false, index))
                  r10 = true
                  @index += match_len
                else
                  terminal_parse_failure('"["')
                  r10 = nil
                end
                if r10
                  r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                  r3 = r10
                else
                  if (match_len = has_terminal?("]", false, index))
                    r11 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"]"')
                    r11 = nil
                  end
                  if r11
                    r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                    r3 = r11
                  else
                    if (match_len = has_terminal?("{", false, index))
                      r12 = true
                      @index += match_len
                    else
                      terminal_parse_failure('"{"')
                      r12 = nil
                    end
                    if r12
                      r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                      r3 = r12
                    else
                      if (match_len = has_terminal?("}", false, index))
                        r13 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"}"')
                        r13 = nil
                      end
                      if r13
                        r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
                        r3 = r13
                      else
                        if (match_len = has_terminal?("#", false, index))
                          r14 = true
                          @index += match_len
                        else
                          terminal_parse_failure('"#"')
                          r14 = nil
                        end
                        if r14
                          r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
                          r3 = r14
                        else
                          if (match_len = has_terminal?("(", false, index))
                            r15 = true
                            @index += match_len
                          else
                            terminal_parse_failure('"("')
                            r15 = nil
                          end
                          if r15
                            r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                            r3 = r15
                          else
                            if (match_len = has_terminal?(")", false, index))
                              r16 = true
                              @index += match_len
                            else
                              terminal_parse_failure('")"')
                              r16 = nil
                            end
                            if r16
                              r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
                              r3 = r16
                            else
                              @index = i3
                              r3 = nil
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if r3
      @index = i2
      r2 = nil
      terminal_parse_failure("(any alternative)", true)
    else
      @terminal_failures.pop
      @index = i2
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << r2
    if r2
      if index < input_length
        r17 = true
        @index += 1
      else
        terminal_parse_failure("any character")
        r17 = nil
      end
      s1 << r17
    end
    if s1.last
      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
      r1.extend(ImportSource0)
    else
      @index = i1
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  r0 = instantiate_node(SyntaxNode,input, i0...index, s0)

  node_cache[:import_source][start_index] = r0

  r0
end
_nt_integer_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 575
def _nt_integer_literal
  start_index = index
  if node_cache[:integer_literal].has_key?(index)
    cached = node_cache[:integer_literal][index]
    if cached
      node_cache[:integer_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("+", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"+"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("-", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"-"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    s4, i4 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
        r5 = true
        @index += 1
      else
        terminal_parse_failure('[0-9]')
        r5 = nil
      end
      if r5
        s4 << r5
      else
        break
      end
    end
    if s4.empty?
      @index = i4
      r4 = nil
    else
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
    end
    s0 << r4
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(IntegerLiteral0)
    r0.extend(IntegerLiteral1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:integer_literal][start_index] = r0

  r0
end
_nt_key_list() click to toggle source
# File lib/DhallishGrammar.rb, line 4619
def _nt_key_list
  start_index = index
  if node_cache[:key_list].has_key?(index)
    cached = node_cache[:key_list][index]
    if cached
      node_cache[:key_list][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?("{", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"{"')
    r2 = nil
  end
  s1 << r2
  if r2
    r4 = _nt_space
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << r3
    if r3
      if (match_len = has_terminal?("}", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"}"')
        r5 = nil
      end
      s1 << r5
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(KeyList0)
    r1.extend(KeyList1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i6, s6 = index, []
    if (match_len = has_terminal?("{", false, index))
      r7 = true
      @index += match_len
    else
      terminal_parse_failure('"{"')
      r7 = nil
    end
    s6 << r7
    if r7
      r9 = _nt_space
      if r9
        r8 = r9
      else
        r8 = instantiate_node(SyntaxNode,input, index...index)
      end
      s6 << r8
      if r8
        r10 = _nt_label
        s6 << r10
        if r10
          s11, i11 = [], index
          loop do
            i12, s12 = index, []
            r14 = _nt_space
            if r14
              r13 = r14
            else
              r13 = instantiate_node(SyntaxNode,input, index...index)
            end
            s12 << r13
            if r13
              if (match_len = has_terminal?(",", false, index))
                r15 = true
                @index += match_len
              else
                terminal_parse_failure('","')
                r15 = nil
              end
              s12 << r15
              if r15
                r17 = _nt_space
                if r17
                  r16 = r17
                else
                  r16 = instantiate_node(SyntaxNode,input, index...index)
                end
                s12 << r16
                if r16
                  r18 = _nt_label
                  s12 << r18
                end
              end
            end
            if s12.last
              r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
              r12.extend(KeyList2)
            else
              @index = i12
              r12 = nil
            end
            if r12
              s11 << r12
            else
              break
            end
          end
          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
          s6 << r11
          if r11
            r20 = _nt_space
            if r20
              r19 = r20
            else
              r19 = instantiate_node(SyntaxNode,input, index...index)
            end
            s6 << r19
            if r19
              if (match_len = has_terminal?("}", false, index))
                r21 = true
                @index += match_len
              else
                terminal_parse_failure('"}"')
                r21 = nil
              end
              s6 << r21
            end
          end
        end
      end
    end
    if s6.last
      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      r6.extend(KeyList3)
      r6.extend(KeyList4)
    else
      @index = i6
      r6 = nil
    end
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:key_list][start_index] = r0

  r0
end
_nt_label() click to toggle source
# File lib/DhallishGrammar.rb, line 5570
def _nt_label
  start_index = index
  if node_cache[:label].has_key?(index)
    cached = node_cache[:label][index]
    if cached
      node_cache[:label][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  i2 = index
  if (match_len = has_terminal?("_", false, index))
    r3 = true
    @index += match_len
  else
    terminal_parse_failure('"_"')
    r3 = nil
  end
  if r3
    r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
    r2 = r3
  else
    if has_terminal?(@regexps[gr = '\A[a-zA-Z]'] ||= Regexp.new(gr), :regexp, index)
      r4 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z]')
      r4 = nil
    end
    if r4
      r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
      r2 = r4
    else
      @index = i2
      r2 = nil
    end
  end
  s1 << r2
  if r2
    s5, i5 = [], index
    loop do
      i6 = index
      if (match_len = has_terminal?("_", false, index))
        r7 = true
        @index += match_len
      else
        terminal_parse_failure('"_"')
        r7 = nil
      end
      if r7
        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
        r6 = r7
      else
        if (match_len = has_terminal?("-", false, index))
          r8 = true
          @index += match_len
        else
          terminal_parse_failure('"-"')
          r8 = nil
        end
        if r8
          r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
          r6 = r8
        else
          if (match_len = has_terminal?("/", false, index))
            r9 = true
            @index += match_len
          else
            terminal_parse_failure('"/"')
            r9 = nil
          end
          if r9
            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
            r6 = r9
          else
            if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9]'] ||= Regexp.new(gr), :regexp, index)
              r10 = true
              @index += 1
            else
              terminal_parse_failure('[a-zA-Z0-9]')
              r10 = nil
            end
            if r10
              r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
              r6 = r10
            else
              @index = i6
              r6 = nil
            end
          end
        end
      end
      if r6
        s5 << r6
      else
        break
      end
    end
    r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
    s1 << r5
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(Label0)
    r1.extend(Label1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i11, s11 = index, []
    if (match_len = has_terminal?("`", false, index))
      r12 = true
      @index += match_len
    else
      terminal_parse_failure('"`"')
      r12 = nil
    end
    s11 << r12
    if r12
      s13, i13 = [], index
      loop do
        i14 = index
        if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9]'] ||= Regexp.new(gr), :regexp, index)
          r15 = true
          @index += 1
        else
          terminal_parse_failure('[a-zA-Z0-9]')
          r15 = nil
        end
        if r15
          r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
          r14 = r15
        else
          if (match_len = has_terminal?("-", false, index))
            r16 = true
            @index += match_len
          else
            terminal_parse_failure('"-"')
            r16 = nil
          end
          if r16
            r16 = SyntaxNode.new(input, (index-1)...index) if r16 == true
            r14 = r16
          else
            if (match_len = has_terminal?("/", false, index))
              r17 = true
              @index += match_len
            else
              terminal_parse_failure('"/"')
              r17 = nil
            end
            if r17
              r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
              r14 = r17
            else
              if (match_len = has_terminal?("_", false, index))
                r18 = true
                @index += match_len
              else
                terminal_parse_failure('"_"')
                r18 = nil
              end
              if r18
                r18 = SyntaxNode.new(input, (index-1)...index) if r18 == true
                r14 = r18
              else
                if (match_len = has_terminal?(":", false, index))
                  r19 = true
                  @index += match_len
                else
                  terminal_parse_failure('":"')
                  r19 = nil
                end
                if r19
                  r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
                  r14 = r19
                else
                  if (match_len = has_terminal?(".", false, index))
                    r20 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"."')
                    r20 = nil
                  end
                  if r20
                    r20 = SyntaxNode.new(input, (index-1)...index) if r20 == true
                    r14 = r20
                  else
                    if (match_len = has_terminal?("$", false, index))
                      r21 = true
                      @index += match_len
                    else
                      terminal_parse_failure('"$"')
                      r21 = nil
                    end
                    if r21
                      r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
                      r14 = r21
                    else
                      @index = i14
                      r14 = nil
                    end
                  end
                end
              end
            end
          end
        end
        if r14
          s13 << r14
        else
          break
        end
      end
      if s13.empty?
        @index = i13
        r13 = nil
      else
        r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
      end
      s11 << r13
      if r13
        if (match_len = has_terminal?("`", false, index))
          r22 = true
          @index += match_len
        else
          terminal_parse_failure('"`"')
          r22 = nil
        end
        s11 << r22
      end
    end
    if s11.last
      r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
      r11.extend(Label2)
      r11.extend(Label3)
    else
      @index = i11
      r11 = nil
    end
    if r11
      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
      r0 = r11
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:label][start_index] = r0

  r0
end
_nt_let_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 5888
def _nt_let_expression
  start_index = index
  if node_cache[:let_expression].has_key?(index)
    cached = node_cache[:let_expression][index]
    if cached
      node_cache[:let_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  s1, i1 = [], index
  loop do
    i2, s2 = index, []
    if (match_len = has_terminal?("let", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"let"')
      r3 = nil
    end
    s2 << r3
    if r3
      r4 = _nt_space
      s2 << r4
      if r4
        r5 = _nt_label
        s2 << r5
        if r5
          r7 = _nt_space
          if r7
            r6 = r7
          else
            r6 = instantiate_node(SyntaxNode,input, index...index)
          end
          s2 << r6
          if r6
            i9, s9 = index, []
            if (match_len = has_terminal?(":", false, index))
              r10 = true
              @index += match_len
            else
              terminal_parse_failure('":"')
              r10 = nil
            end
            s9 << r10
            if r10
              r12 = _nt_space
              if r12
                r11 = r12
              else
                r11 = instantiate_node(SyntaxNode,input, index...index)
              end
              s9 << r11
              if r11
                r13 = _nt_expression
                s9 << r13
                if r13
                  r15 = _nt_space
                  if r15
                    r14 = r15
                  else
                    r14 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s9 << r14
                end
              end
            end
            if s9.last
              r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
              r9.extend(LetExpression0)
            else
              @index = i9
              r9 = nil
            end
            if r9
              r8 = r9
            else
              r8 = instantiate_node(SyntaxNode,input, index...index)
            end
            s2 << r8
            if r8
              if (match_len = has_terminal?("=", false, index))
                r16 = true
                @index += match_len
              else
                terminal_parse_failure('"="')
                r16 = nil
              end
              s2 << r16
              if r16
                r18 = _nt_space
                if r18
                  r17 = r18
                else
                  r17 = instantiate_node(SyntaxNode,input, index...index)
                end
                s2 << r17
                if r17
                  r19 = _nt_expression
                  s2 << r19
                  if r19
                    r20 = _nt_space
                    s2 << r20
                  end
                end
              end
            end
          end
        end
      end
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(LetExpression1)
    else
      @index = i2
      r2 = nil
    end
    if r2
      s1 << r2
    else
      break
    end
  end
  if s1.empty?
    @index = i1
    r1 = nil
  else
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  end
  s0 << r1
  if r1
    if (match_len = has_terminal?("in", false, index))
      r21 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"in"')
      r21 = nil
    end
    s0 << r21
    if r21
      r22 = _nt_space
      s0 << r22
      if r22
        r23 = _nt_expression
        s0 << r23
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(LetExpression2)
    r0.extend(LetExpression3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:let_expression][start_index] = r0

  r0
end
_nt_list_concat_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 4116
def _nt_list_concat_expression
  start_index = index
  if node_cache[:list_concat_expression].has_key?(index)
    cached = node_cache[:list_concat_expression][index]
    if cached
      node_cache[:list_concat_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_text_append_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?("#", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"#"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_text_append_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(ListConcatExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ListConcatExpression1)
    r0.extend(ListConcatExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:list_concat_expression][start_index] = r0

  r0
end
_nt_list_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 1361
def _nt_list_literal
  start_index = index
  if node_cache[:list_literal].has_key?(index)
    cached = node_cache[:list_literal][index]
    if cached
      node_cache[:list_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_empty_list_literal
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(ListLiteral0)
    r1.extend(ListLiteral1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_non_empty_list_literal
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(ListLiteral2)
      r3.extend(ListLiteral3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:list_literal][start_index] = r0

  r0
end
_nt_mult_div_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3994
def _nt_mult_div_expression
  start_index = index
  if node_cache[:mult_div_expression].has_key?(index)
    cached = node_cache[:mult_div_expression][index]
    if cached
      node_cache[:mult_div_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_list_concat_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6 = index
        if (match_len = has_terminal?("*", false, index))
          r7 = true
          @index += match_len
        else
          terminal_parse_failure('"*"')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          if (match_len = has_terminal?("/", false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('"/"')
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            @index = i6
            r6 = nil
          end
        end
        s3 << r6
        if r6
          r10 = _nt_space
          if r10
            r9 = r10
          else
            r9 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r9
          if r9
            r11 = _nt_list_concat_expression
            s3 << r11
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(MultDivExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MultDivExpression1)
    r0.extend(MultDivExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:mult_div_expression][start_index] = r0

  r0
end
_nt_multi_line_comment() click to toggle source
# File lib/DhallishGrammar.rb, line 324
def _nt_multi_line_comment
  start_index = index
  if node_cache[:multi_line_comment].has_key?(index)
    cached = node_cache[:multi_line_comment][index]
    if cached
      node_cache[:multi_line_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("{-", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"{-"')
    r1 = nil
  end
  s0 << r1
  if r1
    r2 = _nt_multi_line_comment_continue
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(MultiLineComment0)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:multi_line_comment][start_index] = r0

  r0
end
_nt_multi_line_comment_chunk() click to toggle source
# File lib/DhallishGrammar.rb, line 364
def _nt_multi_line_comment_chunk
  start_index = index
  if node_cache[:multi_line_comment_chunk].has_key?(index)
    cached = node_cache[:multi_line_comment_chunk][index]
    if cached
      node_cache[:multi_line_comment_chunk][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_multi_line_comment
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    i3 = index
    if (match_len = has_terminal?("{-", false, index))
      r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"{-"')
      r4 = nil
    end
    if r4
      @index = i3
      r3 = nil
      terminal_parse_failure('"{-"', true)
    else
      @terminal_failures.pop
      @index = i3
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s2 << r3
    if r3
      if index < input_length
        r5 = true
        @index += 1
      else
        terminal_parse_failure("any character")
        r5 = nil
      end
      s2 << r5
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(MultiLineCommentChunk0)
    else
      @index = i2
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:multi_line_comment_chunk][start_index] = r0

  r0
end
_nt_multi_line_comment_continue() click to toggle source
# File lib/DhallishGrammar.rb, line 441
def _nt_multi_line_comment_continue
  start_index = index
  if node_cache[:multi_line_comment_continue].has_key?(index)
    cached = node_cache[:multi_line_comment_continue][index]
    if cached
      node_cache[:multi_line_comment_continue][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?("-}", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"-}"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    r3 = _nt_multi_line_comment_chunk
    s2 << r3
    if r3
      r4 = _nt_multi_line_comment_continue
      s2 << r4
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(MultiLineCommentContinue0)
    else
      @index = i2
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:multi_line_comment_continue][start_index] = r0

  r0
end
_nt_natural_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 911
def _nt_natural_literal
  start_index = index
  if node_cache[:natural_literal].has_key?(index)
    cached = node_cache[:natural_literal][index]
    if cached
      node_cache[:natural_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[0-9]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NaturalLiteral0)
    r0.extend(NaturalLiteral0)
  end

  node_cache[:natural_literal][start_index] = r0

  r0
end
_nt_non_empty_list_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 1165
def _nt_non_empty_list_literal
  start_index = index
  if node_cache[:non_empty_list_literal].has_key?(index)
    cached = node_cache[:non_empty_list_literal][index]
    if cached
      node_cache[:non_empty_list_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("[", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"["')
    r1 = nil
  end
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      r4 = _nt_expression
      s0 << r4
      if r4
        s5, i5 = [], index
        loop do
          i6, s6 = index, []
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s6 << r7
          if r7
            if (match_len = has_terminal?(",", false, index))
              r9 = true
              @index += match_len
            else
              terminal_parse_failure('","')
              r9 = nil
            end
            s6 << r9
            if r9
              r11 = _nt_space
              if r11
                r10 = r11
              else
                r10 = instantiate_node(SyntaxNode,input, index...index)
              end
              s6 << r10
              if r10
                r12 = _nt_expression
                s6 << r12
              end
            end
          end
          if s6.last
            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
            r6.extend(NonEmptyListLiteral0)
          else
            @index = i6
            r6 = nil
          end
          if r6
            s5 << r6
          else
            break
          end
        end
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        s0 << r5
        if r5
          r14 = _nt_space
          if r14
            r13 = r14
          else
            r13 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r13
          if r13
            if (match_len = has_terminal?("]", false, index))
              r15 = true
              @index += match_len
            else
              terminal_parse_failure('"]"')
              r15 = nil
            end
            s0 << r15
            if r15
              i17, s17 = index, []
              r19 = _nt_space
              if r19
                r18 = r19
              else
                r18 = instantiate_node(SyntaxNode,input, index...index)
              end
              s17 << r18
              if r18
                if (match_len = has_terminal?(":", false, index))
                  r20 = true
                  @index += match_len
                else
                  terminal_parse_failure('":"')
                  r20 = nil
                end
                s17 << r20
                if r20
                  r22 = _nt_space
                  if r22
                    r21 = r22
                  else
                    r21 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s17 << r21
                  if r21
                    if (match_len = has_terminal?("List", false, index))
                      r23 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                      @index += match_len
                    else
                      terminal_parse_failure('"List"')
                      r23 = nil
                    end
                    s17 << r23
                    if r23
                      r24 = _nt_space
                      s17 << r24
                      if r24
                        r25 = _nt_expression
                        s17 << r25
                      end
                    end
                  end
                end
              end
              if s17.last
                r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
                r17.extend(NonEmptyListLiteral1)
              else
                @index = i17
                r17 = nil
              end
              if r17
                r16 = r17
              else
                r16 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r16
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(NonEmptyListLiteral2)
    r0.extend(NonEmptyListLiteral3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:non_empty_list_literal][start_index] = r0

  r0
end
_nt_optional_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2239
def _nt_optional_literal
  start_index = index
  if node_cache[:optional_literal].has_key?(index)
    cached = node_cache[:optional_literal][index]
    if cached
      node_cache[:optional_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  i1 = index
  if (match_len = has_terminal?("Some", false, index))
    r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"Some"')
    r2 = nil
  end
  if r2
    r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
    r1 = r2
  else
    if (match_len = has_terminal?("None", false, index))
      r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"None"')
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r1 = r3
    else
      @index = i1
      r1 = nil
    end
  end
  s0 << r1
  if r1
    r4 = _nt_space
    s0 << r4
    if r4
      r5 = _nt_or_expression
      s0 << r5
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OptionalLiteral0)
    r0.extend(OptionalLiteral1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:optional_literal][start_index] = r0

  r0
end
_nt_or_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 3475
def _nt_or_expression
  start_index = index
  if node_cache[:or_expression].has_key?(index)
    cached = node_cache[:or_expression][index]
    if cached
      node_cache[:or_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_and_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?("||", false, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"||"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_and_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(OrExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(OrExpression1)
    r0.extend(OrExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:or_expression][start_index] = r0

  r0
end
_nt_primitive_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 5099
def _nt_primitive_expression
  start_index = index
  if node_cache[:primitive_expression].has_key?(index)
    cached = node_cache[:primitive_expression][index]
    if cached
      node_cache[:primitive_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_bool_literal
  s1 << r2
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(PrimitiveExpression0)
    r1.extend(PrimitiveExpression1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i3, s3 = index, []
    r4 = _nt_double_literal
    s3 << r4
    if s3.last
      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
      r3.extend(PrimitiveExpression2)
      r3.extend(PrimitiveExpression3)
    else
      @index = i3
      r3 = nil
    end
    if r3
      r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
      r0 = r3
    else
      i5, s5 = index, []
      r6 = _nt_natural_literal
      s5 << r6
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(PrimitiveExpression4)
        r5.extend(PrimitiveExpression5)
      else
        @index = i5
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r0 = r5
      else
        i7, s7 = index, []
        r8 = _nt_integer_literal
        s7 << r8
        if s7.last
          r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
          r7.extend(PrimitiveExpression6)
          r7.extend(PrimitiveExpression7)
        else
          @index = i7
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r0 = r7
        else
          i9, s9 = index, []
          r10 = _nt_text_literal
          s9 << r10
          if s9.last
            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
            r9.extend(PrimitiveExpression8)
            r9.extend(PrimitiveExpression9)
          else
            @index = i9
            r9 = nil
          end
          if r9
            r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
            r0 = r9
          else
            i11, s11 = index, []
            r12 = _nt_list_literal
            s11 << r12
            if s11.last
              r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
              r11.extend(PrimitiveExpression10)
              r11.extend(PrimitiveExpression11)
            else
              @index = i11
              r11 = nil
            end
            if r11
              r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
              r0 = r11
            else
              i13, s13 = index, []
              r14 = _nt_function_definition
              s13 << r14
              if s13.last
                r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
                r13.extend(PrimitiveExpression12)
                r13.extend(PrimitiveExpression13)
              else
                @index = i13
                r13 = nil
              end
              if r13
                r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
                r0 = r13
              else
                i15, s15 = index, []
                r16 = _nt_optional_literal
                s15 << r16
                if s15.last
                  r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
                  r15.extend(PrimitiveExpression14)
                  r15.extend(PrimitiveExpression15)
                else
                  @index = i15
                  r15 = nil
                end
                if r15
                  r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                  r0 = r15
                else
                  i17, s17 = index, []
                  r18 = _nt_forall_literal
                  s17 << r18
                  if s17.last
                    r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
                    r17.extend(PrimitiveExpression16)
                    r17.extend(PrimitiveExpression17)
                  else
                    @index = i17
                    r17 = nil
                  end
                  if r17
                    r17 = SyntaxNode.new(input, (index-1)...index) if r17 == true
                    r0 = r17
                  else
                    i19, s19 = index, []
                    r20 = _nt_import_expression
                    s19 << r20
                    if s19.last
                      r19 = instantiate_node(SyntaxNode,input, i19...index, s19)
                      r19.extend(PrimitiveExpression18)
                      r19.extend(PrimitiveExpression19)
                    else
                      @index = i19
                      r19 = nil
                    end
                    if r19
                      r19 = SyntaxNode.new(input, (index-1)...index) if r19 == true
                      r0 = r19
                    else
                      i21, s21 = index, []
                      r22 = _nt_label
                      s21 << r22
                      if s21.last
                        r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
                        r21.extend(PrimitiveExpression20)
                        r21.extend(PrimitiveExpression21)
                      else
                        @index = i21
                        r21 = nil
                      end
                      if r21
                        r21 = SyntaxNode.new(input, (index-1)...index) if r21 == true
                        r0 = r21
                      else
                        i23, s23 = index, []
                        r24 = _nt_record_literal
                        s23 << r24
                        if s23.last
                          r23 = instantiate_node(SyntaxNode,input, i23...index, s23)
                          r23.extend(PrimitiveExpression22)
                          r23.extend(PrimitiveExpression23)
                        else
                          @index = i23
                          r23 = nil
                        end
                        if r23
                          r23 = SyntaxNode.new(input, (index-1)...index) if r23 == true
                          r0 = r23
                        else
                          i25, s25 = index, []
                          r26 = _nt_record_type_literal
                          s25 << r26
                          if s25.last
                            r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
                            r25.extend(PrimitiveExpression24)
                            r25.extend(PrimitiveExpression25)
                          else
                            @index = i25
                            r25 = nil
                          end
                          if r25
                            r25 = SyntaxNode.new(input, (index-1)...index) if r25 == true
                            r0 = r25
                          else
                            i27, s27 = index, []
                            r28 = _nt_union_literal
                            s27 << r28
                            if s27.last
                              r27 = instantiate_node(SyntaxNode,input, i27...index, s27)
                              r27.extend(PrimitiveExpression26)
                              r27.extend(PrimitiveExpression27)
                            else
                              @index = i27
                              r27 = nil
                            end
                            if r27
                              r27 = SyntaxNode.new(input, (index-1)...index) if r27 == true
                              r0 = r27
                            else
                              i29, s29 = index, []
                              r30 = _nt_union_type_literal
                              s29 << r30
                              if s29.last
                                r29 = instantiate_node(SyntaxNode,input, i29...index, s29)
                                r29.extend(PrimitiveExpression28)
                                r29.extend(PrimitiveExpression29)
                              else
                                @index = i29
                                r29 = nil
                              end
                              if r29
                                r29 = SyntaxNode.new(input, (index-1)...index) if r29 == true
                                r0 = r29
                              else
                                i31, s31 = index, []
                                if (match_len = has_terminal?("(", false, index))
                                  r32 = true
                                  @index += match_len
                                else
                                  terminal_parse_failure('"("')
                                  r32 = nil
                                end
                                s31 << r32
                                if r32
                                  r34 = _nt_space
                                  if r34
                                    r33 = r34
                                  else
                                    r33 = instantiate_node(SyntaxNode,input, index...index)
                                  end
                                  s31 << r33
                                  if r33
                                    r35 = _nt_expression
                                    s31 << r35
                                    if r35
                                      r37 = _nt_space
                                      if r37
                                        r36 = r37
                                      else
                                        r36 = instantiate_node(SyntaxNode,input, index...index)
                                      end
                                      s31 << r36
                                      if r36
                                        if (match_len = has_terminal?(")", false, index))
                                          r38 = true
                                          @index += match_len
                                        else
                                          terminal_parse_failure('")"')
                                          r38 = nil
                                        end
                                        s31 << r38
                                      end
                                    end
                                  end
                                end
                                if s31.last
                                  r31 = instantiate_node(SyntaxNode,input, i31...index, s31)
                                  r31.extend(PrimitiveExpression30)
                                  r31.extend(PrimitiveExpression31)
                                else
                                  @index = i31
                                  r31 = nil
                                end
                                if r31
                                  r31 = SyntaxNode.new(input, (index-1)...index) if r31 == true
                                  r0 = r31
                                else
                                  if (match_len = has_terminal?("???", false, index))
                                    r39 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                                    r39.extend(PrimitiveExpression32)
                                    @index += match_len
                                  else
                                    terminal_parse_failure('"???"')
                                    r39 = nil
                                  end
                                  if r39
                                    r39 = SyntaxNode.new(input, (index-1)...index) if r39 == true
                                    r0 = r39
                                  else
                                    @index = i0
                                    r0 = nil
                                  end
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end

  node_cache[:primitive_expression][start_index] = r0

  r0
end
_nt_proj_sel_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 4824
def _nt_proj_sel_expression
  start_index = index
  if node_cache[:proj_sel_expression].has_key?(index)
    cached = node_cache[:proj_sel_expression][index]
    if cached
      node_cache[:proj_sel_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_primitive_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?(".", false, index))
          r6 = true
          @index += match_len
        else
          terminal_parse_failure('"."')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            i9 = index
            i10, s10 = index, []
            r11 = _nt_label
            s10 << r11
            if s10.last
              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
              r10.extend(ProjSelExpression0)
            else
              @index = i10
              r10 = nil
            end
            if r10
              r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
              r9 = r10
            else
              i12, s12 = index, []
              r13 = _nt_key_list
              s12 << r13
              if s12.last
                r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
                r12.extend(ProjSelExpression1)
              else
                @index = i12
                r12 = nil
              end
              if r12
                r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                r9 = r12
              else
                @index = i9
                r9 = nil
              end
            end
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(ProjSelExpression2)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(ProjSelExpression3)
    r0.extend(ProjSelExpression4)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:proj_sel_expression][start_index] = r0

  r0
end
_nt_record_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 1730
def _nt_record_literal
  start_index = index
  if node_cache[:record_literal].has_key?(index)
    cached = node_cache[:record_literal][index]
    if cached
      node_cache[:record_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?("{", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"{"')
    r2 = nil
  end
  s1 << r2
  if r2
    r4 = _nt_space
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << r3
    if r3
      if (match_len = has_terminal?("=", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"="')
        r5 = nil
      end
      s1 << r5
      if r5
        r7 = _nt_space
        if r7
          r6 = r7
        else
          r6 = instantiate_node(SyntaxNode,input, index...index)
        end
        s1 << r6
        if r6
          if (match_len = has_terminal?("}", false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('"}"')
            r8 = nil
          end
          s1 << r8
        end
      end
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(RecordLiteral0)
    r1.extend(RecordLiteral1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i9, s9 = index, []
    if (match_len = has_terminal?("{", false, index))
      r10 = true
      @index += match_len
    else
      terminal_parse_failure('"{"')
      r10 = nil
    end
    s9 << r10
    if r10
      r12 = _nt_space
      if r12
        r11 = r12
      else
        r11 = instantiate_node(SyntaxNode,input, index...index)
      end
      s9 << r11
      if r11
        r13 = _nt_label
        s9 << r13
        if r13
          r15 = _nt_space
          if r15
            r14 = r15
          else
            r14 = instantiate_node(SyntaxNode,input, index...index)
          end
          s9 << r14
          if r14
            if (match_len = has_terminal?("=", false, index))
              r16 = true
              @index += match_len
            else
              terminal_parse_failure('"="')
              r16 = nil
            end
            s9 << r16
            if r16
              r18 = _nt_space
              if r18
                r17 = r18
              else
                r17 = instantiate_node(SyntaxNode,input, index...index)
              end
              s9 << r17
              if r17
                r19 = _nt_expression
                s9 << r19
                if r19
                  s20, i20 = [], index
                  loop do
                    i21, s21 = index, []
                    r23 = _nt_space
                    if r23
                      r22 = r23
                    else
                      r22 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s21 << r22
                    if r22
                      if (match_len = has_terminal?(",", false, index))
                        r24 = true
                        @index += match_len
                      else
                        terminal_parse_failure('","')
                        r24 = nil
                      end
                      s21 << r24
                      if r24
                        r26 = _nt_space
                        if r26
                          r25 = r26
                        else
                          r25 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s21 << r25
                        if r25
                          r27 = _nt_label
                          s21 << r27
                          if r27
                            r29 = _nt_space
                            if r29
                              r28 = r29
                            else
                              r28 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s21 << r28
                            if r28
                              if (match_len = has_terminal?("=", false, index))
                                r30 = true
                                @index += match_len
                              else
                                terminal_parse_failure('"="')
                                r30 = nil
                              end
                              s21 << r30
                              if r30
                                r32 = _nt_space
                                if r32
                                  r31 = r32
                                else
                                  r31 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s21 << r31
                                if r31
                                  r33 = _nt_expression
                                  s21 << r33
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                    if s21.last
                      r21 = instantiate_node(SyntaxNode,input, i21...index, s21)
                      r21.extend(RecordLiteral2)
                    else
                      @index = i21
                      r21 = nil
                    end
                    if r21
                      s20 << r21
                    else
                      break
                    end
                  end
                  r20 = instantiate_node(SyntaxNode,input, i20...index, s20)
                  s9 << r20
                  if r20
                    r35 = _nt_space
                    if r35
                      r34 = r35
                    else
                      r34 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s9 << r34
                    if r34
                      if (match_len = has_terminal?("}", false, index))
                        r36 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"}"')
                        r36 = nil
                      end
                      s9 << r36
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if s9.last
      r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
      r9.extend(RecordLiteral3)
      r9.extend(RecordLiteral4)
    else
      @index = i9
      r9 = nil
    end
    if r9
      r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
      r0 = r9
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:record_literal][start_index] = r0

  r0
end
_nt_record_merge_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 4330
def _nt_record_merge_expression
  start_index = index
  if node_cache[:record_merge_expression].has_key?(index)
    cached = node_cache[:record_merge_expression][index]
    if cached
      node_cache[:record_merge_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_application_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        i6 = index
        if (match_len = has_terminal?("//\\\\", false, index))
          r7 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"//\\\\\\\\"')
          r7 = nil
        end
        if r7
          r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
          r6 = r7
        else
          if (match_len = has_terminal?("â©“", false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('"â©“"')
            r8 = nil
          end
          if r8
            r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
            r6 = r8
          else
            if (match_len = has_terminal?("/\\", false, index))
              r9 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"/\\\\"')
              r9 = nil
            end
            if r9
              r9 = SyntaxNode.new(input, (index-1)...index) if r9 == true
              r6 = r9
            else
              if (match_len = has_terminal?("∧", false, index))
                r10 = true
                @index += match_len
              else
                terminal_parse_failure('"∧"')
                r10 = nil
              end
              if r10
                r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
                r6 = r10
              else
                if (match_len = has_terminal?("//", false, index))
                  r11 = instantiate_node(SyntaxNode,input, index...(index + match_len))
                  @index += match_len
                else
                  terminal_parse_failure('"//"')
                  r11 = nil
                end
                if r11
                  r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
                  r6 = r11
                else
                  if (match_len = has_terminal?("⫽", false, index))
                    r12 = true
                    @index += match_len
                  else
                    terminal_parse_failure('"⫽"')
                    r12 = nil
                  end
                  if r12
                    r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
                    r6 = r12
                  else
                    @index = i6
                    r6 = nil
                  end
                end
              end
            end
          end
        end
        s3 << r6
        if r6
          r14 = _nt_space
          if r14
            r13 = r14
          else
            r13 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r13
          if r13
            r15 = _nt_application_expression
            s3 << r15
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(RecordMergeExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(RecordMergeExpression1)
    r0.extend(RecordMergeExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:record_merge_expression][start_index] = r0

  r0
end
_nt_record_type_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 1457
def _nt_record_type_literal
  start_index = index
  if node_cache[:record_type_literal].has_key?(index)
    cached = node_cache[:record_type_literal][index]
    if cached
      node_cache[:record_type_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?("{", false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"{"')
    r2 = nil
  end
  s1 << r2
  if r2
    r4 = _nt_space
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << r3
    if r3
      if (match_len = has_terminal?("}", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"}"')
        r5 = nil
      end
      s1 << r5
    end
  end
  if s1.last
    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
    r1.extend(RecordTypeLiteral0)
    r1.extend(RecordTypeLiteral1)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i6, s6 = index, []
    if (match_len = has_terminal?("{", false, index))
      r7 = true
      @index += match_len
    else
      terminal_parse_failure('"{"')
      r7 = nil
    end
    s6 << r7
    if r7
      r9 = _nt_space
      if r9
        r8 = r9
      else
        r8 = instantiate_node(SyntaxNode,input, index...index)
      end
      s6 << r8
      if r8
        r10 = _nt_label
        s6 << r10
        if r10
          r12 = _nt_space
          if r12
            r11 = r12
          else
            r11 = instantiate_node(SyntaxNode,input, index...index)
          end
          s6 << r11
          if r11
            if (match_len = has_terminal?(":", false, index))
              r13 = true
              @index += match_len
            else
              terminal_parse_failure('":"')
              r13 = nil
            end
            s6 << r13
            if r13
              r15 = _nt_space
              if r15
                r14 = r15
              else
                r14 = instantiate_node(SyntaxNode,input, index...index)
              end
              s6 << r14
              if r14
                r16 = _nt_expression
                s6 << r16
                if r16
                  s17, i17 = [], index
                  loop do
                    i18, s18 = index, []
                    r20 = _nt_space
                    if r20
                      r19 = r20
                    else
                      r19 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s18 << r19
                    if r19
                      if (match_len = has_terminal?(",", false, index))
                        r21 = true
                        @index += match_len
                      else
                        terminal_parse_failure('","')
                        r21 = nil
                      end
                      s18 << r21
                      if r21
                        r23 = _nt_space
                        if r23
                          r22 = r23
                        else
                          r22 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s18 << r22
                        if r22
                          r24 = _nt_label
                          s18 << r24
                          if r24
                            r26 = _nt_space
                            if r26
                              r25 = r26
                            else
                              r25 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s18 << r25
                            if r25
                              if (match_len = has_terminal?(":", false, index))
                                r27 = true
                                @index += match_len
                              else
                                terminal_parse_failure('":"')
                                r27 = nil
                              end
                              s18 << r27
                              if r27
                                r29 = _nt_space
                                if r29
                                  r28 = r29
                                else
                                  r28 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s18 << r28
                                if r28
                                  r30 = _nt_expression
                                  s18 << r30
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                    if s18.last
                      r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
                      r18.extend(RecordTypeLiteral2)
                    else
                      @index = i18
                      r18 = nil
                    end
                    if r18
                      s17 << r18
                    else
                      break
                    end
                  end
                  r17 = instantiate_node(SyntaxNode,input, i17...index, s17)
                  s6 << r17
                  if r17
                    r32 = _nt_space
                    if r32
                      r31 = r32
                    else
                      r31 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s6 << r31
                    if r31
                      if (match_len = has_terminal?("}", false, index))
                        r33 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"}"')
                        r33 = nil
                      end
                      s6 << r33
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if s6.last
      r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
      r6.extend(RecordTypeLiteral3)
      r6.extend(RecordTypeLiteral4)
    else
      @index = i6
      r6 = nil
    end
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:record_type_literal][start_index] = r0

  r0
end
_nt_reserved() click to toggle source
# File lib/DhallishGrammar.rb, line 6829
def _nt_reserved
  start_index = index
  if node_cache[:reserved].has_key?(index)
    cached = node_cache[:reserved][index]
    if cached
      node_cache[:reserved][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?("if", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"if"')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?("then", false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('"then"')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?("else", false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('"else"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?("let", false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"let"')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?("in", false, index))
            r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
            @index += match_len
          else
            terminal_parse_failure('"in"')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?("as", false, index))
              r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
              @index += match_len
            else
              terminal_parse_failure('"as"')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r0 = r6
            else
              if (match_len = has_terminal?("?", false, index))
                r7 = true
                @index += match_len
              else
                terminal_parse_failure('"?"')
                r7 = nil
              end
              if r7
                r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
                r0 = r7
              else
                @index = i0
                r0 = nil
              end
            end
          end
        end
      end
    end
  end

  node_cache[:reserved][start_index] = r0

  r0
end
_nt_root() click to toggle source
# File lib/DhallishGrammar.rb, line 26
def _nt_root
  start_index = index
  if node_cache[:root].has_key?(index)
    cached = node_cache[:root][index]
    if cached
      node_cache[:root][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r2 = _nt_space
  if r2
    r1 = r2
  else
    r1 = instantiate_node(SyntaxNode,input, index...index)
  end
  s0 << r1
  if r1
    r3 = _nt_expression
    s0 << r3
    if r3
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s0 << r4
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(Root0)
    r0.extend(Root1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:root][start_index] = r0

  r0
end
_nt_single_line_comment() click to toggle source
# File lib/DhallishGrammar.rb, line 227
def _nt_single_line_comment
  start_index = index
  if node_cache[:single_line_comment].has_key?(index)
    cached = node_cache[:single_line_comment][index]
    if cached
      node_cache[:single_line_comment][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("--", false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('"--"')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      i4 = index
      if (match_len = has_terminal?("\n", false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('"\\n"')
        r5 = nil
      end
      if r5
        @index = i4
        r4 = nil
        terminal_parse_failure('"\\n"', true)
      else
        @terminal_failures.pop
        @index = i4
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if index < input_length
          r6 = true
          @index += 1
        else
          terminal_parse_failure("any character")
          r6 = nil
        end
        s3 << r6
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(SingleLineComment0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?("\n", false, index))
        r7 = true
        @index += match_len
      else
        terminal_parse_failure('"\\n"')
        r7 = nil
      end
      s0 << r7
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(SingleLineComment1)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:single_line_comment][start_index] = r0

  r0
end
_nt_space() click to toggle source
# File lib/DhallishGrammar.rb, line 492
def _nt_space
  start_index = index
  if node_cache[:space].has_key?(index)
    cached = node_cache[:space][index]
    if cached
      node_cache[:space][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  s0, i0 = [], index
  loop do
    i1 = index
    if (match_len = has_terminal?(" ", false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('" "')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r1 = r2
    else
      if (match_len = has_terminal?("\t", false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('"\\t"')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r1 = r3
      else
        r4 = _nt_eol
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r1 = r4
        else
          r5 = _nt_single_line_comment
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r1 = r5
          else
            r6 = _nt_multi_line_comment
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              r1 = r6
            else
              @index = i1
              r1 = nil
            end
          end
        end
      end
    end
    if r1
      s0 << r1
    else
      break
    end
  end
  if s0.empty?
    @index = i0
    r0 = nil
  else
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
  end

  node_cache[:space][start_index] = r0

  r0
end
_nt_text_append_expression() click to toggle source
# File lib/DhallishGrammar.rb, line 4218
def _nt_text_append_expression
  start_index = index
  if node_cache[:text_append_expression].has_key?(index)
    cached = node_cache[:text_append_expression][index]
    if cached
      node_cache[:text_append_expression][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  r1 = _nt_record_merge_expression
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3, s3 = index, []
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s3 << r4
      if r4
        if (match_len = has_terminal?("++", false, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('"++"')
          r6 = nil
        end
        s3 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s3 << r7
          if r7
            r9 = _nt_record_merge_expression
            s3 << r9
          end
        end
      end
      if s3.last
        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
        r3.extend(TextAppendExpression0)
      else
        @index = i3
        r3 = nil
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TextAppendExpression1)
    r0.extend(TextAppendExpression2)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:text_append_expression][start_index] = r0

  r0
end
_nt_text_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2029
def _nt_text_literal
  start_index = index
  if node_cache[:text_literal].has_key?(index)
    cached = node_cache[:text_literal][index]
    if cached
      node_cache[:text_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?('"', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('\'"\'')
    r1 = nil
  end
  s0 << r1
  if r1
    s2, i2 = [], index
    loop do
      i3 = index
      i4, s4 = index, []
      i5, s5 = index, []
      if (match_len = has_terminal?('${', false, index))
        r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('\'${\'')
        r6 = nil
      end
      s5 << r6
      if r6
        r8 = _nt_space
        if r8
          r7 = r8
        else
          r7 = instantiate_node(SyntaxNode,input, index...index)
        end
        s5 << r7
        if r7
          r9 = _nt_expression
          s5 << r9
          if r9
            r11 = _nt_space
            if r11
              r10 = r11
            else
              r10 = instantiate_node(SyntaxNode,input, index...index)
            end
            s5 << r10
            if r10
              if (match_len = has_terminal?('}', false, index))
                r12 = true
                @index += match_len
              else
                terminal_parse_failure('\'}\'')
                r12 = nil
              end
              s5 << r12
            end
          end
        end
      end
      if s5.last
        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
        r5.extend(TextLiteral0)
      else
        @index = i5
        r5 = nil
      end
      s4 << r5
      if s4.last
        r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
        r4.extend(TextLiteral1)
      else
        @index = i4
        r4 = nil
      end
      if r4
        r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
        r3 = r4
      else
        i13, s13 = index, []
        if (match_len = has_terminal?('\"', false, index))
          r14 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('\'\\"\'')
          r14 = nil
        end
        s13 << r14
        if s13.last
          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
          r13.extend(TextLiteral2)
        else
          @index = i13
          r13 = nil
        end
        if r13
          r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
          r3 = r13
        else
          i15, s15 = index, []
          i16, s16 = index, []
          i17 = index
          if (match_len = has_terminal?('"', false, index))
            r18 = true
            @index += match_len
          else
            terminal_parse_failure('\'"\'')
            r18 = nil
          end
          if r18
            @index = i17
            r17 = nil
            terminal_parse_failure('\'"\'', true)
          else
            @terminal_failures.pop
            @index = i17
            r17 = instantiate_node(SyntaxNode,input, index...index)
          end
          s16 << r17
          if r17
            if index < input_length
              r19 = true
              @index += 1
            else
              terminal_parse_failure("any character")
              r19 = nil
            end
            s16 << r19
          end
          if s16.last
            r16 = instantiate_node(SyntaxNode,input, i16...index, s16)
            r16.extend(TextLiteral3)
          else
            @index = i16
            r16 = nil
          end
          s15 << r16
          if s15.last
            r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
            r15.extend(TextLiteral4)
          else
            @index = i15
            r15 = nil
          end
          if r15
            r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
            r3 = r15
          else
            @index = i3
            r3 = nil
          end
        end
      end
      if r3
        s2 << r3
      else
        break
      end
    end
    r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
    s0 << r2
    if r2
      if (match_len = has_terminal?('"', false, index))
        r20 = true
        @index += match_len
      else
        terminal_parse_failure('\'"\'')
        r20 = nil
      end
      s0 << r20
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(TextLiteral5)
    r0.extend(TextLiteral6)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:text_literal][start_index] = r0

  r0
end
_nt_union_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2563
def _nt_union_literal
  start_index = index
  if node_cache[:union_literal].has_key?(index)
    cached = node_cache[:union_literal][index]
    if cached
      node_cache[:union_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0, s0 = index, []
  if (match_len = has_terminal?("<", false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('"<"')
    r1 = nil
  end
  s0 << r1
  if r1
    r3 = _nt_space
    if r3
      r2 = r3
    else
      r2 = instantiate_node(SyntaxNode,input, index...index)
    end
    s0 << r2
    if r2
      s4, i4 = [], index
      loop do
        i5, s5 = index, []
        r6 = _nt_label
        s5 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s5 << r7
          if r7
            if (match_len = has_terminal?(":", false, index))
              r9 = true
              @index += match_len
            else
              terminal_parse_failure('":"')
              r9 = nil
            end
            s5 << r9
            if r9
              r11 = _nt_space
              if r11
                r10 = r11
              else
                r10 = instantiate_node(SyntaxNode,input, index...index)
              end
              s5 << r10
              if r10
                r12 = _nt_record_merge_expression
                s5 << r12
                if r12
                  r14 = _nt_space
                  if r14
                    r13 = r14
                  else
                    r13 = instantiate_node(SyntaxNode,input, index...index)
                  end
                  s5 << r13
                  if r13
                    if (match_len = has_terminal?("|", false, index))
                      r15 = true
                      @index += match_len
                    else
                      terminal_parse_failure('"|"')
                      r15 = nil
                    end
                    s5 << r15
                    if r15
                      r17 = _nt_space
                      if r17
                        r16 = r17
                      else
                        r16 = instantiate_node(SyntaxNode,input, index...index)
                      end
                      s5 << r16
                    end
                  end
                end
              end
            end
          end
        end
        if s5.last
          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
          r5.extend(UnionLiteral0)
        else
          @index = i5
          r5 = nil
        end
        if r5
          s4 << r5
        else
          break
        end
      end
      r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
      s0 << r4
      if r4
        r18 = _nt_label
        s0 << r18
        if r18
          r20 = _nt_space
          if r20
            r19 = r20
          else
            r19 = instantiate_node(SyntaxNode,input, index...index)
          end
          s0 << r19
          if r19
            if (match_len = has_terminal?("=", false, index))
              r21 = true
              @index += match_len
            else
              terminal_parse_failure('"="')
              r21 = nil
            end
            s0 << r21
            if r21
              r23 = _nt_space
              if r23
                r22 = r23
              else
                r22 = instantiate_node(SyntaxNode,input, index...index)
              end
              s0 << r22
              if r22
                r24 = _nt_record_merge_expression
                s0 << r24
                if r24
                  s25, i25 = [], index
                  loop do
                    i26, s26 = index, []
                    r28 = _nt_space
                    if r28
                      r27 = r28
                    else
                      r27 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s26 << r27
                    if r27
                      if (match_len = has_terminal?("|", false, index))
                        r29 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"|"')
                        r29 = nil
                      end
                      s26 << r29
                      if r29
                        r31 = _nt_space
                        if r31
                          r30 = r31
                        else
                          r30 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s26 << r30
                        if r30
                          r32 = _nt_label
                          s26 << r32
                          if r32
                            r34 = _nt_space
                            if r34
                              r33 = r34
                            else
                              r33 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s26 << r33
                            if r33
                              if (match_len = has_terminal?(":", false, index))
                                r35 = true
                                @index += match_len
                              else
                                terminal_parse_failure('":"')
                                r35 = nil
                              end
                              s26 << r35
                              if r35
                                r37 = _nt_space
                                if r37
                                  r36 = r37
                                else
                                  r36 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s26 << r36
                                if r36
                                  r38 = _nt_record_merge_expression
                                  s26 << r38
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                    if s26.last
                      r26 = instantiate_node(SyntaxNode,input, i26...index, s26)
                      r26.extend(UnionLiteral1)
                    else
                      @index = i26
                      r26 = nil
                    end
                    if r26
                      s25 << r26
                    else
                      break
                    end
                  end
                  r25 = instantiate_node(SyntaxNode,input, i25...index, s25)
                  s0 << r25
                  if r25
                    r40 = _nt_space
                    if r40
                      r39 = r40
                    else
                      r39 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s0 << r39
                    if r39
                      if (match_len = has_terminal?(">", false, index))
                        r41 = true
                        @index += match_len
                      else
                        terminal_parse_failure('">"')
                        r41 = nil
                      end
                      s0 << r41
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
  end
  if s0.last
    r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
    r0.extend(UnionLiteral2)
    r0.extend(UnionLiteral3)
  else
    @index = i0
    r0 = nil
  end

  node_cache[:union_literal][start_index] = r0

  r0
end
_nt_union_type_literal() click to toggle source
# File lib/DhallishGrammar.rb, line 2919
def _nt_union_type_literal
  start_index = index
  if node_cache[:union_type_literal].has_key?(index)
    cached = node_cache[:union_type_literal][index]
    if cached
      node_cache[:union_type_literal][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_empty_union_type_literal
  r1.extend(UnionTypeLiteral0)
  r1.extend(UnionTypeLiteral0)
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    if (match_len = has_terminal?("<", false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('"<"')
      r3 = nil
    end
    s2 << r3
    if r3
      r5 = _nt_space
      if r5
        r4 = r5
      else
        r4 = instantiate_node(SyntaxNode,input, index...index)
      end
      s2 << r4
      if r4
        r6 = _nt_label
        s2 << r6
        if r6
          r8 = _nt_space
          if r8
            r7 = r8
          else
            r7 = instantiate_node(SyntaxNode,input, index...index)
          end
          s2 << r7
          if r7
            if (match_len = has_terminal?(":", false, index))
              r9 = true
              @index += match_len
            else
              terminal_parse_failure('":"')
              r9 = nil
            end
            s2 << r9
            if r9
              r11 = _nt_space
              if r11
                r10 = r11
              else
                r10 = instantiate_node(SyntaxNode,input, index...index)
              end
              s2 << r10
              if r10
                r12 = _nt_record_merge_expression
                s2 << r12
                if r12
                  s13, i13 = [], index
                  loop do
                    i14, s14 = index, []
                    r16 = _nt_space
                    if r16
                      r15 = r16
                    else
                      r15 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s14 << r15
                    if r15
                      if (match_len = has_terminal?("|", false, index))
                        r17 = true
                        @index += match_len
                      else
                        terminal_parse_failure('"|"')
                        r17 = nil
                      end
                      s14 << r17
                      if r17
                        r19 = _nt_space
                        if r19
                          r18 = r19
                        else
                          r18 = instantiate_node(SyntaxNode,input, index...index)
                        end
                        s14 << r18
                        if r18
                          r20 = _nt_label
                          s14 << r20
                          if r20
                            r22 = _nt_space
                            if r22
                              r21 = r22
                            else
                              r21 = instantiate_node(SyntaxNode,input, index...index)
                            end
                            s14 << r21
                            if r21
                              if (match_len = has_terminal?(":", false, index))
                                r23 = true
                                @index += match_len
                              else
                                terminal_parse_failure('":"')
                                r23 = nil
                              end
                              s14 << r23
                              if r23
                                r25 = _nt_space
                                if r25
                                  r24 = r25
                                else
                                  r24 = instantiate_node(SyntaxNode,input, index...index)
                                end
                                s14 << r24
                                if r24
                                  r26 = _nt_record_merge_expression
                                  s14 << r26
                                end
                              end
                            end
                          end
                        end
                      end
                    end
                    if s14.last
                      r14 = instantiate_node(SyntaxNode,input, i14...index, s14)
                      r14.extend(UnionTypeLiteral1)
                    else
                      @index = i14
                      r14 = nil
                    end
                    if r14
                      s13 << r14
                    else
                      break
                    end
                  end
                  r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
                  s2 << r13
                  if r13
                    r28 = _nt_space
                    if r28
                      r27 = r28
                    else
                      r27 = instantiate_node(SyntaxNode,input, index...index)
                    end
                    s2 << r27
                    if r27
                      if (match_len = has_terminal?(">", false, index))
                        r29 = true
                        @index += match_len
                      else
                        terminal_parse_failure('">"')
                        r29 = nil
                      end
                      s2 << r29
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
    if s2.last
      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
      r2.extend(UnionTypeLiteral2)
      r2.extend(UnionTypeLiteral3)
    else
      @index = i2
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:union_type_literal][start_index] = r0

  r0
end
root() click to toggle source
# File lib/DhallishGrammar.rb, line 11
def root
  @root ||= :root
end