5.16.5.23.1. Patterns

Start data section to src/flx_parse.mly[30 /33 ] Next Prev First Last
  2026: pattern:
  2027:   | as_pattern WHEN expr
  2028:     {
  2029:       `PAT_when
  2030:       (
  2031:         rsrange (src_of_pat $1) (src_of_expr $3),
  2032:         $1,
  2033:         $3
  2034:       )
  2035:     }
  2036:   | as_pattern { $1 }
  2037: 
  2038: as_pattern:
  2039:   | variant_pattern AS NAME
  2040:     {
  2041:       `PAT_as
  2042:       (
  2043:         rsrange (src_of_pat $1) (slift (fst $3)),
  2044:         $1,
  2045:         snd $3
  2046:       )
  2047:     }
  2048:   | variant_pattern { $1 }
  2049: 
  2050: variant_pattern:
  2051:   | tuple_pattern { $1 }
  2052: tuple_pattern:
  2053:   | coercive_pattern_list
  2054:     {
  2055:       match $1 with
  2056:       | [x] -> x
  2057:       | _ -> `PAT_tuple
  2058:         (
  2059:           rsrange (src_of_pat (List.hd $1)) (src_of_pat (list_last $1)),
  2060:           $1
  2061:         )
  2062:     }
  2063: 
  2064: coercive_pattern_list:
  2065:   | coercive_pattern COMMA coercive_pattern_list { $1 :: $3 }
  2066:   | coercive_pattern { [$1] }
  2067: 
  2068: coercive_pattern:
  2069:   | atomic_pattern COLON arrow
  2070:     {
  2071:       let sr = rsrange (src_of_pat $1) (src_of_expr $3) in
  2072:       let t = typecode_of_expr $3 in
  2073:       `PAT_coercion (sr,$1,t)
  2074:     }
  2075:   | atomic_pattern { $1 }
  2076: 
  2077: atomic_pattern:
  2078:   /* constants */
  2079:   | STRING { `PAT_string (slift (fst $1), snd $1) }
  2080:   | integral
  2081:     {
  2082:       let sr,t,v = $1 in
  2083:       `PAT_int (sr,t,v)
  2084:     }
  2085:   | NAN { `PAT_nan (slift $1) }
  2086: 
  2087:   /* ranges */
  2088:   | STRING DOTDOT STRING
  2089:     {
  2090:       `PAT_string_range (rstoken (fst $1) (fst $3), snd $1, snd $3)
  2091:     }
  2092:   | integral DOTDOT integral
  2093:     {
  2094:       let sr1,t1,v1 = $1
  2095:       and sr2,t2,v2 = $3
  2096:       in
  2097:       `PAT_int_range (rsrange sr1 sr2, t1,v1,t2,v2)
  2098:     }
  2099: 
  2100:   | floating DOTDOT floating
  2101:     {
  2102:       let sr1,v1 = $1
  2103:       and sr2,v2 = $3
  2104:       in
  2105:       `PAT_float_range
  2106:       (
  2107:        rsrange sr1 sr2,
  2108:        v1, v2
  2109:       )
  2110:     }
  2111: 
  2112:   /* other */
  2113:   | ctor_pattern { $1 }
  2114:   /*
  2115:   | QUEST NAME { `PAT_name (rstoken $1 (fst $2), snd $2) }
  2116:   */
  2117:   | QUEST NAME { let sr = rstoken $1 (fst $2)in `PAT_as (sr,`PAT_any sr, snd $2) }
  2118:   | QUEST { `PAT_any (slift $1) }
  2119:   | UNDERSCORE { `PAT_any (slift $1) }
  2120:   | LPAR pattern RPAR { $2 }
  2121:   | REGEXP STRING LPAR basic_name_comma_list RPAR
  2122:     {
  2123:       let names = List.map snd $4 in
  2124:       `PAT_regexp (rstoken $1 $5, snd $2, names)
  2125:     }
  2126:   | STRUCT LBRACE pat_assigns RBRACE
  2127:     {
  2128:       `PAT_record (rstoken $1 $4, $3)
  2129:     }
  2130: 
  2131: pat_assign:
  2132:   | NAME EQUAL pattern SEMI { snd $1, $3 }
  2133: pat_assigns:
  2134:   | pat_assign pat_assigns  { $1 :: $2 }
  2135:   | pat_assign { [$1] }
  2136: 
  2137: ctor_pattern:
  2138:   | ctor_name atomic_pattern
  2139:     {
  2140:       `PAT_nonconst_ctor
  2141:       (
  2142:         rsrange (src_of_expr $1) (src_of_pat $2),
  2143:         qualified_name_of_expr $1,
  2144:         $2
  2145:       )
  2146:     }
  2147:   | ctor_name
  2148:     {
  2149:       `PAT_const_ctor
  2150:       (
  2151:         src_of_expr $1,
  2152:         qualified_name_of_expr $1
  2153:       )
  2154:     }
  2155: 
  2156: ctor_name:
  2157:   | simple_name_parts
  2158:     {
  2159:       match $1 with sr,name,ts ->
  2160:       `AST_name (sr,name,ts)
  2161:     }
  2162: 
  2163:   | CASE INTEGER {
  2164:       let sr,t,v = $2 in
  2165:       `AST_case_tag (rstoken $1 sr, Big_int.int_of_big_int v)
  2166:     }
  2167: 
  2168: integral:
  2169:   | INTEGER { let sr,t,v = $1 in slift sr, t, v }
  2170:   | MINUS INTEGER
  2171:     {
  2172:       let sr,t,v = $2 in
  2173:       rstoken $1 sr, t, (Big_int.minus_big_int v)
  2174:     }
  2175: 
  2176: floating:
  2177:   | FLOAT
  2178:     {
  2179:       let sr,t,v = $1 in
  2180:       slift sr, Float_plus (t,v)
  2181:     }
  2182:   | MINUS FLOAT
  2183:     {
  2184:       let sr,t,v = $2 in
  2185:       rstoken $1 sr, Float_minus (t,v)
  2186:     }
  2187:   | INF { slift $1, Float_inf }
  2188:   | MINUS INF { slift $1, Float_minus_inf }
  2189: 
  2190: basic_name:
  2191:   | NAME { $1 }
  2192: basic_name_comma_list:
  2193:   | basic_name COMMA basic_name_comma_list { $1 :: $3 }
  2194:   | basic_name { [$1] }
  2195:   | { [] }
  2196: 
End data section to src/flx_parse.mly[30]