F# ?!

[(gile)]

Salut,

 

 

F# est le nouveau langage développé par Microsoft pour la plateforme .NET (voir ici et là).

 

 

C'est un langage de programmation fonctionnel et à ce titre il devrait intéresser au plus haut chef ceux qui aiment le LISP pour ça (fonctions comme arguments de fonctions, fonctions anonymes, récursivité, ...) et voudraient passer à la vitesse supérieure.

 

Étant développé pour la plateforme .NET il permet, bien sûr, d'accéder à toutes les librairies du NET Framework ainsir que l'API .NET d'AutoCAD et peut aussi prendre en charge les programmations orientée objet et impérative (procédurale).

 

 

Il devrait réjouir ceux qui affectionnent les codes concis.

 

Un exemple de fonction qui retourne tous les fichiers correspondant au modèle (pat) du dossier ou disque (dir) et de ses sous dossiers en écartant les dossier avec accès limité.

 

 

Utilisation : FindFiles "C:\" "*.fs"

 

 

let rec FindFiles dir pat =
   try Array.append
           (Directory.GetFiles(dir, pat))
           (Array.collect (fun x -> FindFiles x pat) (Directory.GetDirectories dir))
   with _ -> Array.empty

 

 

 

qui peut s'écrire aussi :

 

let rec FindFiles dir pat =
   try Directory.GetDirectories dir 
       |> Array.collect (fun x -> FindFiles x pat)
       |> Array.append (Directory.GetFiles (dir, pat))
   with _ -> Array.empty

 

 

Si d'aucuns sont tentés dans l'aventure, je les invite à me rejoindre ici dans mes découvertes...

[VDH-Bruno]

Bonsoir,

 

Ca donne envie mais faut se montrer raisonnable je viens juste de débuter en Lisp, alors dans 2 ou 3 ans peut-être… :D

 

Si je réagi à ton post c’est parce que, j’ai été très agréablement surpris de reconnaitre la syntaxe OCaml que j’ai découvert tout récemment il y a 2 ou 3 semaines. En continuant pour ma culture personnel mes recherches sur la récusions terminal, le Lisp implémenté dans AutoCAD n’étant pas optimisé pour cela.

 

Les meilleures discussions francophones que j’ai trouvées sur ce thème, je les ai trouvés en OCaml (langage apparemment utilisé pour l’enseignement de la programmation en France), j’ai été très surpris avec qu’elle facilité il m’a été possible de les traduire en Lisp.

 

Avec le peu de recul que j’ai, je pense qu’effectivement c’est une bonne nouvelle pour les lispeurs chevronnés vu que d’après le lien F# est dérivé d’ OCaml.

 

(Ps : Pour la vitesse supérieure, j’aimerai bien mais je ne me sens pas encore prêt ;) )

 

[Tramber]

C'est pas pour faire le clown mais quand j'ai vu F#, j'ai pensé F### et me suis demandé pourquoi, (gile) tu te mettais à jurer et en Anglais.

Véridique. :cool:

 

Ca veut dire quoi en clair ? Qu'il apparait un nouveau langage ? Et qu'il sera plus facile de l'apprendre pour un mono-compétant lisp que le serait le C++ ?

[bonuscad]

Ma réponse est plutôt une pause café... ;)

 

La trottinette, le vélo, le gros cube et la F1.

 

Ce qui donne dans l'ordre.

 

Autolisp, Visual-Lisp/ActiveX, Net et F#.

 

 

Je suis resté expert en trottinette, apprenti en vélo, émerveillé mais nul en gros cul , bouche bée et complétement idiot en Formule1... ;)

[(gile)]

Salut,

 

Pour essayer de rapidement clarifier les choses.

 

dotNET est une technologie développée par Microsoft (qui s'inspire largement de ce qu'avait fait Sun MicroSystems avec Java et sa machine virtuelle).

Il s'agit, en gros, d'une plateforme de développement qui utilise un ensemble de bibliothèques : le .NET Framework, indépendamment des langages de programmation. Les codes, quelque soit le langage utilisé par le programmeur, sont pré-compilés (génération de dll ou exe) dans un même langage intermédiaire appelé Common Intermediate Language (CIL). Il ne seront compilés à la volée en langage machine qu'au moment de leur première exécution par la machine virtuelle en fonction du type de processeur .

 

Du fait de la structure du NET Framework en bibliothèques de classes, .NET est complètement adapté à la Programmation Orientée Objet (POO).

 

Comme la plateforme NET est construite pour supporter plusieurs langages, Microsoft à dû développer quelques langages :

Microsoft Visual C# a été développé spécialement

Visual Basic .NET est une adaptation de VB

Microsoft Visual C++ (managed) est une adaptation de C++

Microsoft Visual J# est dérivé de Java

Les deux derniers semble n'avoir eu que peu de succès (la syntaxe de C# étant très proche des deux).

 

Parallèlement plusieurs autres langages ont été développés pour fonctionner avec .NET et un projet appelé Mono adapte la technologie .NET pour les systèmes d'exploitation Unix et Mac OS.

 

Les langages les plus populaires pour .NET (C# et VB.net) sont, comme la plupart des langages modernes multi-paradigmes (ils supportent plusieurs styles de programmation) mais sont plus particulièrement adaptés à la POO (création de classes avec encapsulation, relation d'héritage, polymorphisme, etc), ils permettent aussi la programmation impérative et un peu de programmation fonctionnelle.

 

Dernièrement Microsoft a développé un nouveau langage pour la plateforme .NET : F#.

C'est un langage optimisé pour la programmation fonctionnelle pour laquelle il possède ses propres bibliothèques permettant le traitement des fonctions en tant que valeurs, l'optimisation de la récursion terminale, l'utilisation de fonction lambda, de fonctions de traitement des collections, de liste chaînées (comme les listes LISP)...

Et comme c'est un langage qui utilise la technologie .NET, il prend aussi en charge les programmations impérative et orientée objet et peut accéder à toutes les bibliothèques du NET Framework.

 

Il s'agit donc d'un langage vraiment différent des précédent langages développés ou adaptés par Microsoft pour .NET (C# et VB.net ne se différencient pratiquement que par leurs syntaxes).

 

Est-ce que l'apprentissage de F# sera plus facile pour ceux qui viennent du LISP ?

 

Probablement, parce qu'ils y retrouveront certains de leurs petits, par exemple :

1 :: [2; 3]

est équivalent à

(cons 1 '(2 3))

ou encore :

 

List.map (fun x -> x * x) [1; 2; 3]

est équivalent à

(mapcar '(lambda (x) (* x x)) '(1 2 3))

 

Aussi parce que F# intègre la possibilité de compiler et d'exécuter immédiatement des expressions (comme la console de l'éditeur Visual LISP) dans une fenêtre de Visual Studio ou dans la console de commande (fsi.exe).

 

Toujours est-il que l'apprentissage de F# passe de toutes façons par l'apprentissage de l'environnement .NET, ce qui n'est pas une mince affaire...

 

Aujourd'hui, F# est intégré (il me semble) aux versions payantes de Visual Studio 2010 ou peut être ajouté à celles de Visual Studio 2008.

Il n'existe pas (encore) de version gratuite Visual F# Express comme il en existe pour C# ou VB.net.

Il semble qu'il soit possible d'intégrer F# à Visual Studio 2010 Shell (gratuit) voir ici.

 

Il n'existe pas encore (à ma connaissance) de livre en Français traitant de F#, mais on trouve un tuto et des articles divers en français sur le blog de Laurent LeBrun et un forum dédié sur Developpez.com

 

Cerise sur le gâteau : Microsoft a mis F# en Open Source

[Bred]

Salut,

F# intègre la possibilité de compiler et d'exécuter immédiatement des expressions

Ah !

ça c'est déjà un très bon point en comparaison au vb.net !....

 

Merci pour tous ces renseignements.

[(gile)]

Salut,

F# intègre la possibilité de compiler et d'exécuter immédiatement des expressions

Ah !

ça c'est déjà un très bon point en comparaison au vb.net !....

 

Merci pour tous ces renseignements.

 

C'est pas l'editeur Visual LISP non plus...

Je n'arrive pas (et je ne sais pas si c'est possible) à évaluer des expressions qui font références à des objets des namespaces Autodesk.

 

Mais déjà pour apprendre la syntaxe F#, c'est super !

[(gile)]

Un exemple pour se faire une idée avec une fonction qui fait un zoom objets (argument ur array d'ObjectId).

 

 

C#

 

private void ZoomObjects(ObjectId[] ids)
{
   Document doc = Application.DocumentManager.MdiActiveDocument;
   Database db = doc.Database;
   Editor ed = doc.Editor;
   using (Transaction tr = db.TransactionManager.StartTransaction())
   using (ViewTableRecord view = ed.GetCurrentView())
   {
       Entity ent = (Entity)tr.GetObject(ids[0], OpenMode.ForRead);
       Extents3d ext = ent.GeometricExtents;
       for (int i = 1; i < ids.Length; i++)
       {
           ent = (Entity)tr.GetObject(idsl[i], OpenMode.ForRead);
           Extents3d tmp = ent.GeometricExtents;
           ext.AddExtents(tmp);
       }
       Matrix3d WCS2DCS = Matrix3d.PlaneToWorld(view.ViewDirection);
       WCS2DCS = Matrix3d.Displacement(view.Target - Point3d.Origin) * WCS2DCS;
       WCS2DCS = Matrix3d.Rotation(-view.ViewTwist, view.ViewDirection, view.Target) * WCS2DCS;
       WCS2DCS = WCS2DCS.Inverse();
       ext.TransformBy(WCS2DCS);
       view.Width = ext.MaxPoint.X - ext.MinPoint.X;
       view.Height = ext.MaxPoint.Y - ext.MinPoint.Y;
       view.CenterPoint =
       new Point2d((ext.MaxPoint.X + ext.MinPoint.X) / 2.0, (ext.MaxPoint.Y + ext.MinPoint.Y) / 2.0);
       ed.SetCurrentView(view);
        tr.Commit();
   }
}

 

 

VB

 

Private Sub ZoomObjects(ids As ObjectId())
Dim doc As Document = Application.DocumentManager.MdiActiveDocument
Dim db As Database = doc.Database
Dim ed As Editor = doc.Editor
Using tr As Transaction = db.TransactionManager.StartTransaction()
	Using view As ViewTableRecord = ed.GetCurrentView()
		Dim ent As Entity = DirectCast(tr.GetObject(ids(0), OpenMode.ForRead), Entity)
		Dim ext As Extents3d = ent.GeometricExtents
		For i As Integer = 1 To ids.Length - 1
			ent = DirectCast(tr.GetObject(idsl(i), OpenMode.ForRead), Entity)
			Dim tmp As Extents3d = ent.GeometricExtents
			ext.AddExtents(tmp)
		Next
		Dim WCS2DCS As Matrix3d = Matrix3d.PlaneToWorld(view.ViewDirection)
		WCS2DCS = Matrix3d.Displacement(view.Target - Point3d.Origin) * WCS2DCS
		WCS2DCS = Matrix3d.Rotation(-view.ViewTwist, view.ViewDirection, view.Target) * WCS2DCS
		WCS2DCS = WCS2DCS.Inverse()
		ext.TransformBy(WCS2DCS)
		view.Width = ext.MaxPoint.X - ext.MinPoint.X
		view.Height = ext.MaxPoint.Y - ext.MinPoint.Y
		view.CenterPoint = New Point2d((ext.MaxPoint.X + ext.MinPoint.X) / 2.0, (ext.MaxPoint.Y + ext.MinPoint.Y) / 2.0)
		ed.SetCurrentView(view)
		tr.Commit()
	End Using
End Using
End Sub

 

 

F#

 

let zoomObjects (ids : ObjectId[]) =
   let doc = Application.DocumentManager.MdiActiveDocument
   let db = doc.Database
   let ed = doc.Editor
   use tr = db.TransactionManager.StartTransaction()
   use view = ed.GetCurrentView()
   let getEnt id = tr.GetObject(id, OpenMode.ForRead) :?> Entity
   let addExts (ext : Extents3d) id =
       ext.AddExtents((getEnt id).GeometricExtents)
       ext
   let ext = ids |> Array.fold addExts (getEnt ids.[0]).GeometricExtents
   let WCS2DCS =  Matrix3d
                   .PlaneToWorld(view.ViewDirection)
                   .PreMultiplyBy(Matrix3d.Displacement(view.Target - Point3d.Origin))
                   .PreMultiplyBy(Matrix3d.Rotation(-view.ViewTwist, view.ViewDirection, view.Target))
                   .Inverse()
   ext.TransformBy(WCS2DCS)
   view.Width <- ext.MaxPoint.X - ext.MinPoint.X
   view.Height <- ext.MaxPoint.Y - ext.MinPoint.Y
   view.CenterPoint <- new Point2d((ext.MaxPoint.X + ext.MinPoint.X) / 2.0, (ext.MaxPoint.Y + ext.MinPoint.Y) / 2.0)
   ed.SetCurrentView(view)
   tr.Commit()

[(gile)]

Salut,

 

Il est possible d'essayer F# sans rien installer sur ce site.

Un petit tuto (en anglais) vous guidera dans vos premiers pas.