Code-execution (evaluation) time

Code-execution (evaluation) time

[Oliver Bandel]

Hello,

I want to refresh my OCaml knowledge after
I (again) paused for a while.

I want to know, when certain parts of the code are executed,
for example if I have more than one   let _ = ...
statement in my code (for example in different comp0ilaion units each  
one of them).

I also found an old code snippet with the following parts:

==============================
let fnames = List.tl(Array.to_list Sys.argv)

(* some more code *)

let _ =
   List.iter print_days_old fnames
==============================

So, the value fnames contains the args from the command line
and can be used in the first statement of the code.

Is there some documentation on the details of which things
are executed/evaluated at which point of the execution phase
of the program?

I don't want to rely on weak knowledge (because some things I've  
forgotten... jzst have done C, Python and even Assembler (!) during  
the last years...
just some snippets of OCaml in that time.)

Ciao,
    Oliver


P.S.: After coming back to OCaml (what I do mostly in privat projects,
       at work it's very unlikely to have the possibility) I'm again
       even more convinced that it is the best language for most problems. :)
       And it's so much fun using it. :)

RE: [Caml-list] Code-execution (evaluation) time

[David Allsopp]

Oliver Bandel wrote:
> Hello,
> 
> I want to refresh my OCaml knowledge after I (again) paused for a while.
> 
> I want to know, when certain parts of the code are executed,
> for example if I have more than one   let _ = ...
> statement in my code (for example in different comp0ilaion units each one
> of them).

Expressions (as in, things listed in http://caml.inria.fr/pub/docs/manual-ocaml/expr.html) are evaluated in the order in which they appear in a source file. If you have two files A.ml and B.ml which contain top-level statements, the order in which they execute will depend on the order in which you link the resulting .cmo or .cmx files (which should be left-to-right as passed to ocamlc/ocamlopt - don't know where that's specified).

As far as I can see, in pretty much all contexts within an expression where order of evaluation could matter including, but probably not limited to:

* Record initialisation (e.g. let i = ref 0 in {a = (incr i; !i); b = (incr i; !i)})
* Function application (similarly)
* let foo = _ and bar = _ in _

are intentionally left as unspecified (in practice, application and record initialisation are right-to-left and let x = _ and y = _ is left-to-right but the point is that you are never supposed to rely on that).

> I also found an old code snippet with the following parts:
> 
> ==============================
> let fnames = List.tl(Array.to_list Sys.argv)
> 
> (* some more code *)
> 
> let _ =
>    List.iter print_days_old fnames
> ==============================
> 
> So, the value fnames contains the args from the command line and can be
> used in the first statement of the code.

[let fnames = ..] is a complete expression so it's evaluated before the [let _] further down.


David

Re: [Caml-list] Code-execution (evaluation) time

[oliver]

Hello David, hello Mark,

thanks for your answers.


In detail:
  thanks to Mark for the refresher
and
 thanks to David for the enhancer. :)


Ciao,
   Oliver

Re: [Caml-list] Code-execution (evaluation) time

[oliver]

Hello David, hello Mark,

thanks for your answers.


In detail:
  thanks to Mark for the refresher
and
 thanks to David for the enhancer. :)


Ciao,
   Oliver

Re: [Caml-list] Code-execution (evaluation) time

[mark]

It's also worth noting a few other things about execution order:

1) function call arguments - All arguments in a function call are evaluated,
even if not needed (in right-to-left order - as David says - but don't rely
on this).

2) function bodies - These are executed when at least as many arguments are
supplied as are explicitly supplied in the definition of the function.  For
example:

let f x = (print_string "X"; fun y -> (print_string "Y"; x + y));;
- this will not print anything as 'f' is defined

let g = f 5;;
- this will print "X" as 'g' is defined
- "Y" will be printed each time 'g' is called with an argument.

3) blank assignments - These are still fully evaluated, even though the
results are thrown away.  For example:

let _ = (print_string "X"; 5);;
- this will still print "X"

4) 'match' branch choice - The first matching branch (i.e. as it appears in
the file) is chosen (if the conditions overlap).

5) 'if' and 'match' unused branches - These (obviously) don't execute at
all.  So these do not behave like functions.

6) logical operator short circuits - '||' and '&&' short-circuit
left-to-right (i.e. don't evaluate the second argument if the first (i.e.
leftmost) argument is "true" (for '||') or "false (for '&&').  So these do
not behave like functions.  For example:

let foo x y = x && y;;

(print_string "X"; false) && (print_string "Y"; false);;
- this will print just "X"

foo (print_string "X"; false) (print_string "Y"; false);;
- this will print "YX", because it's a function call and not a logical
operation.

Mark.


on 19/10/10 8:54 PM, David Allsopp <dra-news@metastack.com> wrote:

> Oliver Bandel wrote:
>> Hello,
>>
>> I want to refresh my OCaml knowledge after I (again) paused for a while.
>>
>> I want to know, when certain parts of the code are executed,
>> for example if I have more than one   let _ = ...
>> statement in my code (for example in different comp0ilaion units each one
>> of them).
>
> Expressions (as in, things listed in
> http://caml.inria.fr/pub/docs/manual-ocaml/expr.html) are evaluated in the
> order in which they appear in a source file. If you have two files A.ml
and
> B.ml which contain top-level statements, the order in which they execute
> will depend on the order in which you link the resulting .cmo or .cmx
files
> (which should be left-to-right as passed to ocamlc/ocamlopt - don't know
> where that's specified).
>
> As far as I can see, in pretty much all contexts within an expression
where
> order of evaluation could matter including, but probably not limited to:
>
> * Record initialisation (e.g. let i = ref 0 in {a = (incr i; !i); b =
(incr
> i; !i)})
> * Function application (similarly)
> * let foo = _ and bar = _ in _
>
> are intentionally left as unspecified (in practice, application and record
> initialisation are right-to-left and let x = _ and y = _ is left-to-right
> but the point is that you are never supposed to rely on that).
>
>> I also found an old code snippet with the following parts:
>>
>> ==============================
>> let fnames = List.tl(Array.to_list Sys.argv)
>>
>> (* some more code *)
>>
>> let _ =
>>    List.iter print_days_old fnames
>> ==============================
>>
>> So, the value fnames contains the args from the command line and can be
>> used in the first statement of the code.
>
> [let fnames = ..] is a complete expression so it's evaluated before the
[let
> _] further down.
>
> David