L'autre nuit, muni de café, j'ai souhaité m'amuser avec Haskell. J'ai alors consulté le chapitre sur le réseau en Haskell de Real World Haskell et... j'ai écrit un (très petit) clône de client telnet... qui fait 41 lignes. Le seul soucis étant que dans toute application de ce genre, on doit partager habilement la lecture des entrées de l'utilisateur, et l'affichage de ce que l'on nous envoie. Ceci mis à part, tout cela fonctionne très bien !

Regardons à quoi cela ressemble. Petit détail : à chaque tour, je lance la réception de données réseau dans un autre thread, pour ne pas bloquer l'écriture de l'utilisateur.

On importe d'abord les modules nécessaires.

import Control.Concurrent 
import Control.Monad 
import Network.Socket 
import Network.BSD 
import System.Environment 
import System.IO

Ensuite, j'ai écrit quelques fonctions pour rendre la connection, l'envoi etc plus faciles.

-- Ouverture d'une connexion TCP cliente 
-- Prend en argument l'host et le port/service (qui est une String également) 
-- Retourne le "Handle" vers le socket en question. 
openConnection :: String -> ServiceName -> IO Handle 
openConnection hostname port = 
  do 
  addrInfos <- getAddrInfo Nothing (Just hostname) (Just port) 
  let serveraddr = head addrInfos 
  sock <- socket (addrFamily serveraddr) Stream defaultProtocol 
  setSocketOption sock KeepAlive 1 
  connect sock (addrAddress serveraddr) 
  h <- socketToHandle sock ReadWriteMode 
  hSetBuffering h (BlockBuffering Nothing) 
  return h 
 
-- Ferme la connexion dont le Handle est donné 
closeConnection :: Handle -> IO () 
closeConnection h = hClose h 
 
-- Envoie la chaîne donnée sur le Handle donné, et ensuite fait un flush sur ce handle, ce qui force l'envoi immédiat et nettoie les états 
sendMsg :: Handle -> String -> IO () 
sendMsg h msg = hPutStrLn h msg >> hFlush h 
 
-- Lis sur le Handle donné une chaîne et la renvoie (dans la monade IO) 
recvMsg :: Handle -> IO String 
recvMsg h = do 
  msg <- hGetContents h  
  return msg

Voyons maintenant la fonction main.

main = do 
  args <- getArgs 
  let (host, port) = (args !! 0, args !! 1)

On récupère les arguments donnés au programme (s'il n'y en a pas assez, cela fera planter le logiciel -- je ne me suis pas vraiment préoccupé de tous les cas d'erreur, mais ce n'était pas ma priorité ici) via la fonction getArgs, et l'on en récupère l'host et le port donnés.

  putStrLn $ "Opening client on " ++ host ++ ":" ++ port ++ "\n" 
  hclient <- openConnection host port 
  putStrLn "Client connected"

Ca y est, on se connecte, en affichant des messages pour tenir l'utilisateur informé. Si la connection échoue, le programme s'arrêtera avec une erreur -- cf remarque ci-dessus.

Et maintenant, la boucle qui permet de lire depuis le réseau et lire depuis l'utilisateur, etc.

  forever $ do 
    getLine >>= sendMsg hclient 
    forkIO $ recvMsg hclient >>= putStrLn

Ici, on a une sorte de boucle "à la while(true)", dans laquelle on va tour à tour récupérer une entrée de l'utilisateur et l'envoyer au serveur, puis, dans un thread séparé, récupérer ce qu'a envoyé le serveur et l'afficher.
Enfin, on ferme la connection (ce code est inutile tant que l'on a pas de possibilité de sortir du forever... qui devra tôt ou tard se transformer en "until" ou autre).

  closeConnection hclient

Voilà le code complet :

import Control.Concurrent 
import Control.Monad 
import Network.Socket 
import Network.BSD 
import System.Environment 
import System.IO 
 
openConnection :: String -> ServiceName -> IO Handle 
openConnection hostname port = do 
  addrInfos <- getAddrInfo Nothing (Just hostname) (Just port) 
  let serveraddr = head addrInfos 
  sock <- socket (addrFamily serveraddr) Stream defaultProtocol 
  setSocketOption sock KeepAlive 1 
  connect sock (addrAddress serveraddr) 
  h <- socketToHandle sock ReadWriteMode 
  hSetBuffering h (BlockBuffering Nothing) 
  return h 
 
closeConnection :: Handle -> IO () 
closeConnection h = hClose h 
 
sendMsg :: Handle -> String -> IO () 
sendMsg h msg = hPutStrLn h msg >> hFlush h 
 
recvMsg :: Handle -> IO String 
recvMsg h = do 
  msg <- hGetContents h  
  return msg 
 
main = do 
  args <- getArgs 
  let (host, port) = (args !! 0, args !! 1) 
  putStrLn $ "Opening client on " ++ host ++ ":" ++ port ++ "\n" 
  hclient <- openConnection host port 
  putStrLn "Client connected" 
  forever $ do 
    getLine >>= sendMsg hclient 
    forkIO $ recvMsg hclient >>= putStrLn 
  closeConnection hclient

Compilation :

ghc --make -o net net.hs

Puis 2 exemples d'exécution...

$ ./net google.fr 80
Opening client on google.fr:80
Client connected
GET / HTTP/1.0
HTTP/1.0 302 Found
Location: http://www.google.fr/
Cache-Control: private
Content-Type: text/html; charset=UTF-8
Set-Cookie: PREF=ID=30b094ad566b5532:TM=1251456529:LM=1251456529:S=94IXp5-SGiaYADWc; expires=Sun, 28-Aug-2011 10:48:49 GMT; path=/; domain=.google.com
Date: Fri, 28 Aug 2009 10:48:49 GMT
Server: gws
Content-Length: 218 



302 Moved
The document has moved
here.
 

^C

(c'est moi qui ai tapé "GET / HTTP/1.0")
( qui vous dira que la page a été déplacée )

Et enfin, la surprise...

$ ./net towel.blinkenlights.nl 23

Qui, une version simplifiée d'un film très connu, vous permettra de voir, Jedi.

Enjoy !

J'ai écrit un petit programme OCaml de Boucing Ball, une balle qui rebondit contre les bords de la fenêtre, où l'on peut augmenter la vitesse en X et en Y avec les touches du clavier.
Il utilise OCamlSDL, un binding de la désormais célèbre bibliothèque SDL pour le langage OCaml.

Voici ce que cela donne.

Boucing Ball en action

Si vous voulez tester et/ou améliorer ce programme, qui peut soit dit en passant servir de base pour un Pong ou autre jeu de ce genre, vous trouverez le code source ici : bbsdl.tar.gz.

Enjoy.

Peut-être avez-vous déjà entendu parler de ce projet ... OCaml Batteries Included.

Ce projet couvre pour le moment un certain nombre de domaines. Il fournit une certaine quantité de structures de données, de fonctions pour la programmation concurrente, etc. Qui plus est, il inclut des extensions de syntaxes qui pourront s'avérer très utile, ainsi que de nouveaux opérateurs pour rendre le code OCaml plus lisible et concis, ce qui finalement fait gagner en lisibilité (notamment pour l'enchainement de fonctions, comme lorsque l'on appelle une série de fonctions opérant sur une chaîne de caractères, en passant le résultat d'une fonction à la suivante, et ainsi de suite). Je ne vais pas lister les bibliothèques, ce serait trop long.

OCaml Batteries Included est sortie en version Bêta 1 il y a quelques jours. Qui plus est, l'équipe OCaml-Debian-Maintainers a mis à disposition un paquet ocaml-batteries-included qui est dans le dépôt testing officiel, n'hésitez pas !

Pour finir, quelques liens :
Site officiel
Documentation de l'API
Documentation de la plateforme
Billet de blog sur la publication de la Beta 1

Enjoy !

J'inaugure mon compte sur ce blog en y postant mon premier billet, sur Haskell qui plus est !

Je vais vous montrer puis vous expliquer un moyen simple de supprimer toutes les instances d'un caractère donné dans une chaîne, en Haskell... en une ligne, oui.
Il s'agit donc par exemple de pouvoir supprimer tous les 'a' dans (je vais faire dans l'original) le titre de ce billet !

"Supprimer toutes les instances d'un caractère dans une chaîne en Haskell"
doit donc devenir :
"Supprimer toutes les instnces d'un crctère dns une chîne en Hskell"

Voici comment faire, en utilisant la fonction filter que nous expliquerons plus bas.

strip :: Char -> String -> String
strip c s = filter (/= c) s

Premièrement, regardons le type de cette fonction.
Elle prend a deux arguments : un caractère et une chaîne de caractères (qui, en Haskell, est définie comme une liste de caractères [Char]). Elle retourne une chaîne de caractères ; c'est bien ce que l'on désire.

Regardons ensuite la seconde ligne : c désigne le fameux caractère à supprimer et s la chaîne dans laquelle le supprimer.

Nous faisons ensuite appel à la fonction filter qui prend un prédicat à un argument (une fonction d'un argument qui retourne un booléen) et qui s'applique ensuite sur une liste, donnée en second argument. Elle retourne une liste où seuls les éléments vérifiant le prédicat sont restés. Je tiens à rappeler que Haskell étant un langage fonctionnel, on ne modifie pas la liste, on en retourne une nouvelle. N'ayez crainte, ça ne va pas faire des programme lourd, il y a de belles optimisations qui tournent derrière.

Mettez le code précédent dans un fichier strip.hs par exemple, et chargez-le dans GHCi via :load strip.hs (en vous assurant que vous êtes dans le bon répertoire). Puis testons :

*Main> strip 'a' "Supprimer toutes les instances d'un caractères dans une chaîne en Haskell"
"Supprimer toutes les instnces d'un crctères dns une chîne en Hskell"

Notons toutefois que le code ci-dessus peut-être encore plus court !
En effet, nous avons indiqué la chaine "s" alors que l'on peut s'en passer et écrire cela :

strip :: Char -> String -> String
strip c = filter (/= c)

Et encore, on sent que strip n'est définissable qu'avec filter et l'opérateur /= ... Et bien tout à fait !

strip :: Char -> String -> String
strip = filter . (/=)

Cette propriété se nomme êta-réduction et rend le code bien plus sobre, concis et clair. En effet, en Haskell, après un certain temps, on parvient à écrire du code qui n'est presque qu'un enchainement de compositions de fonctions, de sorte qu'une ligne ne soit presque qu'une phrase, si l'on nomme bien les fonctions.

Je rappelle que le '.' est tout simplement l'opérateur de composition de fonctions, et il suffit de regarder son type pour s'en convaincre :
Tapez :t (.) dans GHCi pour vous en convaincre, il vous dira ceci :

*Main> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c

Ce qui signifie en gros :

Pour tous types a, b et c (polymorphisme inside), l'opérateur . prend deux fonctions, l'une (disons g) du type b vers le type c, l'autre (disons f) du type a vers le type b, et elle en fait la composition pour obtenir une fonction qui va du type a vers le type c.

C'est exactement ce que fait l'opérateur 'o' en Mathématiques ; en effet, g . f en Haskell est équivalent à g o f en Mathématiques.

Voilà pour mon premier billet ici.

Si vous avez découvert Haskell par ce billet et que vous souhaitez vous y mettre, voici quelques liens essentiels :
http://www.haskell.org/ : Site officiel, où l'on peut télécharger compilateur, interpréteur, outils & bibliothèques divers et variés mais également consulter des tutoriels/cours sur Haskell - c'est le QG de tous les programmeurs Haskell
http://en.wikibooks.org/wiki/Haskell : Le Wikibook sur Haskell
http://book.realworldhaskell.org/read/ : Le livre 'Real World Haskell' qui est disponible gratuitement en lecture en ligne
Et pour terminer, il y a le salon #haskell (et #haskell.fr, mais ce dernier est peu actif) sur le réseau IRC Freenode.

A bientôt !