[Caml-list] Q: Correct locations for macro camlp4 extensions

[Caml-list] Q: Correct locations for macro camlp4 extensions

[Jan Kybic]

Hello,
        I quite like some of the OCaml syntax extensions implemented
with campl4 that I gathered so far, for example:

    pa_macroe.ml (enhanced macros, IFDEF, etc.)

    "where" keyword (enabling you to write 'let x = f 3 where f = ...')

    operator composition (like "$" in Haskell)

    "repeat"/"until" loop

    "for" loop (like in C), as in "for c 0 (c<10) (c+2) do"

They come from Caml Hump, camlp4 tutorial, Usenet articles and WWW
searches. The problem with them is that the line numbers are lost, 
which is a problem for error and assert messages, I get thinks like
Assert_failure("patch.ml", 1, 4798) instead of correct 
Assert_failure("patch.ml", 155, 4)

I am not a camlp4 expert, so I would like to ask if there versions of
the above mentioned extensions that make caml (3.07) generate correct
line numbers. Has the problem been discussed, is there any workaround?

Thank you very much for all pointers,

Jan

-- 
-------------------------------------------------------------------------
Jan Kybic <kybic@ieee.org>                  tel. +420 2 2435 7264
       or <kybic@fel.cvut.cz>,     http://cmp.felk.cvut.cz/~kybic

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[skaller]

On Mon, 2004-08-23 at 19:33, Jan Kybic wrote:
> The problem with them is that the line numbers are lost, 
> which is a problem for error and assert messages, I get thinks like
> Assert_failure("patch.ml", 1, 4798) instead of correct 
> Assert_failure("patch.ml", 155, 4)

Use Ocaml 3.08. From change list on web site:

Camlp4:
* Support for new-style locations (line numbers, not just character numbers).


-- 
John Skaller, mailto:skaller@users.sf.net
voice: 061-2-9660-0850, 
snail: PO BOX 401 Glebe NSW 2037 Australia
Checkout the Felix programming language http://felix.sf.net



-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[Michael Alexander Hamburg]

Which Haskell operator features does this emulate?  I know you can make an 
operator without any camlp4 that does right-associative application, basically 
let (@@) f x = f x.  Does this do it with less overhead? Or does it enable 
expressions like (/ 5) or (+ 3) as in Haskell (that would be cool...)?

Mike

Quoting Jan Kybic <kybic@fel.cvut.cz>:

> Hello,
>         I quite like some of the OCaml syntax extensions implemented
> with campl4 that I gathered so far, for example:
...
>     operator composition (like "$" in Haskell)
... 
> Jan
> 
> -- 
> -------------------------------------------------------------------------
> Jan Kybic <kybic@ieee.org>                  tel. +420 2 2435 7264
>        or <kybic@fel.cvut.cz>,     http://cmp.felk.cvut.cz/~kybic
> 




-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[Richard Jones]

On Mon, Aug 23, 2004 at 01:21:25PM -0400, Michael Alexander Hamburg wrote:
> [...] Or does it enable 
> expressions like (/ 5) or (+ 3) as in Haskell (that would be cool...)?

You mean like:

# let f = ((/) 5);;
val f : int -> int = <fun>
# f 1;;
- : int = 5

and similarly ((+) 3)?  Or do these expressions do something more
profound that I can't now recall? -- It's been a good 10 years since I
did any serious Haskell.

Rich.

-- 
Richard Jones. http://www.annexia.org/ http://www.j-london.com/
Merjis Ltd. http://www.merjis.com/ - improving website return on investment
http://www.winwinsales.co.uk/ - CRM improvement consultancy

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[David Brown]

On Mon, Aug 23, 2004 at 07:29:36PM +0100, Richard Jones wrote:

> and similarly ((+) 3)?  Or do these expressions do something more
> profound that I can't now recall? -- It's been a good 10 years since I
> did any serious Haskell.

Haskell also allows (3 +), or more usefully (256 /)

Dave

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[skaller]

On Tue, 2004-08-24 at 06:33, David Brown wrote:
> On Mon, Aug 23, 2004 at 07:29:36PM +0100, Richard Jones wrote:
> 
> > and similarly ((+) 3)?  Or do these expressions do something more
> > profound that I can't now recall? -- It's been a good 10 years since I
> > did any serious Haskell.
> 
> Haskell also allows (3 +), or more usefully (256 /)

And ocaml is even more powerful, allowing you to curry
ANY subset of arguments -- provided you label them.

-- 
John Skaller, mailto:skaller@users.sf.net
voice: 061-2-9660-0850, 
snail: PO BOX 401 Glebe NSW 2037 Australia
Checkout the Felix programming language http://felix.sf.net



-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[Michael Alexander Hamburg]

On Mon, 23 Aug 2004, Richard Jones wrote:

> On Mon, Aug 23, 2004 at 01:21:25PM -0400, Michael Alexander Hamburg wrote:
> > [...] Or does it enable
> > expressions like (/ 5) or (+ 3) as in Haskell (that would be cool...)?
>
> You mean like:
>
> # let f = ((/) 5);;
> val f : int -> int = <fun>
> # f 1;;
> - : int = 5
>
> and similarly ((+) 3)?  Or do these expressions do something more
> profound that I can't now recall? -- It's been a good 10 years since I
> did any serious Haskell.

Actually, this sort of proves my point.  (/ 5) divides its argument by 5
in Haskell, which is what I at least would expect such an expression to
do. On the other hand, ((/) 5) divides 5 by its argument, because the
first argument to an operator goes on the left, not the right.  To write
the equivalent of (/ 5), you have to write (fun x -> x/5).  More important
than tripling the number of characters is that non-commutative operators
make the ((op) foo) notation confusing.

If I ever come to understand camlp4, and a module to enable this syntax
isn't there, I'll try to add it, because I find it handy in Haskell.
Another syntax construction that I might write up (which I'm not aware of
in any programming language) would be something like

(f _ x _ _ y) translates into (fun p1 p2 p3 -> f p1 x p2 p3 y)

I don't think that the use of _ can be ambiguous in an expression like
this... any counterexamples?

>From my knowledge of Camlp4, this seems like it would be a lot more
difficult than the Haskell operator currying.

> Rich.
>
> --
> Richard Jones. http://www.annexia.org/ http://www.j-london.com/
> Merjis Ltd. http://www.merjis.com/ - improving website return on investment
> http://www.winwinsales.co.uk/ - CRM improvement consultancy

Regards,

Mike

P.S.
Lest you think I've gone compactness-crazy, I've been doing a fair amount
of symbolic and functional manipulation in O'Caml, and compressed notation
for functions helps me a lot.  When I have n lists of pairs to sort by the
first element of the tuple, or some other function like that, it saves me
a significant amount of programming effort to write

# let (<-<<) f g a b = f (g a) (g b);;
or
# let sort_by g a b = sort (compare (g a) (g b));;

so that I can write

# sort (compare <-<< fst) l;;
or
# sort_by fst l

instead of

# sort (fun a b -> compare (fst a) (fst b)) l;;

I know that the last form is probaly faster at runtime than the first
ones, but my programs don't have to run fast.

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

[Caml-list] Re: Correct locations for macro camlp4 extensions

[Jan Kybic]

> Which Haskell operator features does this emulate?  I know you can make an 
> operator without any camlp4 that does right-associative application, basically 

What I had in mind is function decomposition '.', you write

( f . g . h ) x     instead of        h ( g ( f x ) ) 

The other operator is '$':

f $ g $ h x         instead of        f ( g ( h x ) )

both can save a lot of parentheses. 

As somebody else on the list asked, I am attaching a source code
syntext.ml and an example for the syntax extensions I mentioned in my
previous email ( operator '$', 'repeat'/'until' cycle, 'where' expression, and
generalized 'for' cycle.) Bear in mind, though, that I have not
written any of them and I understand only in general terms how they
work. I am only posting them here so that they are not lost. (I am not
adding pa_macro, since it is a part of the standard distribution.)

Now, the question remains: How do I instrument the code below so that
the ocaml compiler is informed about the correct line numbers?

Jan

-- 
-------------------------------------------------------------------------
Jan Kybic <kybic@ieee.org>                  tel. +420 2 2435 7264
       or <kybic@fel.cvut.cz>,     http://cmp.felk.cvut.cz/~kybic

(** Syntax extensions for Caml programs. To be compiled with
	ocamlc -pp "camlp4o pa_extend.cmo q_MLast.cmo" \
	-I /usr/lib/ocaml/camlp4 -c syntext.ml
 *)

 open Pcaml

#load "pa_extend.cmo";;
#load "q_MLast.cmo";;


let expr_where = Grammar.Entry.create gram "expr_where";;
let let_gen = Grammar.Entry.create gram "let_general";;

let gensym =
  let cnt = ref 0 in
  fun var ->
    let x = incr cnt; !cnt in
    var ^ "_gensym" ^ string_of_int x
      
let gen_for loc v iv wh nx e =
  let loop_fun = gensym "iter" in
  <:expr<
  let rec $lid:loop_fun$ $lid:v$ =
    if $wh$ then do { $e$; $lid:loop_fun$ $nx$ } else ()
 in $lid:loop_fun$ $iv$ >>
       
   
 EXTEND

   (* infix operator $, functional composition *)
  expr: AFTER "apply"
   [[ f = expr; "$"; g = expr -> <:expr< fun x -> $f$ ($g$ x) >> ]];


   (* repeat/until cycle *)
  expr: LEVEL "expr1"
    [[ "repeat"; e1 = expr; "until"; e2 = expr ->
         <:expr< do { $e1$; while not $e2$ do { $e1$ } } >> ]];

  (* where expressions *)
  expr: BEFORE "top"
	[[ e = SELF; (ifRec,l) = expr_where -> 
	    <:expr< let $rec:ifRec!=None$ $list:l$ in $e$ >> ]];

  expr_where:
	[["where"; _ = OPT "begin"; (ifRec,l) = let_gen; "end" ->
	    (ifRec,l)
	| "where"; "("; (ifRec,l) = let_gen; ")" -> (ifRec,l) ]];

  
  let_gen: [[r = OPT "rec"; l = LIST1 let_binding SEP "and" -> (r,l)]];

         expr: LEVEL "expr1"
           [ [ "for"; v = LIDENT; iv = expr LEVEL "simple";
               wh = expr LEVEL "simple"; nx = expr LEVEL "simple";
               "do"; e = expr; "done" ->
                 gen_for loc v iv wh nx e ] ]
         ;


 END;;

(* examples, how to use the syntax extensions. To be compiled with:
  ocamlc -pp "camlp4o ./syntext.cmo" -I /usr/lib/ocaml/camlp4 test.ml\
          -o test
*)

let _ =  
         repeat print_int (z 3) ; until true
           where ( z x = (f $ g ) x where
                     ( f x = x + 3 and g x = x + 7 )
                 )


let _ = for c 0 (c<10) (c+2) do print_int c; done

(* end of examples *)

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[Marcin 'Qrczak' Kowalczyk]

W liście z pon, 23-08-2004, godz. 19:16 -0400, Michael Alexander Hamburg
napisał:


> Another syntax construction that I might write up (which I'm not aware of
> in any programming language) would be something like
> 
> (f _ x _ _ y) translates into (fun p1 p2 p3 -> f p1 x p2 p3 y)

My language Kogut uses this (along with _ in patterns as in other
functional languages). Note: these expressions are evaluated once,
not each time the function is applied.
http://kokogut.sourceforge.net/kogut.html

> When I have n lists of pairs to sort by the
> first element of the tuple, or some other function like that, it saves me
> a significant amount of programming effort to write
> 
> # let (<-<<) f g a b = f (g a) (g b);;
> or
> # let sort_by g a b = sort (compare (g a) (g b));;

It may be better to perform Schwartzian transform: make a list of
(g x, x) pairs, sort it, and extract elements back. It applies g
O(N) rather than O(N log N) times.

Well, unless g is as simple as fst.

-- 
   __("<         Marcin Kowalczyk
   \__/       qrczak@knm.org.pl
    ^^     http://qrnik.knm.org.pl/~qrczak/

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Re: Correct locations for macro camlp4 extensions

[Michael Alexander Hamburg]

On Tue, 24 Aug 2004, Jan Kybic wrote:

> > Which Haskell operator features does this emulate?  I know you can make an
> > operator without any camlp4 that does right-associative application, basically
>
> What I had in mind is function decomposition '.', you write
>
> ( f . g . h ) x     instead of        h ( g ( f x ) )
>
> The other operator is '$':
>
> f $ g $ h x         instead of        f ( g ( h x ) )
>
> both can save a lot of parentheses.
>

... snip ...

>    (* infix operator $, functional composition *)
>   expr: AFTER "apply"
>    [[ f = expr; "$"; g = expr -> <:expr< fun x -> $f$ ($g$ x) >> ]];
>
>

I don't think this is what you want.  The Haskell $ is a regular
right-associative operator; in particluar, it will treat

f $ g x y
as
f (g x y)
whereas this code will treat it as
f (g x) y

You can do it the Haskell way in O'Caml too, you would just have to make $
right-associative, which shoulndn't be so hard (I think the example for o
can be tweaked to do it).

Mike

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[Yamagata Yoriyuki]

From: skaller <skaller@users.sourceforge.net>
Subject: Re: [Caml-list] Q: Correct locations for macro camlp4 extensions
Date: 23 Aug 2004 20:59:34 +1000

> On Mon, 2004-08-23 at 19:33, Jan Kybic wrote:
> > The problem with them is that the line numbers are lost, 
> > which is a problem for error and assert messages, I get thinks like
> > Assert_failure("patch.ml", 1, 4798) instead of correct 
> > Assert_failure("patch.ml", 155, 4)
> 
> Use Ocaml 3.08. From change list on web site:
> 
> Camlp4:
> * Support for new-style locations (line numbers, not just character numbers).

Does camlp4 really report the correct line number?  I ask because my
program exits after "failwith" call, but the backtrace prints the
location which does not correspond the call of failwith either in the
original source, or in the camlp4 pretty printed code.

I use only stream parser in this program.  There is no other syntax
extension used.  The syntax is original ocaml, not revised one.  Am I
missing somthing?

--
Yamagata Yoriyuki

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Q: Correct locations for macro camlp4 extensions

[skaller]

On Sat, 2004-09-04 at 00:37, Yamagata Yoriyuki wrote:

> Does camlp4 really report the correct line number?  I ask because my
> program exits after "failwith" call, but the backtrace prints the
> location which does not correspond the call of failwith either in the
> original source, or in the camlp4 pretty printed code.

The problem may be in the p4 stream module,
not camlp4 itself.

There are obvious problems how to attribute a line
number to generated code. In general, the job must
be done by the generator script.

-- 
John Skaller, mailto:skaller@users.sf.net
voice: 061-2-9660-0850, 
snail: PO BOX 401 Glebe NSW 2037 Australia
Checkout the Felix programming language http://felix.sf.net



-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners