David Delassus a écrit 766 commentaires

Le type f64 de Rust fournit des fonctions pour faire de la division euclidienne, donc on peut imaginer des opérateurs différents :

• a / b = float
• a // b = int (division euclidienne)
• a % b = int (reste de la division euclidienne)

C'est pas encore spécifié, donc ça va peut être changer d'ici là.

Pour le "x is part of the class y" je traduit ça par "x fait partie de la classe y" la ou "x is a part of the class y" se traduirait par "x est une partie de la classe y". Mais je vois la confusion, je vais voir pour remplacer par "is included" ou "is contained in". Merci :)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Oui, c'est bien, mais en Letlang int et number c'est f64 en Rust.

Et f64 c'est pas N, c'est pas Q, c'est pas R, c'est https://fr.wikipedia.org/wiki/IEEE_754.

int est défini comme ceci:

class int(n: number) {
  frac(n) = 0;
}

On a donc bien le même objet qui appartient à deux ensembles.

Si on peut arrêter la branlette intellectuelle et la guerre d'égo pour se recentrer sur le sujet, ça serait bien. Merci.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Moui

Utilité de ce commentaire ?

surtout pas très pertinent pour un système de types informatiques

En quoi c'est pas pertinent ? Je parle de l'inspiration derrière le système de type afin de présenter le système de type justement qui diffère de la plupart des autres langages de programmation.

Mais dire qu’il n’y a pas de “types” en mathématiques est toujours faux.

Il n'y a pas de "type" au sens informatique du terme. Le "type" au sens mathématique du terme c'est l'appartenance à une collection muni ou non d'opérations. Et un objet n'a pas un unique type car c'est la définition de la collection qui détermine cette appartenance.

Si tu dis ∀x ∈ ℚ tel que x = 42, ∀y ∈ ℝ tel que y = 42 : en toute rigueur x ≠ y.

Mais en pratique c'est le cas. x et y désignent tout deux le même objet qui, par la définition de ℚ et ℝ, appartient aux 2 ensembles.

Par abus les mathématiciens finissent par dire que x = y. Mais c’est pas si évident que ça et ça demande tout un travail algébrique pour arriver à dire que ce raccourci d’écriture est légitime.

Et je n'ai pas besoin de rentrer dans ce niveau de détail pour expliquer que ce sont les classes Letlang qui déterminent quels objets sont inclus, et non l'inverse.

Pour les espaces vectoriels tu es obligé de faire la distinction. Parler de 42 comme d’un vecteur ça veut rien dire, tu voulais probablement dire : 42 = 42 · 1 où le gras est un vecteur, en admettant que tu prennes la base canonique. La structure de l’espace vectoriel ℝ n’est pas celle du corps ℝ (le 42 non-gras : c’est le scalaire, c’est une coordonnée qui appartient par définition au corps ℝ, le 42 gras : c’est un vecteur, il appartient au ℝ-espace vectoriel ℝ). Le 42 que tu as donné c’est la coordonnée du vecteur : pour ce faire, tu as considéré ℝ muni d’une structure de (corps-ℝ)-espace vectoriel, avec une base qui plus est.

C’est une erreur classique que de confondre les coordonnées d’un vecteur et le vecteur lui-même.

Je me demande si tu as lu la même chose que j'ai écrit. A aucun moment je ne parle de 42 comme étant un vecteur.

En vrai la seule mention de vecteur dans la spec c'est :

To reduce code duplication, a class can require type parameters:

class vector<T>(v: {x: T, y: T});

According to the above definition:

{x: 0, y: 0} is vector<int> = true;
{x: 0, y: 0} is vector<string> = false;

J'insiste sur le according to the above definition.

Les entiers, les nombres à virgule flottante, la définition de vecteur ci-dessus, et beaucoup de choses en informatique, n'ont pas grand chose à voir avec leur contrepartie mathématique.

Dans cette spec, je parle constamment de la structure des données, et de la définition des collections qui les contiennent. Je fais un rapide parallèle avec la théorie des ensembles ou c'est la définition de la collection qui détermine la structure des objets qu'elle contient.

Alors oui, la partie mathématique n'est pas la plus rigoureuse qui soit, mais ce n'est pas le but en fait, le but c'est de présenter un concept.

Le public auquel je m'adresse n'est pas forcément mathématicien, donc un peu de vulgarisation et quelques raccourcis, ça ne fait de mal à personne.

Le vrai mathématicien lira ça et se dira "oui, bon c'est un peu simplifié et pas très rigoureux, mais soit".

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Bof, on stocke quand même une entrée dans la "table des matières" du système de fichier pour référencer un fichier vide.

De mémoire, un inode sur ext4 c'est 256 octets, alors que :

$ sh -c "exit 0"

C'est 14 octets pour la commande complète.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

C'est prévu.

J'ai déjà une grammaire partiellement implémentée avec LALRPOP et Logos (cf un des articles de la série). J'hésite à mettre simplement des bouts de code de cette grammaire, ou à la traduire en grammaire BNF.

Il y aura donc une série de LEP dans la catégorie "Language Grammar" ou "Language Implementation". Mais avant je tenais à mettre sur papier le design des fonctionnalités du language (faisons les choses dans l'ordre).

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

C'est corrigé :)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ta présentation me semble au minimum maladroite. Mais j'ai prête mal compris.

Non-non, je me suis bien mélangé les pinceaux.

La théorie ZFC utilise un axiome de compréhension restreint qui empêche la construction d'un ensemble selon le paradoxe de Russel.

Si je ne m'abuse il n'y a pas non plus de concept de "classe propre" dans ZFC

Il me semble justement décrire les classes comme étant un ajout qui ne fait pas parti de ZFC, je vais reformuler pour clarifier.

DISCLAIMER: Je ne suis pas mathématicien de profession, juste quelqu'un de très curieux qui a lu beaucoup de choses sur le sujet.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Dans l'article il explique que la restriction était faite sur daniel.haxx.se et non haxx.se globalement.

Du coup, j'en doute.

EDIT: grillé

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

En gros, on peut mettre des littéraux dans une définition

Oui, ça permet par exemple de définir des énumérations :

class roles(r: "admin" | "moderator" | "guest")

on peut définir le type d'un champ plus tard.

J'ai pas encore réfléchit à comment implémenter le type unknown. J'aimerais aussi éviter le type any si possible. Je regarderais sûrement l'implémentation de TypeScript pour m'en inspirer.

D'ailleurs, est-ce que tu as déjà codé et tester le "&" et le "non" dans ton typage ?

J'ai l'implémentation qui est décrite dans l'article (les structs OneOfType, AllOfType et NotType).

Avec les tests suivants :

let ival = Value::Primitive(PrimitiveValue::Integer(42));

let itype = IntergerType {};

let is_42_type = ValueType { llval: PrimitiveValue::Integer(42) };
let not_42_type = NotType { lltype: &is_42_type };
let int_but_not_42 = AllOfType { lltypes: vec![&itype, &not_42_type] };

assert!(itype.has(&ival));
assert!(!int_but_not_42.has(&ival));

Ce qui en Letlang s'écrirait :

ival := 42

assert ival is int
assert !(ival is (int & !42))

Ça fonctionne bien.

NB: Je vais peut-être changer les symboles pour pas confondre :

• !true = false
• !42 = false

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Rien de bien récursif. Je le parcours toujours avec un algo impératif.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

A titre personnel, je trouve ce genre de commentaire inutile. Vraiment..

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

est-ce par principe un nouveau langage de programmation n'a pas de très fortes chances d'être inutile?

Dans ce que ça apporte à celui qui l'écrit :

• une meilleure compréhension des concepts derrière chaque fonctionnalité du langage
• apprentissage

Ensuite, selon le but du langage de programmation, cela te permet de répondre à un besoin que tu as identifié (Domain Specific Language), ou de fournir une implémentation différente à des concepts existant (donc performances différentes, etc…).

C'est jamais inutile de faire un nouveau langage.

Mais franchement, si on veut faire quelque chose d'utile pour la communauté, il y a peut-être mieux à faire que de créer un nouveau langage de programmation.

Pour les arguments que j'ai cité ci-dessus. C'est jamais inutile.

En tout cas, je ne me lasserai jamais des ridiculités cosmétiques qui accompagnent tout projet de nouveau langage. Genre, regardez, il existait #include, using(), library(), module(), package(), \usepackage(), et bah mon nouveau langage c'est use:: pour inclure une bibliothèque. Et puis pour définir une fonction, c'est pas def truc:, ni sub truc { }, ni func truc() { }, ni int truc() { }, c'est fn truc() = { }.

C'est assez ridicule comme remarque. Ce qui est important dans un langage de programmation, c'est la facilité de réutiliser les design patterns que tu connais déjà, et la facilité que tu as pour en apprendre d'autres.

Un langage de programmation c'est avant tout représenter des algorithmes, de la logique métier et de la glue entre tout ça (à l'aide de design pattern).

La syntaxe, c'est accessoire, et au bout d'un moment cela ne devrait pas te poser problème.

Que j'écrive func, function, fun, fn, on a compris. Pareil pour #include, import, use, require, …

Discuter de la syntaxe, c'est comme discuter des goûts et des couleurs. Ça sert à rien.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Ce puit à toxicité qu'est Twitter, va devenir un océan de connerie.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

62 méfie te

(si tu le coupe en deux, ça fait 2 petits carrés)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Alors pour reprendre ton exemple :

class message_def(v: {
  address: int,
  data: unknown,
})

class message_def_speed(v: message_def & {
  address: 0x04,
  data: float32,
})

let message_speed: message_def_speed = {
  address: 0x04,
  data: 4.2
})

Est-ce que cela répond à la problématique ?

Cela me fait aussi penser que j'aurais aimer parfois un moyen de déclarer les dépendances entre modules, et surtout les dépendances que je ne veux jamais.

Tu veux quelque chose de similaire à Boundary en Elixir. C'est aussi dans mon radar mais pour bien plus tard.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Tu aurais un exemple à donner ?

Parce qu'il restera possible de définir un type comme ceci :

class config(json_data: {
  debug: bool,
  loglevel: "debug" | "info" | "warn" | "error" | "critical",
  logformat: string,
})

Et ensuite de l'utiliser dans une fonction :

# lèvera une exception au runtime si la conf est pas bonne
let cfg: config = json.loadfile("/path/to/config.json")

Ce qu'il faut bien comprendre, c'est la syntaxe :

Keyword("class") Identifier LeftParen Identifier : TypeDef RightParen [LeftBracket TypeConstraintBlock RightBracket]

En gros, tout ce qui est après le : dans les ( ) c'est une définition de type. En d'autres mots, toutes les expressions suivantes sont des types :

• int
• int | bool & !42
• (:ok, int)
• { debug: bool }

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Je vois que tu as pensé à créer des types pour les litéraux. C'est une bonne idée.

C'est nécessaire vu que le langage target est statiquement typé. En fait, même si je target le Python ou l'Assembleur, à un moment j'ai besoin de savoir que "hello world" est une string. Tout les types composites sont construit à partir de littéraux, peu importe le langage.

Concrètement, cela veut dire que le type est une donnée comme une autre.

En Letlang ce n'est pas le cas. Je n'ai pas de type type par exemple. Ce qui veut dire que tu ne peux pas passer un type en argument d'un fonction :

func foo(t: type) -> type {
  # n'existe pas en letlang
}

Le seul moyen de "passer un type en argument" c'est en utilisant des fonctions génériques :

func foo<T>(v: T) -> T {
  # ...
}

Mais on ne peut toujours pas manipuler T comme on manipulerait un entier ou un booléen.

tendre le concept de "constante propagation" lors de la phase d'optimisation en incluant les types structurées

Je suis encore loin d'implémenter des optimisations, mais oui c'est dans mon radar.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

marrant de débattre avec un nazi qui ne connait que l'histoire des dernières semaine qui l'arrange :).

Le troll c'est que le Vendredi sur LinuxFR.

Je crois qu'il n'y a pas meilleure preuve du manque de bonne foie d'un interlocuteur quand il en vient a insulter son adversaire de nazi.

"T'es pas d'accord avec moi ? Mais quel nazi !"

Ce genre d'amalgame fait beaucoup de mal car il retire le sens initial du mot Nazi. Le Nazi est une personne suivant une idéologie dangereuse, dictatoriale, mégalomaniaque, eugéniste, et extrêmement raciste.

A ce que je sache, personne dans cette discussion (aussi virulente soit elle, c'est de la politique après tout) n'a montré un seul symptôme indiquant une appartenance ou un soutient à cette idéologie qui a marqué les heures les plus sombres du siècle dernier.

entre nous tes idées sont quand même proche du fachisme ou stalinisme que de la démocratie et la liberté d'expression

Non. Va relire tes cours d'histoire.

tu mélange volontairement un peu tout et tu as de très jolie raccourci et argument d'autorité.

Tu peux parler. Je ne peux même pas qualifier ton discours d'argument fallacieux, car ce n'est pas de l'argumentation, c'est juste de la diffamation.

Bref, ta toxicité, tes mensonges, et ta connerie, tu te la mets ou je pense, bien profond. Bon dimanche :)

opinion

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

changer certaines habitudes

On peut vraiment parler d'habitude quand c'est 5 fois en 80 ans ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

C'est un mauvais exemple parmi tant de meilleurs exemples.

Quand on dit "il n'y a que les riches qui prennent l'avion" on entend implicitement régulièrement.
Comme le train ou la voiture pour môssieur lambda.

Non, le fait que j'ai pris une fois l'avion dans ma vie n'est pas la raison majeure de la pollution due à l'aviation.

Mettre dans le même panier la classe moyenne et l'élite riche, c'est juste un argument fallacieux. C'est comme l'entreprise qui déverse chaque minute des tonnes de déchets chimiques dans la mer qui accuse le pauvre petit étudiant qui a oublié d'éteindre la lumière pendant 5min.

C'est l'hôpital qui se fout de la charité.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

20% des Français n'ont jamais pris l'avion dans leur vie à ce jour. Cela signifie que 80% l'ont fait, et 55% (donc un Français sur deux) l'a fait au moins 5 fois dans sa vie.
Il y a donc bien une majorité de Français qui prennent l'avion

C'est quoi ce foutage de gueule ?

Parce qu'en 80 ans de vie moyenne, on a pris 5 fois l'avion, on est dans le même panier que ceux qui le prennent une fois par semaine ?

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Pour ma part, je ne suis pas d'accord avec ce scrutin y compris pour le premier tour.

Parmi les 12 candidats, aucun ne m'a convaincu, chacun avait dans son programme des deal-breaker pour moi.

Et je me refuse à "voter utile".

Pour ce qui est de la légitimité d'un candidat, c'est difficile pour moi d'accepter que plus il y a de parti politique au programme proche, moins ils ont de chance de passer. En nombre de vote par rapport au nombre de français, aucun des candidats du second tour ne représente plus d'1/6 de la population.

• 60 millions de français
• 45 millions avec le droit de vote
• 35 millions de vote non nul / non blanc / …
• macron premier tour (27.8%) : 9.7 millions de votes
• lepen premier tour (23.1%) : 8 millions de votes
• mélanchon premier tour (22%) : 7.7 millions de votes

Le top 3 accumule 25 millions de votes, qui est inférieur à 50% de la population française, et chacun d'eux sont inférieur à 1/6 de la population française.

Cela veut dire que peu importe qui passe au second tour, plus de la moitié de la population ne montre pas son soutient au candidat. Si il y avait un référendum après le second tour pour destituer le président, dans tout les cas il le serait (destitué).

Dans ce cas, on est bien en droit de se demander "pourquoi le scrutin actuel permet à un candidat d'arriver au pouvoir quand la majorité est contre lui ?" (en d'autres mots: quelle est sa légitimité ?)

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Faut un peu se calmer sur la condescendance et arrêter de prendre les gens pour des cons.

Non, "ne pas pouvoir choisir entre le gangrène et la mort" ne signifie pas une préférence pour "la mort".

Non, voter blanc ce n'est pas souhaiter secrètement que Lepen passe parce qu'après tout on l'a jamais essayé.

T'aurais voté qui entre Lepen et Zemmour par exemple si ils étaient tout les 2 au second tour ?

C'est si difficile que ça de comprendre que l'on ne souhaite pas choisir entre 2 alternatives négatives ?

Pour reprendre l'exemple du gangrène, le patineur artistique qui en fait depuis 40 ans et dont c'est la passion et la raison de vivre, tu penses vraiment qu'il serait capable de choisir délibérément qu'on lui coupe une jambe ?

Le pianiste de vocation accepterait-il qu'on lui coupe les mains ?

Le peintre choisirait-il de perdre la vue ?

Le fils d'immigré vivant en dessous du seuil de pauvreté choisira-t-il un(e) président(e) qui le méprise et ne se battra jamais pour améliorer son niveau de vie, au contraire ?

Bah oui, c'est la limite des métaphores à la con. On trouve des contre-exemples à la con.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Perso, j'avais voté contre, et je pense que c’était une connerie.

J'avais pas le droit de vote à l'époque, mais j'ai la même analyse que toi.

Cependant, cela reste le scrutin majoritaire uninominal, il n'a pas changé.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg

Bah en l’occurrence, si.

Bah en l'occurence non. Le principe théorique du scrutin majoritaire uninominal est le suivant :

• tu donne vote au candidat que tu supporte

Je ne donne mon support à aucun des deux. Je vote blanc. Ah mince, le vote blanc est pas comptabilisé ? Bah je me déplace pas alors, ça sert à rien.

Je ne reconnais pas la légitimité de ce modèle de scrutin, je n'y participerai pas.

Après, on est en tel désaccord, j'ai pas l'impression que ni toi ni moi ne feront changer d'avis l'autre. C'est pas forcément l'objectif non plus.

https://link-society.com - https://kubirds.com - https://github.com/link-society/flowg