Previous week Up Next week

Hello

Here is the latest Caml Weekly News, for the week of July 1 to 8, 2008.

  1. ooauth 0.1
  2. ethreads relesase
  3. Logic File System
  4. Newbie question: OCaml equivalent of Haskell's show?
  5. Bisect 1.0 alpha

ooauth 0.1

Archive: http://groups.google.com/group/fa.caml/browse_thread/thread/a276b47d2a7301f6

Jake Donham announced:
Skydeck is pleased to announce ooauth, an implementation of the OAuth
1.0 protocol for OCaml, as well as an OCaml binding to our web API
(providing access to your cell phone call log). More at

 http://skydeck.com/blog/announcements/skydeck-api-and-oauth-for-ocaml/

The OAuth library provides both the "service provider" and "consumer"
sides of OAuth, so you can use it to build a web API of your own, or
to access one of the increasing number of APIs supporting OAuth (such
as the Google data APIs). More at

 http://oauth.net/

If you'd like to try Skydeck (and have a cell phone with a major
American carrier), drop me an email (of course you don't need a
Skydeck account to use the OAuth library).
			

ethreads relesase

Archive: http://groups.google.com/group/fa.caml/browse_thread/thread/a70e7429bb382275

Satoshi Ogasawara announced:
I'm pleased to announce a new release of 'ethreads', small codes for
multi-thread programming. This library has
- extended Threads.Event module.
- threadless ivar and mvar, inter-thread shared variable.
- mailbox(queue), broadcast channel, timeout, meta-RPC.
I believe these features are necessary for channel passing style multi-thread 
programming with OCaml.
More at: 
Project Home Page:  http://forge.ocamlcore.org/projects/ethread/
Signatures : http://www.itpl.co.jp/ethreads/
			

Logic File System

Archive: http://groups.google.com/group/fa.caml/browse_thread/thread/d190955371ca664f

Yoann Padioleau announced:
I am pleased to announce the release of the Logic File System (LFS).
LFS is a very expressive file system coded in OCaml.
LFS enables the user to access his files through an
additionnal mountpoint, /lfs, where powerful logic queries can be
issued and navigation can be done through different dimensions, like
date, size, or extension. For instance, LFS allows the user to perform
the following commands in the shell:

$ cd /lfs/ext:mp3|ext:ogg/year:1973/genre:Disco/
$ ls
artist:BeeGees/ artist:DonnaSummer/ artist:Chic/ ...
$ cd /lfs/ext:ml|ext:mli/.ext
$ ls
list.ml list.mli array.ml array.mli ...


It uses FUSE (and ocamlfuse). LFS just acts like an additionnal way to
access your files.
No need to migrate your data to LFS.


Homepage:
http://aryx.kicks-ass.org/~pad/wiki/wiki-LFS/doku.php
Tar/GZ:
http://aryx.kicks-ass.org/~pad/software/project-lfs/lfs-0.5.tgz
Quick install guide:
http://aryx.kicks-ass.org/~pad/wiki/wiki-LFS/doku.php?id=quickguide
Tutorial:
 http://aryx.kicks-ass.org/~pad/wiki/wiki-LFS/doku.php?id=syntax
			

Newbie question: OCaml equivalent of Haskell's show?

Archive: http://groups.google.com/group/fa.caml/browse_thread/thread/de74ef19c7864194

Antony Courtney asked and Richard Jones answered:
> I'm an experienced Haskell hacker trying OCaml for the first time. 
> 
> One thing I am desperately searching for but have been unable to find 
> is some direct runtime access to the string representation of 
> arbitrary OCaml values.  I have written a little option pricer that 
> constructs a 
>    float option array array 
> in a function.  I've got a little buglet in my function so I'd like to 
> print the intermediate states of this value from inside the function. 
> How do I do that, short of writing my own recursive pretty printer / 
> formatter?  An OCaml form of the Haskell Show type class would be 
> great, but a hack to provide programmatic access to the polymorphic 
> pretty printer that obviously already exists in the OCaml toplevel 
> would be fine. 
> 
> I've scoured the standard library docs, manual, tutorials and a few 
> books, looked at the FAQ and am amazed that I haven't found the answer 
> to this.  I am hopefully just missing something obvious; would be 
> grateful if someone could point me towards the answer!

Note that OCaml doesn't carry very much information at runtime about 
what is represented in a value.  However there are various generic 
printers around.  Probably your best bet for a quick and dirty hack is 
to use the 'Std.dump' function in extlib 
(http://code.google.com/p/ocaml-extlib/).  This can turn anything into 
a string, and tries to produce something which looks similar to an 
OCaml toplevel value. 

Documentation for Std.dump: 
  http://ocaml-extlib.googlecode.com/svn/doc/apiref/Std.html 

If you want to go further than this and have OCaml write a pretty- 
printer for your types, then you'll want to look at one of the 
following projects (and probably others ...) 

  http://www.ocaml.info/home/ocaml_sources.html 
  http://code.google.com/p/deriving/ 
  http://tools.assembla.com/tywith/wiki 

Another alternative is to run your code in the OCaml toplevel. 
			
Jon Harrop also answered:
> One thing I am desperately searching for but have been unable to find
> is some direct runtime access to the string representation of
> arbitrary OCaml values.

OCaml has no run-time type information, no structural pretty printers in 
compiled code and no type classes to help you implement your own in source 
code.

> I have written a little option pricer that constructs a
>   float option array array
> in a function.  I've got a little buglet in my function so I'd like to
> print the intermediate states of this value from inside the function.
> How do I do that, short of writing my own recursive pretty printer /
> formatter?

You basically have two choices:

.. Run in the top-level and get the value you require as the result of 
evaluating an expression (e.g. by raising an exception, or by setting a 
mutable).

.. Write your own print function(s) and call them.

The benefit of the latter is, of course, that it works from compiled code.

> An OCaml form of the Haskell Show type class would be great,

IMHO, type classes are great for some things but pretty printing is not one of 
them.

Start with a function to print a list with an arbitrary separator:

# open Format;;
# let rec fprintfs sep f ff = function
   | [] -> ()
   | [h] -> fprintf ff "%a" f h
   | h::t -> fprintf ff "%a%a%a" f h sep () (fprintfs sep f) t;;
val fprintfs :
 (Format.formatter -> unit -> unit) ->
 (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a list -> unit =
 <fun>

For example, we can now write a function to pretty print a list in Mathematica 
notation:

# let fprintf_mma ff list =
   let sep ff () = fprintf ff ",@ " in
   let int ff = fprintf ff "%d" in
   fprintf ff "{@[%a@]}" (fprintfs sep int) list;;
val fprintf_mma : Format.formatter -> int list -> unit = <fun>

# fprintf std_formatter "%a\n" fprintf_mma (Array.to_list(Array.init 100 (fun 
n -> n)));;
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
97, 98, 99}
- : unit = ()

Note the automatically-aligned wrapping thanks to OCaml's pretty 
printing "Format" module and the use of "@[", "@ " and "@]" in my code. This 
also works from compiled code and is an excellent way to print indented 
source code (e.g. when generating other languages).

To pretty print a generic array:

# let fprintf_array f ff array =
   let sep ff () = fprintf ff ";@ " in
   fprintf ff "[|@[%a@]|]" (fprintfs sep f) (Array.to_list array);;
val fprintf_array :
 (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a array -> unit =
 <fun>

To print an option:

# let rec fprintf_opt f ff = function
   | None -> fprintf ff "None"
   | Some x -> fprintf ff "Some %a" f x;;
val fprintf_opt :
 (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a option -> unit =
 <fun>

Now you can print your array of arrays of float options:

# let print ff xss =
   let float ff = fprintf ff "%g" in
   fprintf_array (fprintf_array (fprintf_opt float)) ff xss;;
val print : Format.formatter -> float option array array -> unit = <fun>

# fprintf std_formatter "%a\n" print
   [|[|Some 3.; None; None|]; [|None; Some 5.; None|]; [|Some 1.|]|];;
[|[|Some 3; None; None|]; [|None; Some 5; None|]; [|Some 1|]|]
- : unit = ()

> but a hack to provide programmatic access to the polymorphic 
> pretty printer that obviously already exists in the OCaml toplevel
> would be fine.

In addition to Richard's suggestions, you might look at generating OCaml 
expressions using camlp4 and then printing those instead. Just an idea (I've 
never tried it).

> I've scoured the standard library docs, manual, tutorials and a few
> books, looked at the FAQ and am amazed that I haven't found the answer
> to this.  I am hopefully just missing something obvious; would be
> grateful if someone could point me towards the answer!

Surprisingly, structural printing is something that OCamlers rarely do. As 
part of my evolution as a programmer I had migrated everything from C++ and 
Mathematica to OCaml a few years ago but I am actually about to move a little 
parsing-related project from OCaml to F# simply because its built-in pretty 
printers make life so much easier.

Anyway, I shall write an OCaml Journal article about OCaml's 
wonderful "Format" module. Incidentally, the OCaml Journal has recovered from 
a lull in Q1 and has really started to pick up now. So I still think there is 
plenty of opportunity for budding authors to write OCaml books!
			

Bisect 1.0 alpha

Archive: http://groups.google.com/group/fa.caml/browse_thread/thread/542554fe46aca51a

Xavier Clerc announced:
This post announces the 1.0 alpha version of Bisect.
Bisect is a coverage tool for the Objective Caml language.
Home page: http://bisect.x9c.fr

Features:
 - lightweight tool
 - camlp4-based instrumentation of source files
 - HTML-based report with replica of original source code annotated with coverage information
 - per-file and application-wide statistics

Dependencies:
 - Objective Caml 3.10.2
 - Unix module

Planned features:
 - other report formats (framed HTML, XML, bare text)
 - thread support
 - some nice features borrowed from HPC 
(http://projects.unsafeperformio.com/hpc/)


This is my very first non-trivial camlp4-based application, and would be glad
to hear comment and suggestions about Bisect, and the way it could be
enhanced.
			

Using folding to read the cwn in vim 6+

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}$'?'&lt;1':1
zM

If you know of a better way, please let me know.


Old cwn

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.


Alan Schmitt