Hello
Here is the latest Caml Weekly News, for the week of 19 to 26 October, 2004.
I will be in vacations with very limited internet access next week, so there will be no CWN.
Archive: http://caml.inria.fr/archives/200410/msg00175.html
Andrej Bauer asked:
This is a question for gurus.
I am contemplating writing an enhanced toplevel that could display
graphics as we well as text (the evil plan is to replace Mathematica).
The first step seems to be: how to install a pretty printer for a
_polymorphic_ type.
As an example, consider this:
type 'a set = { elements : 'a list }
I want a value of this type to print out as
{a, b, c, ... d}
instead of
{elements = [a; b; c; ...; d]}
The trouble is, how to print out the elements a, b, c, ..., d
since they are of a polymorphic type.
According to the somewhat old message at
http://caml.inria.fr/archives/200201/msg00234.html
I should use Toplevel.print_out_value to do this. But, print_out_value
expects an arguments of type Outcometree.out_value, and it is not
clear to me where I will get it. Is there another function that converts
an arbitrary value (of an arbitrary type!) to an Outcometree.out_value?
Am I supposed to rewrite half of toplevel.ml to get this working?
It would be helpful if there were, somewhere in the world, a minimal and
_complete_ example of how one can actually write a polymorphic pretty
printer. This _must_ be an FAQ.
Christophe Troestler answered and Andrej Bauer said:
> > Am I supposed to rewrite half of toplevel.ml to get this working?
>
> I am afraid that the awser is yes :(. Let's see why:
Thanks for the hints.
I'd be willing to take a shot at writing a more flexible toplevel, one
that allows to install polymorphic pretty-printers in a sane way.
I am imagining something like this. A pretty printer may be registered
with #install_printer, as before. But we need to fiddle with the types
of printers to get things working. A printer pp for type t (where t may
be polymorphic) would have type
pp : Format.formatter -> t -> (Format.formatter -> 'a -> unit) -> unit
If you compare this with the current type, you'll notice the extra
argument of type (Format.formatter -> 'a -> unit). This is a helper
function which would be passed to pp by the toplevel. Then pp can use it
to print out any polymorphic value.
Does this sound like a sound plan? Or am I missing something? Perhaps
the ocaml developers secretly posses such a toplevel already.
Archive: http://caml.inria.fr/archives/200410/msg00181.html
James Woodyatt announced:
Announcing the release of the Iom-0.0 package in the OCaml NAE project.
For more details, see the SF.Net project page for OCaml NAE.
http://sf.net/projects/ocnae/
===== OCaml NAE Reactive I/O Monad (iom) library =====
This distribution is the Objective Caml Network Application Environment
(NAE)
Reactive I/O Monad library, which implements I/O monad functions
designed to
facilitate writing of concurrent, reactive, single-threaded network
application
services in a functional style.
Note: see the ISSUES file for a list of open problems in this release.
===== Required Components =====
This library requires the following external components:
- Objective Caml (v3.07+2 or newer)
- Findlib (tested with v0.8.1 and v1.0.4)
- OCaml NAE Core Foundation (cf-0.4)
Principle development was on Mac OS X 10.3. The final version of this
library also compiled successfully and passed all self-tests without
warnings on Suse Linux 9.0 for x86-32. Other platforms with POSIX-like
environments should require only a minimal porting effort.
Archive: http://caml.inria.fr/archives/200410/msg00182.html
Damien Doligez announced:
We are pleased to announce the release of Focal version 0.2beta.
Focal (formerly known as FoC) is a language for software-proof codesign.
In Focal, code, specifications, and proofs are developped together
in the same source files, using a novel object-oriented module system.
The compiler analyses the dependencies in order to ensure the
consistency of the source, then translates the code to Objective Caml,
and the proofs to Coq.
This is a beta release: there may be some bugs, and the documentation
needs (lots of) work.
This release contains the source code of the following:
- the focal compiler (focc)
- a library of Computer Algebra algorithms
- an automatic theorem prover (zenon)
- a documentation tool (focdoc)
- an emacs mode, etc.
It is available at < http://modulogic.inria.fr/focal/download/ >.
-- the Focal team
David Mentre added:
> We are pleased to announce the release of Focal version 0.2beta.
I have updated the list I try to maintain on free software tools for
formal developments: http://gulliver.eu.org/ateliers/fv-tools/index.html
Let me know if you have any addition/fix/...
Archive: http://caml.inria.fr/archives/200410/msg00183.html
Radu Grigore asked:
I have a problem with writing makefiles for OCaml and with compilation
order. Probably a FAQ.
Searching the caml-list archives I've found info about a tool by
Nicolas Cannesse (ocamake) that can be used to compile a set of ml
files into an executable or to generate a makefile such that a
subsequent make command will construct the executable. However this is
not quite what I want.
Using a makefile has the advantage that only necessary recompilations
are performed. So I want to use a makefile. If I add a source (ml)
file in the project directory then the generated makefile becomes
obsolete and needs to be regenerated. But... a regeneration might
overwrite any subsequent changes I've done.
What I'd love is an enhanced ocamldep that in addition to the
dependencies prints also a topologically sorted list of files, like
this:
---
$ocamldep main.ml parser.ml ast.ml lexer.ml
main.cmo: lexer.cmo parser.cmo
main.cmx: lexer.cmx parser.cmx
parser.cmo: ast.cmo
parser.cmx: ast.cmx
lexer.cmo: parser.cmo
lexer.cmx: parser.cmx
CMO_FILES=ast.cmo parser.cmo lexer.cmo main.cmo
CMX_FILES=ast.cmx parser.cmx lexer.cmx main.cmx
---
This way I would be able to write a kind of 'standard' makefile:
---
include .depend
all: $(CMO_FILES)
ocamlc -o my_app $(CMO_FILES)
depend:
ocamldep *.ml > .depend
%.cmo: %.ml
ocamlc -c $<
---
Does such a tool exists? Does ocamldep already knows to do this and I
didn't found it in the docs? Thanks.
Nicolas Cannasse answered:
> I have a problem with writing makefiles for OCaml and with compilation
> order. Probably a FAQ.
>
> Searching the caml-list archives I've found info about a tool by
> Nicolas Cannesse (ocamake) that can be used to compile a set of ml
> files into an executable or to generate a makefile such that a
> subsequent make command will construct the executable. However this is
> not quite what I want.
[...]
> Does such a tool exists? Does ocamldep already knows to do this and I
> didn't found it in the docs? Thanks.
This is not a FAQ and still an open problem.
OCamldep is working at the syntax level but does not differenciate between
the usage of a module *type* (so a compilation dependency : the MLI of the
module need to be compiled first) and the usage of a module *value* ( so a
compilation + runtime dependency : the MLI needs to be compiled first AND
the module linked first). Thus unless you rewrite your ocamldep you cannot
get enough information to correctly sort the CMO into the good order.
However ocamake is applying some algorithms in order to "guess" which order
might be valid in cases of conflict . A case of conflict arise when we
reduce the ML+MLI ocamldep graph output into a CMO only graph, merging ML
and MLI nodes, and thus sometimes creating cycles while there *is* a valid
compilation order.
Instead of doing again the job you might try to use the Makefile generation
from ocamake, or simply tweak it in order to make it output the linkage
order it found.
Julien Signoles also answered:
> What I'd love is an enhanced ocamldep that in addition to the
> dependencies prints also a topologically sorted list of files, like
> this:
I think Ara's ocamldsort (mixed with ocamldep) is your friend. I quote the
beginning of the README file:
"The ocamldsort command scans a set of Objective Caml source files (.ml
and .mli files), sorts them according to their dependencies and prints the
sorted files in order to link their corresponding .cmo and .cmi files."
http://www.eleves.ens.fr/home/ara/ocaml.html
Richard Jones said and Dimitri Ara answered:
> I tried out ocamldsort, and it seems to work well, *except* that
> there seems to be a strange bug involving directories
Thank you for your bug report. It is fixed in the 0.14.3 that I have
just released.
( ftp://quatramaran.ens.fr/pub/ara/ocamldsort/ocamldsort-0.14.3.tar.gz )
Archive: http://caml.inria.fr/archives/200410/msg00193.html
Harry Chomsky announced:
I'm pleased to announce release 1.0 of OCaml-Win32, an OCaml library
providing direct access to the Win32 API. Compared to the previous release
(0.02), this version adds support for many of the common dialog boxes and
common controls, improved mechanisms for processing notification messages,
and numerous small improvements and bug fixes. I expect that future
upgrades will not change the architecture or introduce many
incompatibilities, so I am taking the liberty of calling this release 1.0,
the first "stable" release. However, large parts of the library have not
been tested yet.
The library is made available under the LGPL license, at the following URL:
http://www.speakeasy.org/~hchomsky/ocaml-win32.html
I have also created a SourceForge project, ocaml-win32, which can allow
volunteers to help expand the library in the future. Please notify me if
you are interested in becoming a developer for this project.
Archive: http://caml.inria.fr/archives/200410/msg00208.html
Charles-Albert Lehalle announced:
A new version (6.01) of OCAMAWEB is available at sourceforge :
http://sourceforge.net/project/showfiles.php?group_id=66639
It's a litterate programming tool written in ocaml and that can be used on
any language having comment marks of one character (I deeply think about
an upgrade to *any* language).
It is used for more that 2 years at MIRIAD Technologies, where it is used
to comment algorithmic code.
config files exist for awk and r-project languages, and I will soon tune
one for the SAS macro programming language.
feel free to use, read and comment the code (It is based on my first ocaml
experience, so I know that I should build a fully new version as soon as
possible : advices are welcome...).
David Brown asked and Charles-Albert Lehalle replied:
> >any language having comment marks of one character
> In other words, it can't be used with Ocaml, C, C++, Java, Ada, Haskell?
> So it is a literate tool for scripting languages such as sh, perl and
> python?
MATLAB, SAS and S-plus were the target of OCAMAWEB (for signal processing
and probability/statistics algorithms prototyping, in which it is very
valuable to include mathematical proofs into code), so I at the time I
developed ocamaweb, I did not think that it could be usefull for the
languages you cite.
Now that a lot of people use ocamaweb outside of MIRIAD, I will have to
extend it to any language...
Anyway, from my point of view, there is a lot of tools to comment code a
proper way (doxygen, ocamldoc, etc), and a lot of programming tasks do not
need "real" litterate programming (in java for instance, a "linear"
documentation tool like javadoc is mainly efficient).
The point is that when you develop code that implement some mathematical
results you obtain and when you want to share that code (and the
mathematics that support it) with other people (that's our case inside
MIRIAD), you need to be able to "reconfigure" your code to produce a
documentation including mathematical glyphs (using LaTeX is a good option)
: that's what ocamaweb allow to obtain. And a lot of people implement such
mathematical "adjustments" of existing results in signal processing and
statistics / probability ; those people mainly use MATLAB, S-plus (or R)
and SAS.
So ocamaweb primary goal is definitely not to comment sh, perl or awk
(even if now that it is on my computer, I use it with those languages) ;
it's to produce restructured documentation including mathematical proofs.
Archive: http://caml.inria.fr/archives/200410/msg00240.html
Olivier Pérès announced:
Amble is a library that makes it easy to write distributed programs
in Objective Caml. It is primarily intended for teaching distributed
programming. Basically, you design communicating automata and network
topologies, and Amble takes care of the implementation details. It is a
"compile once run many" design in that the actual distribution of the
processes is specified at runtime. The source code, documentation and a
few demo programs are available here : http://home.gna.org/amble/
Archive: http://caml.inria.fr/archives/200410/msg00261.html
Pietro Abate asked:
I'm trying to write an extensible data structure where I can add new
types with minimal effort, but I'm kinda stuck...
my goal is to have a mixed list as:
let a1 = (new set :> mixtype1 store);;
let a2 = new setofset;;
let a3 = (new intlist :> mixtype1 store);;
let l = [a1;a2;a3]
this doesn't work, but just to give you an idea...
this is my approach. Is there a better way of doing it ?
First I defined a virtual class and a couple of auxiliary types. The
mixtype should be user extensible and the ext_rep should give me a
uniform representation of all my objects in terms of lists.
type mixtype = [
| `Int of int
]
;;
type 'el ext_rep =
| El of 'el list
| Cont of 'el ext_rep list
;;
class virtual ['mt] store =
object(self : 'store)
method virtual assign : 'store -> unit
method virtual add : 'mt -> unit
method virtual del : 'mt -> unit
method virtual access : 'mt ext_rep
method virtual copy : 'store
end
;;
(* The first class is a int list and it's easy... *)
class intlist =
object
inherit [mixtype] store
val mutable data = []
method data = data
method assign store = data <- store#data
method add e = data <- e::data
method del e = ()
method access = El(data)
method copy = {< data = data >}
end
;;
(* now I want to have set of int: *)
module OriginalSet = Set
module Set = OriginalSet.Make (
struct
type t = mixtype
let compare = compare
end
);;
class set =
object
inherit [mixtype] store
val mutable data = Set.empty
method data = data
method assign store = data <- store#data
method add e = data <- Set.add e data
method del e = ()
method access = El(Set.elements data)
method copy = {< data = data >}
end
;;
(* now I want to extend my mixtype, add a new type to use the set of int
class and define a set of sets of ints... This should give a good deal
of flexibility as to add a new type I just need to subclass store and
add a new mixtype that is more general... *)
type mixtype1 = [
|`Set of set
|mixtype
];;
module SetofSet = OriginalSet.Make (
struct
type t = mixtype1
let compare = compare
end
);;
class setofset =
object
inherit [mixtype1] store
val mutable data = SetofSet.empty
method data = data
method assign store = data <- store#data
method add e = data <- SetofSet.add e data
method del e = ()
method access =
Cont (
List.map (function
|`Set e -> (e#access: mixtype ext_rep :> mixtype1 ext_rep)
|#mixtype -> failwith "wrong type"
) (SetofSet.elements data)
)
method copy = {< data = data >}
end
;;
(* so far, so good. Now I want to put these three objects in a list and downcast
them to the store class (using mixtype1 that should be a super-type of mixtype) *)
(* I tried many combinations, but with poor results... this doesn't work ....
It says:
Type mixtype = [ `Int of int ] is not compatible with type
'b = [> `Int of int | `Set of set ]
The first variant type does not allow tag(s) `Set.
This simple coercion was not fully general. Consider using a double coercion.
But I don't understand why, as mixtype1 should be more general than mixtype...
*)
let a1 = (new set :> mixtype1 store);;
let a2 = new setofset;;
let a3 = (new intlist :> mixtype1 store);;
let l = [a1;a2;a3]
John Prevost answered:
In short, your problem is this:
Say you have two types, t1 and t2, and t1 is a subtype of t2.
Therefore, you can do (x : t1 :> t2) and coerce a value of type t1 to
a value of type t2. You cannot do (x : t2 :> t1). That's pretty
basic. Let's make an example:
type t1 = [ `A ]
type t2 = [ `A | `B ]
let t1_to_t2 (x : t1) = (x :> t2)
let x1 = `A
let x2 = `B
let x3 = t1_to_t2 x1
There. That's easy. It all works and types okay. The problem is at
the next level. Let's look at the type of your "store" class:
class virtual ['a] store :
object ('b)
method virtual access : 'a ext_rep
method virtual add : 'a -> unit
method virtual assign : 'b -> unit
method virtual copy : 'b
method virtual del : 'a -> unit
end
To see what the problem is, let's make some smaller examples with
similar features:
class ['a] c1 (v : 'a) =
let x = ref v in
object
method get = !x
method put v = x := v
end
let o1t1 = new c1 x1
let o1t2 = new c1 x2
let o1t3 = new c1 x3
val o1t1 : t1 c1 = <obj>
val o1t2 : t2 c1 = <obj>
val o1t3 : t2 c1 = <obj>
Okay. So that's working well. Now--we know we can cast t1 to t2.
Can we cast (t1 c1) to (t2 c2)? Let's see:
# let o1t1_t2 = (o1t1 :> t2 c1);;
This expression cannot be coerced to type
t2 c1 = < get : t2; put : t2 -> unit >;
it has type t1 c1 = < get : t1; put : t1 -> unit > but is here used with type
< get : t1; put : ([> t2 ] as 'a) -> unit; .. >
Type t1 = [ `A ] is not compatible with type 'a = [> `A | `B ]
The first variant type does not allow tag(s) `B
Looks like no. Why not? Well, let's think about it. What happens if
we get a value out of this object? The value is going to be `A,
because the initial object contains type t1. That's fine--if we give
`A to something that expects `A or `B, it can handle it. What happens
if we put a value into this object? Well, we can only put `A into it.
Aha! Here is the problem!
You can't use the value `B in a spot where only `A is expected to be!
Because the "put" method of o2 c1 takes `A|`B, and the "put" method of
o1 c1 only takes `A, we cannot cast a value of type (o1 c1) to (o2
c1)--if we did, we could give the object to code that wants to put `B
into it. This is called "contravariance", and you can identify it by
looking at the type signature. If a type argument appears on the
right side of the arrow (or there is no arrow), that type is
"covariant", and behaves as you were expecting. But if the type
argument appears on the left side of an arrow, it is
"contravariant"--it works the opposite way from what you were
expecting. If in a single type it is on *both* sides of the arrow,
then it is *invariant*. That is the case here.
With c1, look at the type:
class ['a] c1 : 'a -> object
method get : 'a
(* ^^ this indicates covariance, 'a is on the right *)
method put : 'a -> unit
(* ^^ this indicates contracariance, 'a is on the left *)
end
Because c1 is invariant in the type argument 'a, it doesn't matter
that t1 is a subtype of t2. The rules are like this:
If 'a is covariant in class c, then (t1 <: t2) implies (t1 c <: t2 c)
If 'a is contravariant in class c, then (t1 <: t2) implies (t2 c <: t1 c)
If 'a is invariant in class c, then neither holds, unless t1 = t2.
To make things a little more clear, let's break that down:
class ['a] covariant (x : 'a) = object method get = x end
class ['a] contravariant = object method put (x : 'a) = () end
class ['a] covariant : 'a -> object method get : 'a end
class ['a] contravariant : object method put : 'a -> unit end
Let's make some covariant objects and cast them:
let covariant_t1 = new covariant x1 (* OK *)
let covariant_t2 = new covariant x2 (* OK *)
let covariant_t1_as_t2 = (covariant_t1 :> t2 covariant) (* OK *)
let covariant_t2_as_t1 = (covariant_t2 :> t1 covariant) (* Error *)
t2 covariant is not a subtype of t1 covariant, so that last is an
error. Now we look at contravariant:
let contravariant_t1 = (new contravariant : t1 contravariant) (* OK *)
let contravariant_t2 = (new contravariant : t2 contravariant) (* OK *)
let contravariant_t1_as_t2 = (contravariant_t1 :> t2 contravariant) (* Error *)
let contravariant_t2_as_t1 = (contravariant_t2 :> t1 contravariant) (* OK *)
So here, the other case holds. And above, in the sample class c1,
both constraints were there, and things didn't work out.
As a final note, you can cast out the offending methods to get around
this. For example, if you use casting to remove the contravariant
methods from an object of your store class, you can then use the
resulting object covariantly (only reading data out of the object.)
If you use casting to remove the covariant methods from an object of
your store class, you can then use the resulting object
contravariantly (only writing data into the object.)
Archive: http://caml.inria.fr/archives/200410/msg00262.html
Christoph Bauer announced:
Schoca is an implementation of the Scheme language. The primary
purpose of Schoca is the use as an embedded extension language in
OCaml applications.
The new release 0.2.3 fixes a lot of bugs and the interpreter is
now faster. scmTypes.mli lists all scheme-data specific functions.
An init file for slib is included (example/schoca.init). (slib:report)
works but not much more. This will be improved.
The new location of Schoca's homepage is
http://home.arcor.de/chr_bauer/schoca.html
Have fun with functional programming,
Christoph Bauer
P.S.:
Changes for 0.2.3
o (define (f) 1)-Bug is fixed
o wrong parsing of a the string like "...\\" is fixed
o no termination of schoca shell when an exception occurs
o getenv returns #f on unset vars
o a lot of string functions (which uses string_of_datum instead od string_of_scm_string) are fixed
o (load (...)) is fixed (missing eval)
o parsing of symbols (or numbers) starting with a dot (`.') is fixed
o examples/schoca.init for slib is included
(install slib 3a1,
setenv SCHEME_LIBRARY_PATH
run (load "schoca.init"))
o cond bugs are fixed
o scm_eval (evaluation of arguments) is fixed
Changes for 0.2.2:
o much faster function calls (ack.scm 8.3s -> 5.9s)
Changes for 0.2.1 (not released)
o Fix for eq? on numbers.
o `truncate' is added
o documentation for ScmTypes
o some functions are renamed
Archive: http://caml.inria.fr/archives/200410/msg00269.html
Richard Jones announced:
I'm pleased to announce GregorianDate, which is a pure Objective CAML
library for handling calculations on the Gregorian calendar.
http://www.merjis.com/developers/gregorian_date
This is version 1.0.0, which is mature, stable and widely used (by
me). The library is released under the GNU LGPL with OCaml linking
exception.
Example:
$ ocaml -I +gregoriandate
Objective Caml version 3.08.1
# #load "gregorianDate.cma";;
# open GregorianDate;;
# days_in_year 2004;;
- : int = 366
# business_of_standard (2004, 10, 24);;
- : (int * int) * int = ((2004, 43), 7)
# easter_sunday 2005;;
- : int * int * int = (2005, 3, 27)
# day_of_week (2004, 10, 24);;
- : int = 7
# nth_weekday_of_month (2004, 10) 7 4;;
- : int * int * int = (2004, 10, 24)
# add_delta_days (2004, 10, 24) 100;;
- : int * int * int = (2005, 2, 1)
etc.
William Lovas asked and Richard Jones answered:
William Lovas wrote:
> Richard Jones wrote:
> > I'm pleased to announce GregorianDate, which is a pure Objective CAML
> > library for handling calculations on the Gregorian calendar.
>
> This looks cool, but i have a few suggestions. First, it needs some online
> documentation (beyond the examples), preferrably in ocamldoc format.
Yes, you're right, but I'm quite busy at the moment. There is
ocamldoc documentation in the tarball itself, and for an online
reference you should look at:
http://search.cpan.org/dist/Date-Calc/Calc.pod#DESCRIPTION
The API is pretty much identical, except that I have omitted Steffen's
time functions which really don't belong in this library.
> In
> particular, the following examples weren't transparent to me (a date
> non-specialist):
>
> > # business_of_standard (2004, 10, 24);;
> > - : (int * int) * int = ((2004, 43), 7)
[Sunday (7) in week 43 of year 2004.]
> > # nth_weekday_of_month (2004, 10) 7 4;;
> > - : int * int * int = (2004, 10, 24)
[Calculate the 4th Sunday (7) in October 2004.]
>
> I don't know what a "business" date is, and 10-24-2004 isn't a weekday.
> Actually, i think i just understood "nth_weekday_of_month", but
> documentation would certainly have been helpful.
For reference, business weeks are defined in ISO 8601, and you can
find a synopsis here:
http://www.cl.cam.ac.uk/~mgk25/iso-time.html
> > # day_of_week (2004, 10, 24);;
> > - : int = 7
> > etc.
>
> Also, you might consider enriching the interface with some types: i'd say
> at least that day of the week ought to be a variant. This not only makes
> thing safer, but also makes the intended behavior of functions like
> "nth_weekday_of_month" more apparent.
James Woodyatt said:
Similar functions [with different signatures] are also available in the
Cf_date module, along with lots of other goodies, distributed in the
"cf" package of the OCaml Network Application Environment
(http://sf.net/projects/ocnae/).
The Cf package is distributed under a 2-clause BSD license, and it
comes with Ocamldoc generated HTML pages. Download from the
SourceForge site.
Julien Signoles also replied to the original announcement:
What are the differences with the module Date of the "calendar" library ?
http://www.lri.fr/~signoles/prog.en.html
This library is also a pure OCaml library and released under the GNU
LGLP.
The aims of both libraries seem to be identical. An ocamldoc documentation
of calendar is available at:
http://www.lri.fr/~signoles/calendar/doc
Archive: http://caml.inria.fr/archives/200410/msg00272.html
Richard Jones announced:
I'm pleased to announce a substantial new release of COCANWIKI, the
wiki and content management system written in Objective CAML. It is
released under the GNU General Public License (GPL).
http://sandbox.merjis.com/
You can find a list of the features and differences over the previous
version here:
http://sandbox.merjis.com/features
http://sandbox.merjis.com/features/diff?version=5614
Debian packages are available:
http://sandbox.merjis.com/debian_packages
This is the page to use if you wish to try out editing:
http://sandbox.merjis.com/sandbox
http://sandbox.merjis.com/sandbox/edit
Archive: http://caml.inria.fr/archives/200410/msg00288.html
John Skaller announced:
Felix version 1.0.16 is now released under BSD style FFAU licence.
You can obtain it from
http://felix.sf.net/download
or from Gerd's Godi archive. Ocaml 3.0.8.1 or CVS version plus
Python and some kind of C++ compiler are required. It should
build on any Unix like platform including OSX and Cygwin.
[I need help to get a native Win32 version to build]
Felix is an Algol like language aimed at the C++ market,
but uses an ML style type system. The compiler is written
in Ocaml, and generates ISO C++. There is a heavy emphasis
on retaining C/C++ compatibility at both object and source
levels. It supports compile time parametric polymorphism,
overloading, recursive types, variants, first class
function closures, lexical scoping, garbage collection,
and type deduction for variables and function returns
(but no inference of arguments). It also provides
standard support for heavy microthreading (cooperative
multi-tasking with O(1) context switching), and features
a non-side effecting functional subsystem separated
from procedural code with support from the type system.
This release contains a freestanding FISh 1.6 implementation,
which I may integrate more closely later. FISh 1 is a
polyadic array procesing language capable of
outperforming C by up to 2:1 (with a C backend :).
Also new is support for STL built into the standard
distribution.
Optimisation is still flaky, however Felix is outperforming
Ocaml bytecode interpreter in the Alioth shootout.
Archive: http://caml.inria.fr/archives/200410/msg00292.html
Achim Blumensath announced:
I'm pleased to announce the release of ant version 0.6. The archive can
be found at
http://www-mgi.informatik.rwth-aachen.de/~blume/Download.html
ant is a typesetting system inspired by TeX. It does not aim at complete
compatibility with TeX but focusses instead on a flexible, clean, and
modular design.
This version of ant finally implements all major parts of TeX. But there
are still a lot of small things missing. New features include:
o an improved page layout algorithm with support for floats and
footnotes
o an integrated scripting language
Achim
PS: Yes, I do know about Apache Ant.
Archive: http://caml.inria.fr/archives/200410/msg00293.html
Berke Durak announced:
Debian users might be interested in Flare which allows to do boolean
regexp searches on the Debian package database in a LablGTK2 GUI.
It was based on ara (which is available via APT) but includes much
better syntax and fixes some database issues (ie ara in its current
version does not scan properly all package database files).
Flare is not yet available via APT but can be downloaded in source
form at
http://abaababa.ouvaton.org/ara/
Feel free to send all comments and suggestions for some final fixes
before inclusion in Debian.
ExtLib 1.3 is available through Sourceforge : http://ocaml-lib.sf.net
ExtLib is a project aiming at providing a complete - yet small - standard
library for the OCaml programming langage. The purpose of this library is to
add new functions to OCaml Standard Library modules, to modify some
functions in order to get better performances or more safety
(tail-recursive) but also to provide new modules which should be useful for
the average OCaml programmer.
Changes for 1.3 :
- new module OptParse (by Bardur Arantsson) : GNU [getopt(3)]-style command
line parsing
- new module Dllist (by Jesse Guardiani and Brian Hurt) : A mutable,
imperative, circular, doubly linked list
- fixed bugs in Bitset and IO modules
- and some minor other changes...
Nicolas Cannasse added:
The TGZ have just been updated, the previous one was missing some file, if
you just downloaded it please retry.
Sorry for the inconvenience,
Ah and yes : ExtLib is LGPL with linking exemption, the same license as
Ocaml uses for its libraries :)
ML Seattle will meet next Wednesday Nov. 3 at 7pm at the Stumbling Monk in
Capitol Hill.
The Seattle ML SIG will be moving its regular meeting announcements off
caml-list. Our wiki and mailing list are available with those of the SF Bay
Area SIG:
http://www.mlsig.org
We meet every three weeks. The wiki will post our next scheduled meeting when
we have scheduled it.
For the sake of new residents or visitors to Seattle, and those in Seattle
finding caml-list, we will continue to broadcast announcements at less
frequent, unscheduled intervals. If practical, we will attempt to coordinate
with the other area SIGs to minimize caml-list traffic. For those who do not
and never will have interest about users in Seattle, our apologies. We promise
to be mindful of the greater good.
Dear caml-list subscribers,
After many years of using Majordomo on our old server (pauillac), the
caml-list mailing list is now managed by the Mailman software running
on our new server (yquem).
Mailman gives subscribers more flexibility to handle the list
traffic. For instance, you can elect to receive the list as a daily
digest. All options can be controlled via the Web interface at
http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
You should have received yesterday an individual e-mail giving more
detailed instructions, including your actual subscription address.
Unlike what this e-mail says, messages to the list can (and should)
still be sent to caml-list@inria.fr.
Since one of you asked: yquem is named after Château Yquem, a famous
dessert white wine from the Bordeaux area.
Here is a quick trick to help you read this CWN if you are viewing it using vim (version 6 or greater).
:set foldmethod=expr
:set foldexpr=getline(v:lnum)=~'^=\\{78}$'?'<1':1
zM
If you know of a better way, please let me know.
If you happen to miss a CWN, you can send me a message and I'll mail it to you, or go take a look at the archive or the RSS feed of the archives.
If you also wish to receive it every week by mail, you may subscribe online.