Re: [Caml-list] destructive local opens

[Erkki Seppala <flux-caml@inside.org>]

Hi,

Couple points I felt the need to address :).

Yotam Barnoy <yotambarnoy@gmail.com> writes:

> A lot of great ideas here. I want to comment on many of them, so
> please bear with me while I summarize some of the points in the
> process. Hopefully this will also help anybody new to the discussion,
> which has become extremely long.
>
> - Local opens are somewhat of an anti-pattern in OCaml, because they're
> usually used in places where you have the same names defined in
> multiple modules:

While this is certainly a very popular use case in particular when
dealing with operators, I find myself using the local 'let open' form
very often in other contexts. In fact, I don't ever seem to find myself
using it for redefining identifiers. Examples I grepped from my sources,
admittedly some obsoleted by the new disambiguation feature:

2014/device-table/layout.ml:
  let open Containers_misc.PrintBox in
  hlist ~bars:false [box; text (String.make n ' ')]

2014/TinyGUploader/src/upload.ml:
  let open Gcode.Parser in
  match input with
  | Move { move_reg = (G0 | G1); move_pos = at } -> ..

2014/TinyGUploader/src/upload.ml:
  let open ANSITerminal in
  let progress = float n /. float input_nlines in
  move_bol ();
  let time_left = (Unix.gettimeofday () -. t0) /. progress in
  let time_finished = t0 +. time_left in
  if not common_options.co_verbose then (
    printf [Bold; green; on_default] "%2.1f%%" (100.0 *. progress);
    printf [default] "complete, %d/%d, ETA " n input_nlines;
    printf [Bold; green; on_default] "%s (%s)"
           (Utils.human_eta (int_of_float time_left))
           (Utils.string_of_time time_finished);
    erase Eol;
  )

2014/TinyGUploader/src/align.ml:
let render_gcode cairo mapping_matrix gcode =
  let open Cairo in
  set_line_width cairo (length_in_matrix mapping_matrix 3.0);
  set_line_cap cairo ROUND;
  set_line_join cairo JOIN_ROUND;
  ..

2014/TinyGUploader/src/align.ml:
  let open Bigarray in
  let open Array1 in
  let ba = create int8_unsigned c_layout (String.length str) in
  for c = 0 to String.length str - 1 do
    ba.{c} <- Char.code str.[c]
  done;
  ba

Many of these would be more verbose without using a local open, the only
non-verbose alternate being opening the modules for the whole remaining
module. Using the local open gives the person reading the code a heavy
hint that this code will be dealing a lot with the concepts of that
module.

> The problem is, if you ever change one of the modules to include
> another function that wasn't expected originally (for example, N now
> includes *), you now have subtle bugs breaking your code in completely
> separate files from the ones you were editing, and the type system
> can't necessarily do anything to catch these errors.

I think this is an instance where theory and practice don't match: in
practice, I don't ever remember having witnessed such a bug.

> - Similar languages to OCaml (such as Haskell) outlaw having the same
> name defined twice in the same scope. OCaml only issues a warning.
> IMO, this warning should be turned into an error.

I don't think these is such a warning in general. I referred to
http://caml.inria.fr/pub/docs/manual-ocaml/comp.html . Do you mean only
definitions, not expression scopes?

I in fact find it quite convenient to be able to write:

let furbulation = acquire_value () in
let furbulation, brightness = process_step_1 furbulation in 
let furbulation, volume = process_step_2 (brightness / 2) furbulation in
..

The alternative of renaming intermediate steps can result in mistakes if
the order of steps is to be changed, as can happen when doing signal
processing algorithms in an explorative fashion.

Cheers,
-- 
  _____________________________________________________________________
     / __// /__ ____  __               http://www.modeemi.fi/~flux/\   \
    / /_ / // // /\ \/ /                                            \  /
   /_/  /_/ \___/ /_/\_\@modeemi.fi                                  \/