let rec exp_to_patt (_loc: Ast.Loc.t) (an_expression: Ast.expr): Ast.patt =
  match an_expression with
      <:expr< $int:s$ >> -> <:patt< $int:s$ >> (* integer constant *)
    | <:expr< $chr:c$ >> -> <:patt< $chr:c$ >> (* character constant *)
    | <:expr< $str:s$ >> -> <:patt< $str:s$ >> (* string constant *)
    | <:expr< $lid:b$ >> -> <:patt< $lid:b$ >> (* local variable *)
    | <:expr< $uid:b$ >> -> <:patt< $uid:b$ >> (* variable of other module *)
    | <:expr< $e1$ $e2$ >> ->                  (* function application *)
      let p1 = exp_to_patt _loc e1
      and p2 = exp_to_patt _loc e2 in
        <:patt< $p1$ $p2$ >>
    | <:expr< ($tup:e$) >> ->                  (* tuple *)
      let p = exp_to_patt _loc e in
        <:patt< ($tup:p$) >>
    | <:expr< $e1$, $e2$ >> ->
      let p1 = exp_to_patt _loc e1
      and p2 = exp_to_patt _loc e2 in
        <:patt< $p1$, $p2$ >>
    | <:expr< { $rec_binding:r$ } >> ->        (* record *)
      let p = recbinding_to_patt _loc r in
        <:patt< { $p$ } >>
    | <:expr< ($e$ : $t$) >> ->                (* type restriction *)
      let p = exp_to_patt _loc e in
        <:patt< ($p$ : $t$) >>
    | _ ->
      Loc.raise _loc
        (Stream.Error "exp_to_patt: this expression is not yet supported")
(** recbinding_to_pattrec _loc an_exp_record

Convert an_exp_record to a pattern matching a record. *)


and recbinding_to_patt (_loc: Ast.Loc.t) (an_exp_record: Ast.rec_binding): Ast.patt =
  match an_exp_record with
      <:rec_binding< >> -> <:patt< >>
    | <:rec_binding< $i$ = $e$ >> ->
      let p = exp_to_patt _loc e in
        <:patt< $i$ = $p$ >>
    | <:rec_binding< $b1$ ; $b2$ >> ->
        let p1 = recbinding_to_patt _loc b1
        and p2 = recbinding_to_patt _loc b2 in
          <:patt< $p1$; $p2$ >>
    | <:rec_binding< $anti:_$ >> ->
      Loc.raise _loc
        (Stream.Error "recbinding_to_patt: antiquotations are not yet supported")