Juste pour savoir - Page 4

abbreviations("M$","Microsoft").

qualites("Linux","super").
qualites("Microsoft","merde").

abbrev_qualite(A,B) :-
abbreviations(A,_X),
qualites(_X,B).

:- abbrev_qualite("M$",X).
% X = "merde".

:- abbrev_qualite(X,"merde").
% X = "M$".

:- abbrev_qualite(X,Y).
% X = "M$", Y = "merde".

:/- abbrev_qualite("Linux","merde"). % Aucune solution.

Namespace Entreprise_Serieuse
    Structure Candidat
        Private _Name As String
        Private _Infos As String

        Public Sub New(ByVal Name As String, ByVal Infos As String)
            _Name = Name
            _Infos = Infos
        End Sub

        Public ReadOnly Property Name() As String
            Get
                Return _Name
            End Get
        End Property

        Public ReadOnly Property Infos() As String
            Get
                Return _Infos
            End Get
        End Property
    End Structure

    Class Embaucheur
        Public Shared Function Entretien(ByVal Candidat As Candidat) As Boolean
            If Candidat.Infos.IndexOf("M$") >= 0 AndAlso Candidat.Infos.IndexOf("merde") >= 0 Then Return False
            Return True
        End Sub
    End Class

    Class Siege_Social
        Shared Sub Main()
            Console.WriteLine("Dossier accepté: " + CStr(Embaucheur.Entretien(New Candidat("Kevin Kofler", "M$ = merde"))))
        End Sub
    End Class
End Namespace

Kevin Kofler
: Parce qu'il optimise très mal!

GoldenCrystal
: Quesoft > Mais ça doit dépendre pas mal du programme aussi. Il y a certain cas pour lesquels c'est quasi-certain que le C++ aura l'avantage, mais c'est sûr que dans les autres cas, ces deux langages sont plus ou moins équivalents.

Kevin Kofler
:

Delphi (objet pascal) est un langage OO et son compilateur bat à plat de couture la pluspart des compilos C.

Parce qu'il optimise très mal!

retournerliste:-
  retournerliste([a,b,c,d,e,f,g],[]).
retournerliste([],Nliste):-
  write(Nliste).
retournerliste([Tete|Corps],Nliste):-
  retournerliste(Corps, [Tete, Nliste]).

let retournerliste =
  let rec retournerliste = function
      ([], nliste) -> nliste
    | (tete :: corps, nliste) -> retournerliste (corps, tete :: nliste)
  in retournerliste ([`a; `b; `c; `d; `e; `f; `g], [])

let retournerliste =
  let rec retournerliste nliste = function
      [] -> nliste
    | tete :: corps -> retournerliste (tete :: nliste) corps
  in retournerliste ([`a; `b; `c; `d; `e; `f; `g], [])

# retournerliste;;
- : [> `a | `b | `c | `d | `e | `f | `g ] list = [`g; `f; `e; `d; `c; `b; `a]

remplacerelement(Valeur, Base):-
  remplacerelement(Valeur,Base,[a,b,c,d,e,f,g],[]).
remplacerelement(Valeur, Base, [Base|Corps],Nliste):-
  remplacerelement(Valeur,Base,Corps,[Valeur,Nliste]).
remplacerelement(_, _, [],Nliste):-
  write(Nliste).
remplacerelement(Valeur, Base, [Tete|Corps], Nliste):-
  remplacerelement(Valeur,Base,Corps,[Tete,Nliste]).

let remplacerelement valeur base =
  let rec remplacerelement = function
      (valeur, base, re_base :: corps, nliste) when base = re_base ->
	remplacerelement (valeur, base, corps, valeur :: nliste)
    | (_, _, [], nliste) -> nliste
    | (valeur, base, tete :: corps, nliste) ->
	remplacerelement (valeur, base, corps, tete :: nliste)
  in remplacerelement (valeur, base, [`a; `b; `c; `d; `e; `f; `g], [])

# remplacerelement `t `c;;
- : [> `a | `b | `c | `d | `e | `f | `g | `t ] list =
[`g; `f; `e; `d; `t; `b; `a]

L'Open Group n'y est pour rien. C'est un comité de standardisation de ISO. Et pas mal des nouveautés adoptées viennent des extensions de GCC à l'origine. Et pour les histoires du "fric", je te signale que les standards Open Group (Single Unix Specification et POSIX) sont désormais consultables gratuitement, donc tu accuses la mauvaise organisation. C'est ISO qui fait payer les standards! Cela dit, il y a des drafts du C99 qui circulent légalement (ISO permet la redistribution des drafts préliminaires).

Le C99 apporte aussi pas mal de nouveautés qui ne sont pas dans le C++. Par exemple: les tableaux de taille variable, les constructeurs de style &(struct foo){1,2,3}, les long long, les types complexes intégrés, les fonctions inline etc. (toutes des extensions GNU à l'origine). Et aussi quelques nouveautés qui n'étaient ni du C++, ni du GNU C, par exemple les pointeurs _restrict (que les versions récentes de GCC gèrent, mais parce que c'est dans le C99, pas parce que c'était une extension GNU traditionnelle) et les constructeurs de structures variables, style &(struct foo){x,y,z} (là aussi géré par les versions récentes de GCC). Quant aux fonctionnalités héritées du C++, ils n'ont vraiment pris que les meilleures: Les commentaires // étaient gérés par pratiquement tous les compilateurs C depuis longtemps. Et les déclarations au milieu du code et les déclarations dans un for sont vraiment utiles.

Sally :

let retournerliste =
  let rec retournerliste nliste = function
      [] -> nliste
    | tete :: corps -> retournerliste (tete :: nliste) corps
  in retournerliste ([`a; `b; `c; `d; `e; `f; `g], [])