(no subject)

[@ 1992-11-27 15:24 UTC (permalink / raw)]

From: helary@irisa.fr (Jean-Michel Helary)
Subject: external line editor dans camllight
Message-ID: <1992Nov27.151952.20105@irisa.fr>
Date: Fri, 27 Nov 92 15:19:52 GMT

Bonjour, 
J'utilise camllight (version 0.5 Unix) pour l'enseignement de la
programmation en cycle A du CNAM a Rennes. Pour faciliter le travail
des auditeurs, je souhaiterais qu'ils puissent utiliser des facilites
d'edition integree lorsqu'ils sont en TP. 
A la page 243 du manuel camllight version 0.5, (cahpter 26) il est
fait mention  de fep. Or nous ne possedons pas cet outil (fep: Command
not found.).
Peut-on se le procurer, si oui comment, sinon quel outil equivalent
est diponible?

(les auditeurs du cnam, habitues a des environnements de qualite -la
plupart ont deja utilise turbo-qqchose - prennent assez mal la
pauvrete de l'environnement standard de camllight, et ce d'autant plus
qu'ils sont deja passablement deroutes par ce style de programmation
auquel ils ne sont pas habitues... Si les choses ne s'ameliorent pas
sur le plan de l'environnement, nous choisirons Scheme l'annee
prochaine. Mais ce serait dommage, car les qualites pedagogiques de
caml sont a mon avis superieures a celle de Scheme, mais ceci est un
autre debat!)

Jean-Michel Helary

Re: your mail

[Michel Mauny]

fep est distribue' par ftp anonyme sur nuri.inria.fr, fichier:
        system/user/fep.tar.Z

Michel

Re: fep...

[Daniel de Rauglaudre]

at Nov 27, 92 4:24 pm
Sender: weis

J'ai e'crit aussi en Chamau-Le'ger un outil du me^me genre que "fep",
que j'ai appele' "ledit". Je m'en sers quotidiennement et avec
satisfaction, puisqu'on n'est jamais mieux servi que par soi-me^me.
Pour la somme modique de 1 milliard, je serais pre^t a` en faire une
distribution gratuite par ftp anonyme.

	Daniel

[Note du mode'rateur:
 Tout le monde sait ici que tu t'ai fabrique' des tas d'outils que tu
 gardes jalousement pour toi.
 Enfin y'a du progre`s puisque tu acceptes maintenant de les vendre.
 Mais 1 milliard me semble un peu cher. A combien nous feras-tu
 l'e'diteur pleine page avec debuggeur inte'gre' que tu dois su^rement
 avoir de'ja` dans tes cartons ?
 Blagues a` part, et si tu te contentais de la gloire et de notre
 reconnaissance, on aimerait bien l'avoir tous ...

 Une question cependant: ca tourne sur toute imple'mentation de
 Chamau Le'ger ou seulement sous Unix ?


 Pierre Weis
 ----------------------------------------------------------------------------
 Formel Project
 INRIA, BP 105, F-78153 Le Chesnay Cedex (France)
 E-mail: Pierre.Weis@inria.fr
 Telephone: +33 1 39 63 55 98
 ----------------------------------------------------------------------------
]

Re: your mail

[Xavier Leroy]

> Can OCaml programs be compiled to native Windows(x86) executables ?

Yes, you can produce standalone Win32 executables, either using the
bytecode compiler ocamlc with the -custom option, or using the
native-code compiler ocamlopt.

> What external programs are needed ? Can Microsoft Visual C++ be of
> some help ?

>From the README.win32 file:

  Linking Caml bytecode with C code (ocamlc -custom) requires the
  Microsoft Visual C++ compiler version 6.

  The native-code compiler (ocamlopt) requires Visual C++ version 6
  and the Microsoft assembler MASM version 6.11 or later.
  MASM can be downloaded for free from Microsoft's Web site;
  see the comp.lang.asm.x86 FAQ for directions, or
  http://www.cs.uu.nl/wais/html/na-dir/assembly-language/x86/microsoft.html

Hope this helps,

- Xavier Leroy

Re: your mail

[Pierre Weis]

> Messieurs,
> Je suis interessé à Camlwin que vous developpez. Mais il me manque sa
> documentation.Pouvez-vous, si possible, me fournir cette documentation si
> precieuse pour moi.
> Elle pourra être envoyée à mon adresse que voici:
> Mifuku Assin-na-Idia
> Rue de l'Economie n° 9
> 1000 Bruxelles.
> Voici mon e-mail: amifuku@info.fundp.ac.be
> D'avance merci.
> Mifuku Assin.

Camlwin n'est pas de'veloppe' a` l'Inria mais a` Te'le'com Bretagne.
Voici un extrait du readme, qu'on trouve dans la distribution de
Camlwin (ftp://ftp.inria.fr/lang/caml-light/Usercontribs/camlwin/readme.pc)

Camlwin is developped in Caml at TELECOM BRETAGNE 
(Ecole Nationnale Superieure des Telecommunications).

[...]

You can found the Camlwin release manual on WEB at:
http://liasc.enst-bretagne.fr/~saunier

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/

Re: your mail

[Pierre Weis]

> 	J'ai voulu recompiler un programme fait en 0.7 (je crois) avec le 
> compilateur 0.73 : apparemment certaines fonctions ont changé de nom: j'ai 
> l'erreur
> camlc -g -W -c main.ml
> File "main.ml", line 9, characters 7-43:
> >       format__set_formatter_output_channel stdout;
> >       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> The value identifier format__set_formatter_output_channel is unbound.

Yes, some small discrepancies in the naming conventions have been
corrected in the format library (see format.mli). In this case output
has been change into out, since output channel are named out channels
in Caml.

(*** Redirecting formatter output *)
value set_formatter_out_channel : out_channel -> unit;;
        (* Redirect the pretty-printer output to the given channel. *)

In addition, multiple formatting in parallel on several output
channels are now available (once more, see format.mli):

(*** Multiple formatted output *)
type formatter;;
        (* Abstract data type corresponding to a pretty-printer and
           all its machinery.
           Defining new pretty-printers permits the output of
           material in parallel on several channels.
           Parameters of the pretty-printer are local to the pretty-printer:
           margin, maximum indentation limit, maximum number of boxes
           simultaneously opened, ellipsis, and so on, are specific to
           each pretty-printer and may be fixed independantly. *)

Enjoy it!

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis

Re: your mail

[Pierre Weis]

> 1) L'expression
> let rec x = 1 :: x ;;
> est de type int list. Son exécution crée-t-elle une fermeture ?

Il n'y a pas lieu de cre'er de fermeture car cette de'finition
re'cursive n'est pas la de'finition d'une fonction mais la de'finition
d'une liste. Ce genre de de'finitions re'cursives sont qualifie'es de
``de'finitions re'cursives de valeurs'' dans le jargon des
imple'menteurs de ML. En effet elles posent des proble`mes de
compilation (voir ci-dessous) alors que les de'finitions re'cursives
de fonction s'imple'mentent sans proble`me.

Ici la de'finition cre'e une cellule de liste dont la queue pointe
vers elle-me^me: on obtient une liste circulaire ne comportant que des
1.

> Je lis d'ailleurs dans le "Doc et user's manual" : the behavior of other
> forms of let rec (formes autres que des définitions de fonction) is
> implementation-dependant.
> 
> 2) Pourquoi le typeur accepte la définition récursive précédente mais

Le typeur accepte cette de'finition parcequ'elle est bien type'e.

Le proble`me des de'finitions re'cursives de valeurs n'est pas d'abord
un proble`me de typage mais surtout un proble`me de compilation.

En effet la de'finition re'cursive de valeur la plus ge'ne'rale s'e'crit:

let rec x = F (x);;

Calculer une valeur pour x revient finalement a` de'terminer le point
fixe de la fonction F, ce qui n'est pas e'vident.
Par exemple pour let rec x = 1 :: x, il faut trouver le point fixe de
(function y -> 1 :: y).

Ce proble`me est clairement non re'soluble en ge'ne'ral: soit parceque
F n'admet pas de point fixe (let rec x = x + 1;;), soit parcequ'elle en
admet plusieurs (let rec x = x * x;;), soit qu'on ne sait absolument
pas comment en trouver un s'il existe.

On de'termine cependant une large classe de fonctions F pour lesquels
il y a un unique point fixe qu'on obtient en outre de fac,on uniforme:
-- classe 0 : F est une fonctionnelle (on est en train de de'finir une
fonction).
 Ex: let rec fact = function x -> ... fact (x - 1)
     F = function f -> function x -> ... f (x - 1)
     On de'montre que F admet un unique point fixe. Pratiquement, on le
     trouve en fabriquant une fermeture cyclique.
-- classe 1 : l'expression F (x) ne fait intervenir que des
constructeurs de valeurs mais aucun appel de fonction, et en outre la
valeur de x est ne'cessairement alloue'e en me'moire et posse`de une
taille pre'visible par le compilateur.

La classe 0 est la plus simple et la seule supporte'e par tous les
compilateurs; la classe 1 est celle accepte'e par Caml Light.

Dans une de'finition de classe 1 on peut calculer F (x) sans
connai^tre la valeur de x, on a seulement besoin de l'adresse me'moire
ou` cette valeur sera range'e. En ce cas, le compilateur re'serve la
place correspondante pour x, calcule F (x) et e'crit la valeur obtenue
a` l'endroit re'serve' pour x.

N'appartiennent pas a` la classe 1:
let rec x = 1 + x;; (appel de fonction)
let rec x = x;; (type (donc taille de x) inconnu)
let rec x = 1;; (type int: x n'est pas alloue')

La de'finition let rec x = 1 :: x entre dans la classe 1: x est
force'ment une liste non vide. On re'serve donc une cellule de liste
dans la me'moire, appelons la @x. Puis on calcule la liste 1 ::
@x. Cette liste est e'crite a` l'adresse de x: on e'crit 1 dans le
premier champ de la cellule @x, et @x dans le deuxie`me, ce qui boucle
la liste.

> 21)refuse la modification suivante du programme minicaml (cf Le langage
> caml de Pierre Weiss et Xavier Leroy p 352) :
> 
> let rec env_étendu =
> (déf.Nom, Val_fermeture
>          { Définition = liste_de_cas ; Environnement = env_étendu}) ::
> env_courant
> 
> sous le prétexte que déf.Nom n'est pas acceptable dans une définition récursive

En effet un acce`s a` l'inte'rieur d'une structure de donne'es n'est
pas tole're', car il est susceptible d'acce'der a` une partie de la
valeur de'finie re'cursivement qui n'est pas encore significative
(c'est-a`-dire pas encore construite). Ce cas est analogue a` l'acce`s
a` la te^te d'une liste non encore construite, par exemple let rec x =
(hd x) :: x;;

> 22)accepte par contre
> 
> let nom = déf.Nom in
> let rec env_étendu =
> (nom, Val_fermeture
>          { Définition = liste_de_cas ; Environnement = env_étendu}) ::
> env_courant

En effet, vous avez fait disparai^tre l'acce`s a` l'inte'rieur de
de'f, il est maintenant clair (pour le compilateur) que seule
l'adresse de env_e'tendu est ne'cessaire pour calculer l'expression
de'finissante.

> Remarque : mon but était d'éviter les types mutables pour représenter les
> environnements.

Nous n'avions pas utilise' la de'finition re'cursive de valeurs pour ne
pas introduire dans notre livre d'extensions propres a` Caml Light. En
outre boucler la fermeture ``a` la main'' est plus pe'dagogique ici,
pluto^t que de de'finir les fonctions re'cursives directement avec un
let rec de Caml.

En outre, utiliser des structures mutables est la fac,on la plus
ge'ne'rale de de'finir re'cursivement des valeurs.

Et finalement: faut-il avoir peur des structures de donne'es mutables ?

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis