[Caml-list] functional or imperative feature ?

[Caml-list] functional or imperative feature ?

[habet_ms]

Hi,
  are sequencing (;) and block structure (begin ... end) functional features
  or imperative ones ?

Thanks,

M.S

[Caml-list] Re: functional or imperative feature ?

[Christopher Zimmermann]

On Sun, 21 Jul 2013 22:50:26 +0200 (CEST)
<habet_ms@yahoo.fr> wrote:

> Hi,
>   are sequencing (;) and block structure (begin ... end) functional
> features or imperative ones ?

sequencing is imperative.
begin and end are just an alias for '(' and ')' and are used in both
styles.

Christopher


-- 
OpenPGP public key: http://gmerlin.de/christopher.pub
fingerprint: 1917 680A 723C BF3D 2CA3  0E44 7E24 D19F 34B8 2A2A

RE: [Caml-list] functional or imperative feature ?

[David Allsopp]

habet_ms@yahoo.fr wrote:
> Hi,
>   are sequencing (;) and block structure (begin ... end) functional
> features
>   or imperative ones ?

Any sequence

e1; e2; e3;;

can be rewritten

let _ = e1 in
let _ = e2 in
e3;;

(with the difference that in a sequence, the compiler warns you if e1 and e2 don't have type unit) 

It's not strictly speaking an imperative construct but it's only really of use in imperative programming.

Conversely begin ... end is neither explicitly functional nor imperative - it's simply a form of brackets. Consider nested matches (definitely functional):

let f x y = 
  match x with
    `Foo ->
      begin
        match y with
          `Bar -> true
        | _ -> failwith "Bar"
      end
  | _ ->
    failwith "Foo"

HTH,


David 

Re: [Caml-list] functional or imperative feature ?

[Jean-Marc Alliot]

Le 21/07/2013 22:50, habet_ms@yahoo.fr a écrit :
> Hi,
>    are sequencing (;) and block structure (begin ... end) functional features
>    or imperative ones ?
>
> Thanks,
>
> M.S
>
Interesting question, which I sometimes get from my students.
I am not giving really an answer (I saw one from David Allsopp), but 
instead an advice;
Ocaml is not the best language to learn "pure" functional programming. 
If you really want to give it a try, then try Haskell, and if you really 
want to be "extra-pure", don't use at all Haskell syntactic sugar. You 
will find all the answers by yourself, maybe the hard way :-)

PS: That's not a Haskell vs Ocaml troll. I love both languages, and I am 
using ocaml much more than Haskell for everyday programming (I consider 
Ocaml easier to use and even easier to read, but that's strictly IMHO, 
and maybe just because I am more familiar with it).
It's just that, for learning pure functional programming, with lazy 
evaluation, Haskell is really good.

Re: [Caml-list] Re: functional or imperative feature ?

[oliver]

Maybe it can be called just syntactical sugar...


========================================================================

let fun_a () = print_endline "A: FooBar";
               print_endline "A: Baz"

let fun_b () =
               let () = print_endline "B: FooBar" in
               let () = print_endline "B: Baz" in
               ()



let () =
   fun_a();
   fun_b()


(* or this one:, of course:

let () =
   let () = fun_a() in
   let () = fun_b() in
   ()

*)

========================================================================



Ciao,
   Oliver

RE: [Caml-list] Re: functional or imperative feature ?

[David Allsopp]

oliver wrote:
> Maybe it can be called just syntactical sugar...

Yes...

> ========================================================================
> 
> let fun_a () = print_endline "A: FooBar";
>                print_endline "A: Baz"
> 
> let fun_b () =
>                let () = print_endline "B: FooBar" in
>                let () = print_endline "B: Baz" in
>                ()

... but not for this translation! Consider

# 4; 3;;
Characters 0-1:
  4; 3;;
  ^
Warning 10: this expression should have type unit.
- : int = 3

By your translation, you'd have:

# let () = 4 in
  3;;
Characters 9-10:
  let () = 4 in
           ^
Error: This expression has type int but an expression was expected of type
         unit


David

Re: [Caml-list] Re: functional or imperative feature ?

[Wojciech Meyer]

[-- Attachment #1: Type: text/plain, Size: 1297 bytes --]

Moreover we can translate lets to lambdas:

let () = print_endline "Foo" in
let () = print_endline "Bar" in
let () = print_endline "Baz" in
   ()

(fun () -> (fun () -> print_endline "Baz") (print_endline "Bar"))
(print_endline "Foo")

Further transformation to use bind instead of function application and
wrapping the carried value into a type, leads to monads.

On Mon, Jul 22, 2013 at 12:42 PM, oliver <oliver@first.in-berlin.de> wrote:

> Maybe it can be called just syntactical sugar...
>
>
> ========================================================================
>
> let fun_a () = print_endline "A: FooBar";
>                print_endline "A: Baz"
>
> let fun_b () =
>                let () = print_endline "B: FooBar" in
>                let () = print_endline "B: Baz" in
>                ()
>
>
>
> let () =
>    fun_a();
>    fun_b()
>
>
> (* or this one:, of course:
>
> let () =
>    let () = fun_a() in
>    let () = fun_b() in
>    ()
>
> *)
>
> ========================================================================
>
>
>
> Ciao,
>    Oliver
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa.inria.fr/sympa/arc/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>

[-- Attachment #2: Type: text/html, Size: 2257 bytes --]

Re: [Caml-list] functional or imperative feature ?

[r.3]

[-- Attachment #1: Type: text/plain, Size: 37 bytes --]

habet, are you still following :-) 


[-- Attachment #2: Type: text/html, Size: 259 bytes --]

Re: [Caml-list] Re: functional or imperative feature ?

[oliver]

On Mon, Jul 22, 2013 at 11:46:55AM +0000, David Allsopp wrote:
> oliver wrote:
> > Maybe it can be called just syntactical sugar...
> 
> Yes...
> 
> > ========================================================================
> > 
> > let fun_a () = print_endline "A: FooBar";
> >                print_endline "A: Baz"
> > 
> > let fun_b () =
> >                let () = print_endline "B: FooBar" in
> >                let () = print_endline "B: Baz" in
> >                ()
> 
> ... but not for this translation! Consider
> 
> # 4; 3;;
> Characters 0-1:
>   4; 3;;
>   ^
> Warning 10: this expression should have type unit.
> - : int = 3
> 
> By your translation, you'd have:
> 
> # let () = 4 in
>   3;;
> Characters 9-10:
>   let () = 4 in
>            ^


let _ = 4 in _ = 4 in ();;

The unit-problem comes from let () = ...
                                ^^ 
                                  \
                                 unit


Ciao,
   Oliver

Re: [Caml-list] functional or imperative feature ?

[Kristopher Micinski]

As others have mentioned, you can desugar sequenced statements to
lambdas, but that doesn't make it functional (in the pure sense) per
se.

The purest way to view it is that after desugaring, sequenced
statements turn into lambdas, which turn into (morally) binds from the
IO monad.  The observation is that when writing in ML, you are
implicitly writing in the IO monad.

Kris


On Sun, Jul 21, 2013 at 4:50 PM,  <habet_ms@yahoo.fr> wrote:
> Hi,
>   are sequencing (;) and block structure (begin ... end) functional features
>   or imperative ones ?
>
> Thanks,
>
> M.S
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa.inria.fr/sympa/arc/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs

Re: [Caml-list] functional or imperative feature ?

[oleg]

> The purest way to view it is that after desugaring, sequenced
> statements turn into lambdas, which turn into (morally) binds from the
> IO monad.  The observation is that when writing in ML, you are
> implicitly writing in the IO monad.

Peter Landin has described this process already in 1965. See the exact
quotation from his paper (the ()-passing trick) in
        http://okmij.org/ftp/Computation/IO-monad-history.html
(as well a few comments). That Peter Landin's paper also described
State and Writer monads, streams and delayed evaluation and even
stream fusion. 

Re: [Caml-list] functional or imperative feature ?

[Kristopher Micinski]

[-- Attachment #1: Type: text/plain, Size: 1176 bytes --]

Thanks for pointing out this exposition, Oleg.  I had never thought of the
connection between monads and Landin's earlier paper.  However, I do
remember Appel's CPS book saying something to the effect of lambda being
the prototypical let, and this was further described to me by Michael Hicks
when he was doing his work on monadic programming for ML: in which ML is
"lifted" to the proper monad for the job.

http://research.microsoft.com/apps/pubs/?id=151802

Interesting history however, your pages are quite useful!


Kris
On Jul 22, 2013 8:16 PM, <oleg@okmij.org> wrote:

>
> > The purest way to view it is that after desugaring, sequenced
> > statements turn into lambdas, which turn into (morally) binds from the
> > IO monad.  The observation is that when writing in ML, you are
> > implicitly writing in the IO monad.
>
> Peter Landin has described this process already in 1965. See the exact
> quotation from his paper (the ()-passing trick) in
>         http://okmij.org/ftp/Computation/IO-monad-history.html
> (as well a few comments). That Peter Landin's paper also described
> State and Writer monads, streams and delayed evaluation and even
> stream fusion.
>
>

[-- Attachment #2: Type: text/html, Size: 1759 bytes --]