Re: [Caml-list] A syntax extension to simplify List manipulation

[blue storm <bluestorm.dylc@gmail.com>]

[-- Attachment #1.1: Type: text/plain, Size: 1693 bytes --]

On Mon, Jan 25, 2010 at 10:45 PM, Alexander Voinov <avoinov@gmail.com>wrote:

> I've updated this extension to remove the dependency on ExtLib (as
> suggested
> previously). The price is that iteratei is not available with the core List
> module.
>
> If you do need iteratei, first uncomment the
>
> # WITH_ITERATEI = 1
>
> line in the Makefile (and do a fresh build), and, second, always
>
> open ExtLib;;
>

I think you should keep iteratei by default : if the user use an
insufficient List module, he will get a classical "unbound value
List.iteratei" error from the compiler, and will easily relate it to the
code using your extension (as the "iteratei" name is apparent).
If you document that point, it could be much easier than a compile-time
option that requires one to edit the Makefile. If you really want an option
to disallow iteratei syntaxically, you could use command-line options to
make that choice at runtime (that would be more flexible).
I don't know how well camlp5 handle command-line parameters, so I can't help
you there.


Regarding camlp4, I don't remember why this extension didn't work with it
> after that big refactoring, which gave birth to camlp5. I'm making a TODO
> for myself to take a look at this.
>

In case you're interested, attached is a short camlp4 (>= 3.10) port of your
extension (wich wasn't thoroughly tested). As you can see, changes are
minimal. This is just in case, I don't have any opinion on what preprocessor
you should use.


> The tarball is: http://www.voinov.org/FP/spbSyntax-1.0.1.tgz
>
> (and also http://www.voinov.org/FP/spbSyntax.tgz)
>
>
PS : the software license is the zlib/png license. Maybe you should mention
it explicitely.

[-- Attachment #1.2: Type: text/html, Size: 2551 bytes --]

[-- Attachment #2: spbSyntax_camlp4.ml --]
[-- Type: application/octet-stream, Size: 2533 bytes --]

(* This is a camlp4 port (from camlp5) of Alexander Voinov's "simplify
   List manipulation" syntax extension. Source changes were minimal.

   See below for the original copyright notice.

   Compilation command used :
     ocamlfind ocamlc -syntax camlp4o -package camlp4.extend,camlp4.quotations -c spbSyntax_camlp4.ml
*)

(*
 * Copyright (c) 2003-2010 Alexander Voinov

 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.

 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:

 * 1. The origin of this software must not be misrepresented; you must
 * not claim that you wrote the original software. If you use this
 * software in a product, an acknowledgment in the product documentation
 * would be appreciated but is not required.

 * 2. Altered source versions must be plainly marked as such, and must
 * not be misrepresented as being the original software.

 * 3. This notice may not be removed or altered from any source
 * distribution.
 * (The text of this license is borrowed from one found in ocamlnet-2.2.9)
 *)

open Camlp4
open PreCast
open Syntax

EXTEND Gram
  GLOBAL: expr;

  expr: 
    LEVEL "top" [ [ "map"; list = expr; "with"; OPT "|"; clauses = LIST1 match_case SEP "|" ->
	  <:expr< List.map (fun [ $list:clauses$ ]) $list$ >> ]

    | [ "filtermap"; list = expr; "with"; OPT "|"; clauses = LIST1 match_case SEP "|" ->
	  <:expr< List.filter_map (fun [ $list:clauses$ ]) $list$ >> ]

    | [ "iterate"; list = expr; "with"; OPT "|"; clauses = LIST1 match_case SEP "|"; "done" ->
	  <:expr< List.iter (fun [ $list:clauses$ ]) $list$ >> ]
	
    | [ "iteratei"; list = expr; "with"; OPT "|"; clauses = LIST1 match_case SEP "|"; "done" ->
	  <:expr< List.iteri (fun n h -> match (n, h) with [ $list:clauses$ ]) $list$ >> ]

    | [ "foldr"; list = expr; "from"; initval = expr; "with"; OPT "|"; 
	clauses = LIST1 match_case SEP "|" ->
	  <:expr< List.fold_right (fun a b -> 
				     match (a, b) with [ $list:clauses$ ]) 
	                           $list$ $initval$ >> ]

    | [ "foldl"; list = expr; "from"; initval = expr; "with"; OPT "|"; 
	clauses = LIST1 match_case SEP "|" ->
	  <:expr< List.fold_left (fun a b -> 
				     match (a, b) with [ $list:clauses$ ]) 
	                           $initval$ $list$ >> ]
    ];
END