[Caml-list] pattern matching on mapped lists

[Caml-list] pattern matching on mapped lists

[Nils Becker]

I find this syntax handy

    let [ii; jj] = List.map float_of_int [i; j] in
    ... do stuff with the floats

because it avoids repeating the function call. The compiler lets this
pass but warns that the matching is not exhaustive since [] is not
matched. This actually can't happen if I'm not mistaken. So, is this
considered good style, or is there a better idiomatic way to do multiple
assignments? If yes, should this be an enhancement request for the type
checker?

n.

Re: [Caml-list] pattern matching on mapped lists

[Romain Bardou]

On 03/06/2015 00:23, Nils Becker wrote:
> I find this syntax handy
>
>      let [ii; jj] = List.map float_of_int [i; j] in
>      ... do stuff with the floats
>
> because it avoids repeating the function call. The compiler lets this
> pass but warns that the matching is not exhaustive since [] is not
> matched. This actually can't happen if I'm not mistaken. So, is this
> considered good style, or is there a better idiomatic way to do multiple
> assignments? If yes, should this be an enhancement request for the type
> checker?
>
> n.

The type-checker cannot find out that List.map returns a list of the 
same size. I think it would require dependent types. Maybe some GADT can 
encode this, but it would be a bit messy.

If you use this idiom often, maybe you should define some map functions 
on tuples, whose length is known at compile-time:

let map2 f (x, y) = f x, f y

let (ii, jj) = map2 float_of_int (i, j) in
...

Unfortunately you need to define map2, map3, map4...

Cheers,

-- 
Romain

Re: [Caml-list] pattern matching on mapped lists

[John Whitington]

Hi Nils,

Nils Becker wrote:
> I find this syntax handy
>
>      let [ii; jj] = List.map float_of_int [i; j] in
>      ... do stuff with the floats
>
> because it avoids repeating the function call. The compiler lets this
> pass but warns that the matching is not exhaustive since [] is not
> matched. This actually can't happen if I'm not mistaken. So, is this
> considered good style, or is there a better idiomatic way to do multiple
> assignments? If yes, should this be an enhancement request for the type
> checker?

If the lengths are almost always small, why not just put appropriate 
functions map_pair, map_tuple3, map_tuple4 etc. into your library?

fun map_tuple3 f (x, y, z) = (f x, f y, f z)

let (ii, jj) = map_pair float_of_int (i, j)

Or, even...

let ii, jj = map_pair float (i, j)

...if you really want to save typing.

John

-- 
John Whitington
Director, Coherent Graphics Ltd
http://www.coherentpdf.com/

Re: [Caml-list] pattern matching on mapped lists

[Mikhail Mandrykin]

On 06/03/2015 07:52 PM, Romain Bardou wrote:
> On 03/06/2015 00:23, Nils Becker wrote:
>> I find this syntax handy
>>
>>      let [ii; jj] = List.map float_of_int [i; j] in
>>      ... do stuff with the floats
>>
>> because it avoids repeating the function call. The compiler lets this
>> pass but warns that the matching is not exhaustive since [] is not
>> matched. This actually can't happen if I'm not mistaken. So, is this
>> considered good style, or is there a better idiomatic way to do multiple
>> assignments? If yes, should this be an enhancement request for the type
>> checker?
>>
>> n.
>
> The type-checker cannot find out that List.map returns a list of the 
> same size. I think it would require dependent types. Maybe some GADT 
> can encode this, but it would be a bit messy.
>
> If you use this idiom often, maybe you should define some map 
> functions on tuples, whose length is known at compile-time:
>
> let map2 f (x, y) = f x, f y
>
> let (ii, jj) = map2 float_of_int (i, j) in
> ...
>
> Unfortunately you need to define map2, map3, map4...
>
> Cheers,
>
It seems GADT encoding mostly works here, but the absence of local opens 
in patterns and redefinition of [] constructor and [_; _] special syntax 
for lists currently makes the use of such encoding inconvenient e.g.:

module Flist =
struct

   type z = Z

   type 'a s = S of 'a

   type ('a, _) t =
     | Nil : ('a, z) t
     | :: : 'a * ('a, 'b) t ->  ('a, 'b s) t

     let rec map : type a. _ -> (_, a) t -> (_, a) t = fun f ->
        function
        | Nil ->   Nil
        | x :: xs -> f x :: map f xs
end

open Flist

let a :: b :: c :: Nil = map ((+) 2) @@ 1 :: 2 ::  3 :: Nil;;  (* Can't 
use Flist.[a; b; c] on both sides *)

let d :: e :: Nil = map ((^) "2 + ") @@ "1" :: "2" :: Nil;;

let g :: Nil = map ((+) 2) @@ 1 :: Nil;;

Printf.printf "%d = %s = %d\n%!" a d g;;

BTW, both features are already proposed as feature requests:
https://github.com/ocaml/ocaml/pull/187
https://github.com/ocaml/ocaml/pull/76

Regards, Mikhail


-- 
Mikhail Mandrykin
Linux Verification Center, ISPRAS
web: http://linuxtesting.org
e-mail: mandrykin@ispras.ru

Re: [Caml-list] pattern matching on mapped lists

[Octachron]

On 06/03/15 19:42, Mikhail Mandrykin wrote:
> It seems GADT encoding mostly works here, but the absence of local 
> opens in patterns and redefinition of [] constructor and [_; _] 
> special syntax for lists currently makes the use of such encoding 
> inconvenient e.g.:
>
> module Flist =
> struct
>
>   type z = Z
>
>   type 'a s = S of 'a
>
>   type ('a, _) t =
>     | Nil : ('a, z) t
>     | :: : 'a * ('a, 'b) t ->  ('a, 'b s) t
>
>     let rec map : type a. _ -> (_, a) t -> (_, a) t = fun f ->
>        function
>        | Nil ->   Nil
>        | x :: xs -> f x :: map f xs
> end
>
> open Flist
>
> let a :: b :: c :: Nil = map ((+) 2) @@ 1 :: 2 ::  3 :: Nil;;  (* 
> Can't use Flist.[a; b; c] on both sides *)
>
> let d :: e :: Nil = map ((^) "2 + ") @@ "1" :: "2" :: Nil;;
>
> let g :: Nil = map ((+) 2) @@ 1 :: Nil;;
>
> Printf.printf "%d = %s = %d\n%!" a d g;;
>
> BTW, both features are already proposed as feature requests:
> https://github.com/ocaml/ocaml/pull/187
> https://github.com/ocaml/ocaml/pull/76
>
> Regards, Mikhail
>

A possibility to lighten these constructions is to use a ppx extension 
to rewrite
the special syntax [a;...] into a standard Cons(a,... Nil)...) 
construction. For instance with my experimental ppx_listlike extension 
(https://github.com/Octachron/ppx_listlike), these examples can be 
rewritten as

     let [%ll? [a; b; c] ] = map ((+) 2) [%ll 1; 2; 3 ];;

or with more syntactic sugar

     let%with_ll [ d; e ] = map ((^) "2 + ") ["1"; "2" ];;
     let%with_ll [g] = map ((+) 2) [1];;

Regards,
octachron.