Several days ago, bluestorm and I started working on monads-related stuffs for Batteries, so that we’d be able to provide a good API for writing and using monads in Objective Caml.

Well, we’ve now written the basis of the future monad-related functions and modules in Batteries.

Of course, we’ve introduced two key monads, keeping Batteries’ spirit : the Option monad and the Enum monad. The first is the equivalent of Haskell’s Maybe monad, whereas the latter is somehow “equivalent” to Haskell’s List monad, with the difference that Batteries’ key data structure is Enum, whereas Haskell’s standard library’s is List.

We’ve also written two key functions for working with monads… If you are familiar with foldM and sequence in Haskell, working over lists, you won’t be lost when using our fold_monad and sequence functions, working over enums.

Hey, wait a minute…

OCaml’s hasn’t typeclasses ! How can we “overload” bind and return and make sequence and fold_monac guess what is the monad they have to work in ?
The answer is the pa_openin syntax extension.

Now, even if we’re working on adding some trivial uses of our monad related stuffs in Batteries’ testsuite, you can take a look at the following sample which works on my local Batteries version…

1
2
3
4
5
6

# let module M = Option.Monad in open Enum.WithMonad(M),M in
       sequence [? Some x |x <- 1--100 ] ;;
- : int Batteries.Enum.t option = Some <abstr>
# let module M = Option.Monad in open Enum.WithMonad(M),M in
       sequence (List.enum [Some 1; None ; Some 3]) ;;
- : int Batteries.Enum.t option = None

By the way, do you think, you, user, the (>>=) operator should be provided by default in our XXX.Monad modules ?

Enjoy !

[Link : my git commit]

The Prolog programming language includes this feature. In fact, as I’m working with SWI-Prolog, I know this feature is (well) covered by this Prolog distribution but I suppose that other distributions also give tools for network programming in Prolog.

SWI-Prolog’s network programming module is a binding of the C POSIX API so its use is quite similar.

Here is some predicates of the socket library.

• tcp_socket(-SocketId)
• tcp_close_socket(+SocketId)
• tcp_open_socket(+SocketId, -InStream, -OutStream)
• tcp_bind(+Socket, ?Port)
• tcp_listen(+Socket, +Backlog)
• tcp_accept(+Socket, -Slave, -Peer)
• tcp_connect(+Socket, +Host:+Port)
• udp_socket(-Socket)
• udp_receive(+Socket, -Data, -From, +Options)
• udp_send(+Socket, +Data, +To, +Options)

For tcp sockets, you can simply use the write* and read* predicates.

To use those functions, sometimes you’ll have to put :

1

:- use_module(library(socket)).

at the beggining of your Prolog source file.

Here is a sample Prolog program that creates a server. When a client gets connected to the server, it sends it Welcome on myPrologServer and then closes the connection.
<

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

:- use_module(library(socket)).
 
init :-
	create_server(2302,'Welcome on myPrologServer\n').
 
create_server(Port,Txt) :-
	tcp_socket(Socket),
	tcp_bind(Socket,Port),
	tcp_listen(Socket,5),
	tcp_open_socket(Socket,AcceptFd,_),
	server_loop(AcceptFd,Txt).
 
server_loop(AcceptFd,Txt) :-
	tcp_accept(AcceptFd,Socket2,_),
	tcp_open_socket(Socket2,In,Out),
	write(Out,Txt),
	close(In),
	close(Out),
	server_loop(AcceptFd,Txt).

The code is quite short and is very easy to understand.

Now, launch swipl, consult your file (test_socket.pl for me) and launch the init predicate.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

$ swipl
Welcome to SWI-Prolog (Multi-threaded, Version 5.6.47)
Copyright (c) 1990-2007 University of Amsterdam.
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
Please visit http://www.swi-prolog.org for details.
 
For help, use ?- help(Topic). or ?- apropos(Word).
 
?- consult('test_socket.pl').
%     library(error) compiled into error 0.01 sec, 7,508 bytes
%    library(lists) compiled into lists 0.02 sec, 19,312 bytes
%   library(shlib) compiled into shlib 0.02 sec, 34,280 bytes
%  library(socket) compiled into socket 0.02 sec, 40,536 bytes
% test_socket.pl compiled 0.02 sec, 41,872 bytes
 
Yes
?- init.

Then, your server is waiting for connections.
I used telnet to connect to my server :

1
2
3
4
5
6
7

$ telnet
telnet> open localhost 2302
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Welcome on myPrologServer
Connection closed by foreign host.

You can see that everything works fine.

Using both the socket module and the multithreading module of SWI-Prolog will let you create strong and efficient servers/clients and show everybody that nothing is impossible in Prolog

The documentation of the network module is included in SWI-Prolog’s C-library’s one, at the following URL : http://www.swi-prolog.org/packages/clib.html#sec:5.

You have now everything needed to write Prolog programs interacting with any servers/clients in the world using the SWI-Prolog C-library’s socket module !

Writing UIs in Prolog is a very simple thing !

First, with SWI-Prolog, there’s a dialog editor based on Drag & Drop, like we have for Java, C# or C++, and it generates a prolog-xpce code that we just have to execute to see the window being shown on our screen.

However, we can manually write code with XPCE predicates.

Just see it in action. Here is a code that shows a 250×100 window with a text label.

1
2
3
4
5
6
7
8
9
10
11
12
13

:- use_module(library(pce)).
 
my_first_program :-
	% creates the window
	new(D, window('Ma premiere fenetre')),
	% resize the window
	send(D, size, size(250, 100)),
	% creates a textlabel
	new(T, text('Hello World !')),
	% displays the textlabel at the given point
	send(D, display, T, point(80, 40)),
	% show the window
	send(D, open).

Save it as xpce.pl for example.

Then, open a terminal. Launch xpce.

$ xpce
XPCE 6.6.44, October 2007 for i386-linux-gnu and X11R6
Copyright (C) 1993-2007 University of Amsterdam.
XPCE comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
The host-language is SWI-Prolog version 5.6.47

For HELP on prolog, please type help. or apropos(topic).
         on xpce, please type manpce.

?-

Then just use consult :

1
2
3
4

?- consult('xpce.pl').
% xpce.pl compiled 0.01 sec, 1,280 bytes
 
Yes

and launch your predicate :

1

?- my_first_program.

You’ll obtain something like the following image.

Have fun with XPCE !

The Prolog programming language permit for example to use logic programming and constraint programming which are uncommon paradigms.

This language is mainly based on the backtracing and unification principles.

If you can read French, you should give a whirl at the following article : Présentation du langage Prolog.

If you can’t, you should give a whirl at this website : Learn Prolog Now !.

A sample code for calculating the size of a list (even if it already exists), in Prolog.

1
2
3
4
5

my_list_size([],0).
 
my_list_size ([H|L], S) :-
  my_list_size(L, S1),
  S is 1+S1.

My Prolog environment is SWI-Prolog and I use SWI-Prolog’s XPCE for User Interfaces.