Failing tests, ocp-indent version 1.6.1+45 (2018-11-19)

(* this could be fixed, but we actually want to handle the first case

(* this could be fixed, but we actually want to handle the first case

   differently for when there is only one case (see next examples) *)

   differently for when there is only one case (see next examples) *)

let f x = function A -> x;

let f x = function A -> x;

  2

  2

                 | B -> y;

                 | B -> y;

                   3

                   3

(* if we were to fix to the case above, the second >>= would be below the _

(* if we were to fix to the case above, the second >>= would be below the _

   (test taken from js-fun) *)

   (test taken from js-fun) *)

let _ =

let _ =

  x

  x

  >>= fun x ->

  >>= fun x ->

  try x with _ -> ()

  try x with _ -> ()

    >>= fun x ->

    >>= fun x ->

    x

    x

(* (and also: the some_handling here would be below Not_found) *)

(* (and also: the some_handling here would be below Not_found) *)

let _ =

let _ =

  try

  try

    _

    _

  with Not_found ->

  with Not_found ->

    some_handling

    some_handling

let f = fun x ->

let f = fun x ->

  x

  x

let f = (fun x ->

let f = (fun x ->

    x

    x

  )

  )

let f g = g @@ fun x ->

let f g = g @@ fun x ->

  x

  x

let f g = g @@ (fun x ->

let f g = g @@ (fun x ->

    x

    x

  )

  )

(* the above should probably be consistent with: *)

(* the above should probably be consistent with: *)

let f x y = y + match x with A ->

let f x y = y + match x with A ->

    0

    0

let f x y = y + (match x with A ->

let f x y = y + (match x with A ->

    0

    0

  )

  )

(* wich means we may over-indent even when the block is non-closable *)

(* wich means we may over-indent even when the block is non-closable *)

let f x y = y + match x with

let f x y = y + match x with

  | A -> 0

  | A -> 0

let f x y = y + (match x with

let f x y = y + (match x with

    | A -> 0

    | A -> 0

  )

  )

let f x y = y + match x with

let f x y = y + match x with

  | A -> 0

  | A -> 0

let _ =

let _ =

  somefun

  somefun

    (fun x ->

    (fun x ->

       x);

       x);

  somefun

  somefun

    (if

    (if

      bla

      bla

     then

     then

       bli);

       bli);

  somefun

  somefun

    (if bla then

    (if bla then

       bli

       bli

     else

     else

       blu)

       blu)

let _ =

let _ =

  a

  a

  ;

  ;

  b

  b

(* Surprisingly, this is the indentation correpsonding to OCaml's interpretation

(* Surprisingly, this is the indentation correpsonding to OCaml's interpretation

   of this code.  Indenting this accordingly may help users notice that they're

   of this code.  Indenting this accordingly may help users notice that they're

   doing something dubious. *)

   doing something dubious. *)

let b = `b

let b = `b

let d = `d

let d = `d

;;

;;

let a = b

let a = b

;;

;;

let s1 = "No field 'install', but a field 'remove': install instructions \

let s1 = "No field 'install', but a field 'remove': install instructions \

          probably part of 'build'. Use the 'install' field or a .install \

          probably part of 'build'. Use the 'install' field or a .install \

          file"

          file"

let x =

let x =

  cond 40 `Warning

  cond 40 `Warning

    "Package uses flags that aren't recognised by earlier versions in \

    "Package uses flags that aren't recognised by earlier versions in \

     OPAM 1.2 branch. At the moment, you should use a tag \"flags:foo\" \

     OPAM 1.2 branch. At the moment, you should use a tag \"flags:foo\" \

     instead for compatibility"

     instead for compatibility"

    ~detail:alpha_flags

    ~detail:alpha_flags

    (alpha_flags <> [])

    (alpha_flags <> [])

let s2 = "bla bla

let s2 = "bla bla

 bli bli \

 bli bli \

          blo"

          blo"

let s3 = "\

let s3 = "\

"

"

let s4 = " \

let s4 = " \

         "

         "

let s5 = "  \

let s5 = "  \

          \

          \

         "

         "

let s6 = "

let s6 = "

"

"

let s7 = "  

let s7 = "  

"

"

let c1 = '

let c1 = '

let x1 = f x '

let x1 = f x '

    z

    z

let zz = "\

let zz = "\

s \

s \

 \

 \

 "

 "

type _ term =

type _ term =

  | Int : int -> int term

  | Int : int -> int term

  | Add : (int -> int -> int) term

  | Add : (int -> int -> int) term

  | App : ('b -> 'a) term * 'b term -> 'a term

  | App : ('b -> 'a) term * 'b term -> 'a term

let rec eval : type a. a term -> a = function

let rec eval : type a. a term -> a = function

  | Int n    -> n                 (* a = int *)

  | Int n    -> n                 (* a = int *)

  | Add      -> (fun x y -> x+y)  (* a = int -> int -> int *)

  | Add      -> (fun x y -> x+y)  (* a = int -> int -> int *)

  | App(f,x) -> (eval f) (eval x)

  | App(f,x) -> (eval f) (eval x)

(* eval called at types (b->a) and b for fresh b *)

(* eval called at types (b->a) and b for fresh b *)

let two = eval (App (App (Add, Int 1), Int 1))

let two = eval (App (App (Add, Int 1), Int 1))

let rec sum : type a. a term -> _ = fun x ->

let rec sum : type a. a term -> _ = fun x ->

  let y =

  let y =

    match x with

    match x with

    | Int n -> n

    | Int n -> n

    | Add   -> 0

    | Add   -> 0

    | App(f,x) -> sum f + sum x

    | App(f,x) -> sum f + sum x

  in y + 1

  in y + 1

type _ typ =

type _ typ =

  | Int : int typ

  | Int : int typ

  | String : string typ

  | String : string typ

  | Pair : 'a typ * 'b typ -> ('a * 'b) typ

  | Pair : 'a typ * 'b typ -> ('a * 'b) typ

let rec to_string: type t. t typ -> t -> string =

let rec to_string: type t. t typ -> t -> string =

  fun t x ->

  fun t x ->

type (_,_) eq = Eq : ('a,'a) eq

type (_,_) eq = Eq : ('a,'a) eq

let cast : type a b. (a,b) eq -> a -> b = fun Eq x -> x

let cast : type a b. (a,b) eq -> a -> b = fun Eq x -> x

let rec eq_type : type a b. a typ -> b typ -> (a,b) eq option =

let rec eq_type : type a b. a typ -> b typ -> (a,b) eq option =

  fun a b ->

  fun a b ->

type dyn = Dyn : 'a typ * 'a -> dyn

type dyn = Dyn : 'a typ * 'a -> dyn

let get_dyn : type a. a typ -> dyn -> a option =

let get_dyn : type a. a typ -> dyn -> a option =

  fun a (Dyn(b,x)) ->

  fun a (Dyn(b,x)) ->

let _ =

let _ =

  let f: type a. a list -> int =

  let f: type a. a list -> int =

    fun _x -> 42

    fun _x -> 42

  in

  in

  f []

  f []

let nth t n =

let nth t n =

  if n < 0 then None else

  if n < 0 then None else

    let rec nth_aux: type b. ('a, b) t -> int -> 'a option = fun t n ->

    let rec nth_aux: type b. ('a, b) t -> int -> 'a option = fun t n ->

      match t with

      match t with

      | Empty -> None

      | Empty -> None

      | Node (a, t) -> if n = 0 then Some a else nth_aux t (n-1)

      | Node (a, t) -> if n = 0 then Some a else nth_aux t (n-1)

    in

    in

    nth_aux t n

    nth_aux t n

let rec f : type a b. a = function

let rec f : type a b. a = function

  | _ -> assert false

  | _ -> assert false

and g : type a. a = function

and g : type a. a = function

  | _ -> assert false

  | _ -> assert false

let () =

let () =

  foo.bar <-

  foo.bar <-

    f x

    f x

      y z

      y z

let should_check_can_sell_and_marking regulatory_regime =

let should_check_can_sell_and_marking regulatory_regime =

  match z with

  match z with

  | `foo

  | `foo

    -> some_function

    -> some_function

         argument

         argument

(* The above typically occurs in a multi-pattern match clause, so the clause

(* The above typically occurs in a multi-pattern match clause, so the clause

   expression is on a line by itself.  This is the more typical way a long

   expression is on a line by itself.  This is the more typical way a long

   single-pattern match clause would be written: *)

   single-pattern match clause would be written: *)

let should_check_can_sell_and_marking regulatory_regime =

let should_check_can_sell_and_marking regulatory_regime =

  match z with

  match z with

  | `foo ->

  | `foo ->

    some_function

    some_function

      argument

      argument

let f = fun x ->

let f = fun x ->

  ghi

  ghi

    x

    x

(* common *)

(* common *)

let x =

let x =

  try x with

  try x with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let x = try x with

let x = try x with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let x =

let x =

  try x

  try x

  with

  with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let z =

let z =

  some_function

  some_function

    argument

    argument

let () =

let () =

  f a b ~c:c

  f a b ~c:c

    d

    d

let () =

let () =

  f a b ~c:1.

  f a b ~c:1.

    d

    d

let () =

let () =

  My_module.f a b ~c:c

  My_module.f a b ~c:c

    d

    d

(* This last case is where Tuareg is inconsistent with the others. *)

(* This last case is where Tuareg is inconsistent with the others. *)

let () =

let () =

  My_module.f a b ~c:1.

  My_module.f a b ~c:1.

    d

    d

let () =

let () =

  messages :=

  messages :=

    Message_store.create (Session_id.of_string "")

    Message_store.create (Session_id.of_string "")

      (* Tuareg indents these lines too far to the left. *)

      (* Tuareg indents these lines too far to the left. *)

      "herd-retransmitter"

      "herd-retransmitter"

      Message_store.Message_size.Byte

      Message_store.Message_size.Byte

let () =

let () =

  raise (Bug ("foo"

  raise (Bug ("foo"

              (* In this and similar cases, we want the subsequent lines to

              (* In this and similar cases, we want the subsequent lines to

                 align with the first expression. *)

                 align with the first expression. *)

              ^ "bar"));

              ^ "bar"));

  raise (Bug ("foo" ^ "quux"

  raise (Bug ("foo" ^ "quux"

              ^ "bar"));

              ^ "bar"));

  raise (Bug (foo + quux

  raise (Bug (foo + quux

              ^ "bar"));

              ^ "bar"));

  raise (Bug ((foo + quux)

  raise (Bug ((foo + quux)

              ^ "bar"))

              ^ "bar"))

(* Except in specific cases, we want the argument indented relative to the

(* Except in specific cases, we want the argument indented relative to the

   function being called.  (Exceptions include "fun" arguments where the line

   function being called.  (Exceptions include "fun" arguments where the line

   ends with "->" and subsequent lines beginning with operators, like above.) *)

   ends with "->" and subsequent lines beginning with operators, like above.) *)

let () =

let () =

  Some (Message_store.create s

  Some (Message_store.create s

          "herd-retransmitter" ~unlink:true Message_store.Message_size.Byte)

          "herd-retransmitter" ~unlink:true Message_store.Message_size.Byte)

(* We like the indentation of most arguments, but want to get back towards the

(* We like the indentation of most arguments, but want to get back towards the

   left margin in a few special cases: *)

   left margin in a few special cases: *)

let _ =

let _ =

  foo (bar (fun x ->                    (* special: "fun _ ->" at EOL *)

  foo (bar (fun x ->                    (* special: "fun _ ->" at EOL *)

    baz))                               (* assume no more arguments to "bar" *)

    baz))                               (* assume no more arguments to "bar" *)

let _ =

let _ =

  foo

  foo

    ~a_long_field_name:(check (fun bar ->

    ~a_long_field_name:(check (fun bar ->

      baz))

      baz))

let _ =

let _ =

  foo ~a_long_field_name:(check (fun bar ->

  foo ~a_long_field_name:(check (fun bar ->

    baz))

    baz))

let _ =

let _ =

  foo (bar (quux (fnord (fun x ->       (* any depth *)

  foo (bar (quux (fnord (fun x ->       (* any depth *)

    baz))))

    baz))))

(* We also wanted to tweak the operator indentation, making operators like <=

(* We also wanted to tweak the operator indentation, making operators like <=

   not special cases in contexts like this:  *)

   not special cases in contexts like this:  *)

let _ =

let _ =

  assert (foo (bar + baz

  assert (foo (bar + baz

               <= quux))                (* lined up under left argument to op,

               <= quux))                (* lined up under left argument to op,

                                           sim. to ^ above *)

                                           sim. to ^ above *)

(* Sim. indentation of if conditions: *)

(* Sim. indentation of if conditions: *)

let _ =

let _ =

  if (a

  if (a

      <= b)

      <= b)

  then ()

  then ()

let _ =

let _ =

  (* Comparisons are different than conditionals; we don't regard them as

  (* Comparisons are different than conditionals; we don't regard them as

     conceptually part of the [if] expression. *)

     conceptually part of the [if] expression. *)

  if a

  if a

     <= b

     <= b

  then ()

  then ()

let _ =

let _ =

  (* We regard the outermost condition terms as conceptually part of the [if]

  (* We regard the outermost condition terms as conceptually part of the [if]

     expression and indent accordingly.  Whether [&&] or [||], conditionals

     expression and indent accordingly.  Whether [&&] or [||], conditionals

     effectively state lists of conditions for [then]. *)

     effectively state lists of conditions for [then]. *)

  if Edge_adjustment.is_zero arb.cfg.extra_edge

  if Edge_adjustment.is_zero arb.cfg.extra_edge

  && 0. = sys.plugs.edge_backoff

  && 0. = sys.plugs.edge_backoff

  && 0. = zero_acvol_edge_backoff

  && 0. = zero_acvol_edge_backoff

  then 0.

  then 0.

  else 1.

  else 1.

let _ =

let _ =

  if

  if

    Edge_adjustment.is_zero arb.cfg.extra_edge

    Edge_adjustment.is_zero arb.cfg.extra_edge

    && 0. = sys.plugs.edge_backoff

    && 0. = sys.plugs.edge_backoff

    && 0. = zero_acvol_edge_backoff

    && 0. = zero_acvol_edge_backoff

  then 0.

  then 0.

  else 1.

  else 1.

let _ =

let _ =

  let entries = List.filter (Lazy.force transferstati) ~f:(fun ts ->

  let entries = List.filter (Lazy.force transferstati) ~f:(fun ts ->

    Pcre.pmatch ~pat ts.RQ.description

    Pcre.pmatch ~pat ts.RQ.description

  ) in

  ) in

  x

  x

(* combination of operator at BOL and -> at EOL: *)

(* combination of operator at BOL and -> at EOL: *)

let _ =

let _ =

  Shell.ssh_lines x

  Shell.ssh_lines x

  |! List.map ~f:(f (g (fun x ->

  |! List.map ~f:(f (g (fun x ->

(* open paren ending line like begin *)

(* open paren ending line like begin *)

let _ =

let _ =

  if a (p ^/ "s") [ e ] = Ok () then `S (

  if a (p ^/ "s") [ e ] = Ok () then `S (

    let label count =

    let label count =

      sprintf "%d s" c ^ if c = 1 then ":" else "s"

      sprintf "%d s" c ^ if c = 1 then ":" else "s"

    in

    in

    x

    x

  )

  )

let f = function

let f = function

  | zoo -> begin

  | zoo -> begin

      foo;

      foo;

      bar;

      bar;

    end

    end

;;

;;

let g = function

let g = function

  | zoo -> (

  | zoo -> (

      foo;

      foo;

      bar;

      bar;

    )

    )

;;

;;

let () =

let () =

  begin match foo with

  begin match foo with

  end

  end

;;

;;

(* preferred list style *)

(* preferred list style *)

let z =

let z =

  f

  f

    [ y

    [ y

    ; foo ~f:(fun () ->

    ; foo ~f:(fun () ->

        arg)

        arg)

    ]

    ]

;;

;;

let z =

let z =

  f

  f

    [ y

    [ y

    ; foo ~f:(fun () ->

    ; foo ~f:(fun () ->

        arg

        arg

      )

      )

    ]

    ]

;;

;;

(* legacy list style *)

(* legacy list style *)

let _ =

let _ =

  [ f (fun x ->

  [ f (fun x ->

      x);

      x);

    f (fun x ->

    f (fun x ->

      x);

      x);

    f (fun x ->

    f (fun x ->

      x);

      x);

  ]

  ]

let _ =

let _ =

  [ f (fun x ->

  [ f (fun x ->

      x

      x

    );

    );

    f (fun x ->

    f (fun x ->

      x

      x

    );

    );

    f (fun x ->

    f (fun x ->

      x

      x

    );

    );

  ]

  ]

;;

;;

let _ =

let _ =

  [f (fun x ->

  [f (fun x ->

     x

     x

   );

   );

   f (fun x ->

   f (fun x ->

     x

     x

   );

   );

   f (fun x ->

   f (fun x ->

     x

     x

   );

   );

  ]

  ]

;;

;;

let _ =

let _ =

  x

  x

  >>= fun x ->

  >>= fun x ->

  (try x with _ -> ())

  (try x with _ -> ())

  >>= fun x ->

  >>= fun x ->

  try x with _ -> ()

  try x with _ -> ()

    >>= fun x ->

    >>= fun x ->

    x

    x

;;

;;

let () =

let () =

  expr

  expr

  >>| function

  >>| function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  expr

  expr

  >>| fun z -> match z with

  >>| fun z -> match z with

;;

;;

let () =

let () =

  expr

  expr

  >>| fun z -> function

  >>| fun z -> function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  my_func () >>= function

  my_func () >>= function

  | A -> 0

  | A -> 0

  | B -> 0

  | B -> 0

;;

;;

let () =

let () =

  my_func () >>= (function

  my_func () >>= (function

    | A -> 0

    | A -> 0

    | B -> 0)

    | B -> 0)

;;

;;

let () =

let () =

  expr

  expr

  >>| function

  >>| function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  expr

  expr

  >>| (function

  >>| (function

    | x -> 3

    | x -> 3

    | y -> 4)

    | y -> 4)

;;

;;

let f =

let f =

  f >>= m (fun f ->

  f >>= m (fun f ->

    fun x ->

    fun x ->

      y);

      y);

  z

  z

;;

;;

let f =

let f =

  f

  f

  |> m (fun f ->

  |> m (fun f ->

    fun x ->

    fun x ->

      y

      y

  );

  );

  z

  z

;;

;;

let f =

let f =

  f

  f

  |> m (fun f ->

  |> m (fun f ->

    fun x ->

    fun x ->

      y);

      y);

  z

  z

;;

;;

module M =

module M =

  Foo (G)

  Foo (G)

    (H)

    (H)

module M =

module M =

  Foo

  Foo

    (G)

    (G)

    (struct

    (struct

      let x

      let x

    end)

    end)

    (H)

    (H)

(* To me, this looks fine as it is.  The rule seems fine as "indent arguments by

(* To me, this looks fine as it is.  The rule seems fine as "indent arguments by

   2".  To illustrate, with a case where the functor name is longer: *)

   2".  To illustrate, with a case where the functor name is longer: *)

module M =

module M =

  Functor (G)

  Functor (G)

    (H)

    (H)

    (I)

    (I)

include Foo (struct

include Foo (struct

    let x

    let x

  end) (struct

  end) (struct

    let y

    let y

  end)

  end)

include

include

  Foo (struct

  Foo (struct

include

include

  Foo

  Foo

    (struct

    (struct

      let x

      let x

    end) (struct

    end) (struct

include Persistent.Make

include Persistent.Make

include Persistent.Make

include Persistent.Make

include

include

  Persistent.Make

  Persistent.Make

    (struct let version = 1 end)

    (struct let version = 1 end)

    (Stable.Cr_soons_or_pending.V1)

    (Stable.Cr_soons_or_pending.V1)

include

include

  Persistent.Make

  Persistent.Make

    (struct

    (struct

      let version = 1

      let version = 1

    end)

    end)

    (Stable.Cr_soons_or_pending.V1)

    (Stable.Cr_soons_or_pending.V1)

module M =

module M =

  Foo (struct

  Foo (struct

module M : S =

module M : S =

  Make (M)

  Make (M)

module M : S with type t := int =

module M : S with type t := int =

  Make (M)

  Make (M)

module Simple_command(Arg:sig

module Simple_command(Arg:sig

  end) = struct end

  end) = struct end

module Simple_command(Arg : sig

module Simple_command(Arg : sig

  end) = struct end

  end) = struct end

module Simple_command (Arg:sig

module Simple_command (Arg:sig

  end) = struct end

  end) = struct end

module Simple_command (Arg : sig

module Simple_command (Arg : sig

  end) = struct end

  end) = struct end

module Simple_command

module Simple_command

let f = function

let f = function

  | _ -> 0

  | _ -> 0

;;

;;

let f x = match x with

let f x = match x with

;;

;;

let f =

let f =

  function

  function

  | _ -> 0

  | _ -> 0

;;

;;

let f x =

let f x =

  match x with

  match x with

  | _ -> 0

  | _ -> 0

;;

;;

let f x =

let f x =

  begin match x with

  begin match x with

  end

  end

;;

;;

let check_price t = function

let check_price t = function

  | { Exec.

  | { Exec.

      trade_at_settlement = (None | Some false);

      trade_at_settlement = (None | Some false);

    } -> ()

    } -> ()

let check_price t = function

let check_price t = function

  | simpler -> ()

  | simpler -> ()

  | other -> ()

  | other -> ()

(* Sometimes we like to write big alternations like this, in which case the

(* Sometimes we like to write big alternations like this, in which case the

   comment should typically align with the following clause. *)

   comment should typically align with the following clause. *)

let 0 =

let 0 =

  match x with

  match x with

  | A

  | A

    (* a *)

    (* a *)

    -> a

    -> a

let 0 =

let 0 =

  match x with

  match x with

    A

    A

    (* a *)

    (* a *)

    -> a

    -> a

let _ =

let _ =

  a

  a

  || match a with

  || match a with

type x =

type x =

  { foo : int

  { foo : int

  ; bar : int

  ; bar : int

  }

  }

let x =

let x =

  { x with

  { x with

    foo = 3

    foo = 3

  ; bar = 5

  ; bar = 5

  }

  }

let x =

let x =

  { (* blah blah blah *)

  { (* blah blah blah *)

    foo = 3

    foo = 3

  ; bar = 5

  ; bar = 5

  }

  }

;;

;;

let x =

let x =

  [{ x with

  [{ x with

     foo = 3

     foo = 3

   ; bar = 5

   ; bar = 5

   }]

   }]

let x =

let x =

  [{ (* blah blah blah *)

  [{ (* blah blah blah *)

;;

;;

let x =

let x =

  { M.x with

  { M.x with

    M.

    M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let x =

let x =

  { x with

  { x with

    M.

    M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let x =

let x =

  { M.

  { M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let _ =

let _ =

  { foo with

  { foo with

    Bar.

    Bar.

    field1 = value1

    field1 = value1

  ; field2 = value2

  ; field2 = value2

  }

  }

;;

;;

let _ =

let _ =

  { foo

  { foo

    with Bar.

    with Bar.

  }

  }

;;

;;

(* multicomponent record module pathname *)

(* multicomponent record module pathname *)

let _ =

let _ =

  { A.B.

  { A.B.

    a = b

    a = b

  ; c = d

  ; c = d

  }

  }

;;

;;

type t =

type t =

  { a

  { a

    : something_lengthy list list

    : something_lengthy list list

        [@default String.Map.empty]

        [@default String.Map.empty]

  }

  }

type t =

type t =

  { a

  { a

    : Something_lengthy.t list list

    : Something_lengthy.t list list

        [@default String.Map.empty]

        [@default String.Map.empty]

  }

  }

type t =

type t =

  { a

  { a

    : something_lengthy list

    : something_lengthy list

        list

        list

  }

  }

type t =

type t =

  { a

  { a

    : Something_lengthy.t list

    : Something_lengthy.t list

        list

        list

  }

  }

type t =

type t =

  { a

  { a

    : Something_lengthy.t

    : Something_lengthy.t

        list

        list

  }

  }

(* s *)

(* s *)

let _ =

let _ =

  [%raise_structural_sexp

  [%raise_structural_sexp

    "feature's tip is already an ancestor of new base"

    "feature's tip is already an ancestor of new base"

let _ =

let _ =

  [%raise_structural_sexp "feature's tip is already an ancestor of new base"

  [%raise_structural_sexp "feature's tip is already an ancestor of new base"

  ]

  ]

(* Indentation that Jane Street needs to think about and make precise.

(* Indentation that Jane Street needs to think about and make precise.

   These are long term ideas, possibly even conflicting with other tests. *)

   These are long term ideas, possibly even conflicting with other tests. *)

(* js-args *)

(* js-args *)

let _ =

let _ =

  let min_closing_backoff =

  let min_closing_backoff =

    -. (   Hidden_float.expose (arb.cfg.base_edge @! Buy)

    -. (   Hidden_float.expose (arb.cfg.base_edge @! Buy)

  in

  in

  0

  0

(* js-type *)

(* js-type *)

(* The following tests incorporate several subtle and different indentation

(* The following tests incorporate several subtle and different indentation

   ideas.  Please consider this only a proposal for discussion, for now.

   ideas.  Please consider this only a proposal for discussion, for now.

   First, notice the display treatment of "(,)" tuples, analogous to "[;]"

   First, notice the display treatment of "(,)" tuples, analogous to "[;]"

   lists.  While "(,)" is an intensional combination of "()" and ",", unlike

   lists.  While "(,)" is an intensional combination of "()" and ",", unlike

   "[;]" lists, we believe "(,)" isn't too big a departure.  Value expression

   "[;]" lists, we believe "(,)" isn't too big a departure.  Value expression

   analogies are included in js-type.ml, (meant to be) consistent with the

   analogies are included in js-type.ml, (meant to be) consistent with the

   proposed type indentation.

   proposed type indentation.

   Second, and more divergently, the proposed indentation of function types is

   Second, and more divergently, the proposed indentation of function types is

   based on the idea of aligning the arguments, even the first argument, even

   based on the idea of aligning the arguments, even the first argument, even

   where that means automatically inserting spaces within lines.  This applies

   where that means automatically inserting spaces within lines.  This applies

   to the extra spaces in ":__unit" and "(____Config.Network.t" below.

   to the extra spaces in ":__unit" and "(____Config.Network.t" below.

   We believe this fits into a more general incorporation of alignment into

   We believe this fits into a more general incorporation of alignment into

   ocp-indent, to replace our internal alignment tool with a syntax-aware one.

   ocp-indent, to replace our internal alignment tool with a syntax-aware one.

   We like to align things for readability, like big records, record types,

   We like to align things for readability, like big records, record types,

   lists used to build tables, etc.

   lists used to build tables, etc.

   The proposal also includes indenting "->" in the circumstances below relative

   The proposal also includes indenting "->" in the circumstances below relative

   to the enclosing "()", by two spaces.  In a sense, this happens first, and

   to the enclosing "()", by two spaces.  In a sense, this happens first, and

   then the first argument is aligned accordingly.  So, there's no manual

   then the first argument is aligned accordingly.  So, there's no manual

   indentation or spacing below. *)

   indentation or spacing below. *)

val instances

val instances

  :  unit

  :  unit

  -> (    Config.Network.t

  -> (    Config.Network.t

     , 'm

     , 'm

     ) Command.Spec.t

     ) Command.Spec.t

val instances

val instances

  :  unit

  :  unit

  -> (    Config.Network.t

  -> (    Config.Network.t

     , 'm

     , 'm

     ) Command.Spec.t

     ) Command.Spec.t

(* presumed analog with stars *)

(* presumed analog with stars *)

val instances :

val instances :

  unit

  unit

  * (   Config.Network.t

  * (   Config.Network.t

    , 'm

    , 'm

    ) Command.Spec.t

    ) Command.Spec.t

let f x =

let f x =

  stop

  stop

  (* We don't do this as a matter of style, but the indentation reveals a common

  (* We don't do this as a matter of style, but the indentation reveals a common

     mistake. *)

     mistake. *)

  >>> fun () -> don't_wait_for (close fd);

  >>> fun () -> don't_wait_for (close fd);

let f x =

let f x =

  stop

  stop

  (* This is what was intended, which is indented correctly, although it's bad

  (* This is what was intended, which is indented correctly, although it's bad

     style on my part. *)

     style on my part. *)

  >>> (fun () -> don't_wait_for (close fd));

  >>> (fun () -> don't_wait_for (close fd));

  bind

  bind

let f x =

let f x =

  (fun x -> x [ (fun () -> 3) ;

  (fun x -> x [ (fun () -> 3) ;

                (fun () -> 4) ])

                (fun () -> 4) ])

let f x = (fun x -> x [ (fun () -> 3) ;

let f x = (fun x -> x [ (fun () -> 3) ;

                        (fun () -> 4) ])

                        (fun () -> 4) ])

let f x =

let f x =

  x [ (fun () -> 3) ;

  x [ (fun () -> 3) ;

      (fun () -> 4) ]

      (fun () -> 4) ]

let f x =

let f x =

  [ (fun () -> 3) ;

  [ (fun () -> 3) ;

    (fun () -> 4) ]

    (fun () -> 4) ]

let f x =

let f x =

  (fun x -> x [ (fun () ->

  (fun x -> x [ (fun () ->

let f x = (fun x -> x [ (fun () ->

let f x = (fun x -> x [ (fun () ->

let f x =

let f x =

  x [ (fun () ->

  x [ (fun () ->

      (fun () -> 4) ]

      (fun () -> 4) ]

let f x =

let f x =

  [ (fun () ->

  [ (fun () ->

    (fun () -> 4) ]

    (fun () -> 4) ]

(** ocaml classes

(** ocaml classes

    (http://caml.inria.fr/pub/docs/manual-ocaml/manual017.html)

    (http://caml.inria.fr/pub/docs/manual-ocaml/manual017.html)

*)

*)

(* class types *)

(* class types *)

class type c =

class type c =

  object

  object

  end

  end

class type c =

class type c =

  M.cl

  M.cl

class type c =

class type c =

  ['a, 'b] M.cl

  ['a, 'b] M.cl

class type c =

class type c =

  object

  object

    ('ty)

    ('ty)

    inherit cl

    inherit cl

    val mutable virtual

    val mutable virtual

      var : bool

      var : bool

    method private bar1 x ~y : bool

    method private bar1 x ~y : bool

    method private virtual bar2 : 'a 'b.('a,'b) Hashtbl.t

    method private virtual bar2 : 'a 'b.('a,'b) Hashtbl.t

    constraint

    constraint

      'a = 'b

      'a = 'b

  end

  end

(* class expressions *)

(* class expressions *)

class c =

class c =

  ['a, 'b]

  ['a, 'b]

    M.cl

    M.cl

class c =

class c =

  fun a b ->

  fun a b ->

class c = object

class c = object

  val x = true

  val x = true

end

end

class c =

class c =

  object

  object

    (_ :

    (_ :

       'a)

       'a)

    inherit Something.someclass

    inherit Something.someclass

      as v

      as v

    val mutable

    val mutable

      var : bool

      var : bool

      = true

      = true

    val mutable virtual var2

    val mutable virtual var2

      : string

      : string

    method private bar1 x ~y : bool =

    method private bar1 x ~y : bool =

      false

      false

    method private virtual bar2 : 'a 'b.('a,'b) Hashtbl.t

    method private virtual bar2 : 'a 'b.('a,'b) Hashtbl.t

    constraint

    constraint

      'a = 'b

      'a = 'b

    initializer

    initializer

      z

      z

  end

  end

(* method specific expressions *)

(* method specific expressions *)

let e =

let e =

  var <- true

  var <- true

let e =

let e =

  {< var = false;

  {< var = false;

     var2 = true;

     var2 = true;

  >}

  >}

(* class definitions *)

(* class definitions *)

class cl =

class cl =

  object

  object

    val x = true

    val x = true

  end

  end

and

and

  virtual ['a, 'b]

  virtual ['a, 'b]

    cl2 x y :

    cl2 x y :

  object

  object

    val x : bool

    val x : bool

  end = fun x y ->

  end = fun x y ->

  object

  object

    val x : bool = true

    val x : bool = true

  end

  end

class cl

class cl

  : object end

  : object end

class type virtual ['a] clty = object

class type virtual ['a] clty = object

  method x : int

  method x : int

end

end

(* objects *)

(* objects *)

val a :

val a :

  < >

  < >

let () = ()

let () = ()

val a :

val a :

  < .. >

  < .. >

let () = ()

let () = ()

val a :

val a :

  < meth: int option;

  < meth: int option;

    meth2: 'a. 'a option;

    meth2: 'a. 'a option;

    meth3: 'a 'b. ('a,'b) Hashtbl.t >

    meth3: 'a 'b. ('a,'b) Hashtbl.t >

let () = ()

let () = ()

val a :

val a :

  < meth: int option;

  < meth: int option;

    meth2: 'a. 'a option;

    meth2: 'a. 'a option;

    meth3: 'a 'b. ('a,'b) Hashtbl.t;

    meth3: 'a 'b. ('a,'b) Hashtbl.t;

    .. >

    .. >

let () = ()

let () = ()

(* #-types *)

(* #-types *)

val a :

val a :

  #M.meth

  #M.meth

val a :

val a :

  'a#M.meth

  'a#M.meth

val a :

val a :

  ('a,'b*'c)

  ('a,'b*'c)

  #M.meth

  #M.meth

(* object types *)

(* object types *)

type a =

type a =

  < >

  < >

let () = ()

let () = ()

type a =

type a =

  < .. >

  < .. >

let () = ()

let () = ()

type a =

type a =

  < meth: int option;

  < meth: int option;

    meth2: 'a. 'a option;

    meth2: 'a. 'a option;

    meth3: 'a 'b. ('a,'b) Hashtbl.t >

    meth3: 'a 'b. ('a,'b) Hashtbl.t >

let () = ()

let () = ()

type a =

type a =

  < meth: int option;

  < meth: int option;

    meth2: 'a. 'a option;

    meth2: 'a. 'a option;

    meth3: 'a 'b. ('a,'b) Hashtbl.t;

    meth3: 'a 'b. ('a,'b) Hashtbl.t;

    .. >

    .. >

let () = ()

let () = ()

type t =

type t =

  < a : int; b:

  < a : int; b:

      < a: int; b: < c:int > >

      < a: int; b: < c:int > >

  >

  >

let () = ()

let () = ()

type t =

type t =

  < a : int; b:

  < a : int; b:

      < a: int; b: < c: int -> int> >;

      < a: int; b: < c: int -> int> >;

    c: int

    c: int

  >

  >

let () = ()

let () = ()

type 'a t =

type 'a t =

  | Bla : < x : int > t

  | Bla : < x : int > t

  | Blo : < y : int > t

  | Blo : < y : int > t