Je voulais trouver quelque chose qui est aussi proche d'un type type type.
Qu'est-ce qui est le plus proche que je pouvais avoir
pour des syntaxes native type
que je serais capable de utiliser en runtime JavaScript ?
C'était vraiment la question de la question de la course
de laquelle beaucoup de l'API se sont dégagés.
Bonjour ! Bienvenue à DevTools FM.
C'est un podcast sur les tools de développeur.
Les gens vont faire ça.
Je suis Andrew et ce sont mes co-hosts, Justin.
Salut tout le monde !
Nous sommes vraiment heureux d'avoir David Blass
avec nous. David, vous êtes le créateur de type art.
C'est vraiment cool.
Runtime validation library.
Nous sommes vraiment heureux d'avoir parlé de ça.
Nous avons eu Colin
qui a créé Zod,
en 2022 à un moment.
Je suis un grand fan de ces libraries.
Donc, avant de nous dépasser,
serait-ce que vous devez nous parler un peu plus
de vous-même ?
Bien sûr.
Je suis David.
Je suis en train de travailler sur ce projet
type art tout le temps.
C'est un type source type script
Runtime validation library.
Il y a quelques features très uniques.
Il y a quelques manières très uniques.
Un des deux est qu'une des définitions
est spécifiée
dans un moyen qui ressemble à des syntaxes
native type scripts.
Ils sont en strings.
Vous pouvez utiliser des expressions union
et des parenthèses.
Tout ce que vous pouvez utiliser en type script.
Et ensuite, il est infert.
C'est assez différent de la plupart des API.
Et puis,
le autre aspect cool de ça
est vraiment obscur
à un certain extent.
De beaucoup d'users,
vous ne devez pas vraiment savoir
pour utiliser le aspect de validation
de Runtime.
Mais quelque chose qui est très unique
et qui peut avoir un impact
sur l'écosystème,
c'est qu'il y a aussi un type
type system type scripts.
C'est-à-dire qu'il peut comparer
les schemas
avec l'autre.
Et dire que,
peut-il exister ce schema
comme un type script keyword ?
Ou,
si j'ai tous ces constraints,
je vous garantirais
que ce autre schema
sera mis en place.
Ce qui,
c'est comme un end-user.
Vous ne pourrez pas
faire un ton de directs
de l'utilisation.
Mais je suis super content
de voir
les implications
pour l'écosystème,
comme les autres libraries,
pour valider les schemas
que vous passerez
à l'un des sens de constraints
et beaucoup d'optimisation
potentiel
pour faire la validation
de Runtime très vite.
Donc,
un couple de vraiment
un couple de vraiment
différentes directions
à l'endroit où je suis content
de le faire,
c'est un peu plus
basé en tant que
des aspects basés
pour les données
dont il faut
valider le Runtime
dans un moyen
qui le fait
tout le monde heureux.
Le syntaxe
est vraiment cool.
Je pense
que je parle beaucoup
de typesystems
pour les co-workers
et les amis
et les trucs.
Le type scripts,
le type systeme
pour les typesstreams
est toujours
comme quand ça a landé.
C'est très mind-blowing
et vous utilisez
ça
beaucoup.
Comment
avez-vous
étendu ce API ?
Et je ne sais pas,
comment avez-vous
expérimente
ceci ?
Quoi sont les sharp edges ?
Oui,
c'est drôle.
Je suis travaillé
pour quelques années maintenant.
Et
je n'ai honnêtement pas
vraiment pensé que ce serait
viable
quand j'ai commencé à travailler
sur ça.
Je pense que
l'inspiration corse
pour l'API est assez simple.
Donc, mon procès
était
que je voulais
définir
quelque chose
que c'est possible
comme ce qui est le plus
plus close
que je pouvais avoir
à des syntaxes

que je pourrais
utiliser
dans le runtime
JavaScript.
C'était
vraiment
la question
importante
de l'API.
C'est
ce qui est le plus
change
que je peux faire
comme ça.
Vous regardez
la définition arch type
et la définition type type.
Ils sont
aussi proches
que l'autre.
Mais je peux
utiliser
cette définition
pour
vérifier un objectif
au runtime.
Mais
comment est-ce

possible ?
Je ne savais pas
quand je suis commencé
à travailler sur ça
quelques années plus tard.
Mon
intuition
n'est pas
très
viable pour les
trucs réels.
C'est
ce qui est le
problème
de la
type
de la
language
de la
typologie.
C'est
un type



de
typologie.
C'est








question












de
la
typologie.























C'est



typologie.
C'est
un type



un type


C'est un type


C'est
un type


C'est un type
de
typologie.
C'est un type
de
typologie.
C'est un type

de

C'est
un type
de
typologie.
C'est
un type
de
typologie.
episode
je pense qu'il y a un peu de overhead dans le système de type pour pouvoir l'interpréter sur des personnages.
En faisant ça, j'ai espéré, quand je l'ai déjà impliqué, que pour avoir des cas de niche où j'ai des paroles paroles,
et j'ai des personnages spéciales qui ne pourraient pas le logiciel de la parsing, j'ai espéré qu'il y ait une performance de faute.
Mais ça a été fait en fait, que ça a été plus efficace et que ça a été plus capable de parser sur des expressions complexes.
Quand je l'ai trouvé, j'étais super excité et j'étais content d'utiliser un project en tout cas.
Je testais des scopes de cyclique avec 500 types de cyclique et j'ai pu parser les types relativement officiellement.
J'ai pensé que c'était possible, mais je n'étais pas content d'utiliser les types relativement.
J'ai pensé que c'était possible, mais je n'étais pas content d'utiliser les types relativement officiellement.
J'ai pensé que c'était possible, mais je n'étais pas content d'utiliser les types relativement officiellement.
J'ai pensé que c'était possible, mais je n'étais pas content d'utiliser les types relativement officiellement.
J'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé que c'était possible, mais j'ai pensé
J'ai pensé que j'ai pensé que j'étais un type natif, mais pas souffrir de cette overhead de performance que vous espérez que ça serait inusable dans les projets de large.
Vous avez fait tout ça, vous avez aidé à faire des typescripts plus vides, car j'ai écrit un type script pour des années, je ne sais pas ce qui fait mal un type script en performance.
C'est comme vous l'avez dit, c'est comme de la shooting dans le noir, c'est comme de la shooting dans le noir, mais je ne sais pas, je suis en train de faire un tir, ou que je n'ai pas existé tout en général.
Donc, ça a donné vous cette extra habilité ?
Oui, pour sûr. Je pense que si vous faites tout ça, vous vous buildez des intuitions sur ça.
Et donc, en fait, ce que j'ai essayé de faire pour soutenir mon travail de course en fulltime, c'est de faire des typescripts en performance.
Donc les équipes vont m'aider à aller en optimiser des typescript types, des issues fixés, etc.
Et je pense que ça fait beaucoup de sens pour tout le monde, car c'est une zone spécialisée, et ce n'est pas une chose que vous pouvez apprendre en un jour.
Je bêle des outils pour avoir l'insight dans le temps que la chose va se faire en performance, mais le problème est que si vous identifiez que quelque chose ne va pas se faire bien,
et que vous vous dites, comment peut-on optimiser ça ?
Oui, c'est un très bon travail.
Et oui, vous buildez des intuitions sur ce qui a été fait en temps, et ça a été fait en temps de temps.
Et oui, vous buildez des intuitions sur ce qui a été fait en temps, et ça a été fait en temps de temps.

Et oui, vous buildez des intuitions sur ce qui a été fait en temps, et ça a été fait en temps de temps.
Et oui, vous buildez des intuitions sur ce qui a été fait en temps, et ça a été fait en temps de temps.
Et oui, vous buildez des intuitions sur ce qui a été fait en temps, et ça a été fait en temps de temps.
Mais je veux être sûr que ce sera comme ça, comme c'est suffisant, comme il y avait été, comme ça.
Donc oui, je dirais que c'est bon que les développeurs ne doivent ou ne doivent pas spécialiser ce genre de choses,
parce que, à l'idée, ça devrait être un niveau de libération qui est optimisé,
comme les types qu'ils ont à proposer, parce que ce sont les plus complexes.
Et si les types de la application en termes de la fin de l'utilisation sont aussi complexes,
comme ce sont les types de la libération, c'est quelque chose que vous avez peut-être une case spéciale,
mais vous devez avoir de la séquence de ces traitements, parce que c'est difficile de optimiser les types à ce niveau,
si vous avez l'expérience avec ça, et si vous n'êtes pas malade,
vous devez vous faire plaisir de me faire un petit tour de consulting,
parce que je suis heureux d'y aider.
Comment, à l'idée de curiosité, comment est-ce que le Delta entre les types de la libération et les releases,
comme ça, c'est la grande chose, les développeurs changent sous la nourriture, ils ont ajouté des nouvelles optimisations,
peut-être qu'il y a des déops, c'est comme, vous voyez des les deltas entre les releases,
où vous devez être enthousiaste et essayer de différentes choses, ou quelque chose.
Oui, donc pas généralement, et je donne à la team de types de la libération un peu de preuves pour ça,
parce que c'est un peu construit sur des cas de 1 million d'égecs,
que les gens ont, vous savez,
baisiquement adopté comme fonctionnalité à ce point,
et depuis que tout le monde explique, ils ont de la langue.
Et c'est un truc difficile de maintenir, mais ils ont un grand nombre de tests de communauté,
notre type est en un set de tests de communauté que la team de types de la libération
fait quand ils font des changements, pour faire sure que ce n'est pas une régression signifique,
ce qui est génial, et me donne beaucoup de paix de mien.
C'est pas à dire qu'ils ne pouvaient pas dire,
« On a brouillé ce truc, les types de craintes, mais on va faire ce changement,
pour qu'ils puissent aller au écosystème, » mais en général, ils ont des agressions vraiment sérieux,
et il peut être difficile de faire des tractions sur des nouvelles issues,
ou même des choses qu'on considère comme des fixations de bug,
qui semblent comme des obvies, parce qu'ils sont assez conscients, je pense,
mais en termes de leur réponse, quand ils ont fait quelque chose qui ne s'est pas fait en passant,
ou quelque chose qui a fait quelque chose qui a été fait en passant,
ils ont toujours été vraiment responsables, et ont été très sérieux,
et ils ont adressé à ceux qui ont été réellement réellement réellement réellement réellement réellement,
parce que c'est un nombre de retouches, des tests qu'ils font,
des tests qu'ils font, quand ils ont créé des nouvelles fonctions,
donc je leur donne beaucoup de crédits pour ça.
Le nombre de changements de breakage, quand une nouvelle version de type a été créée,
et que tout ce type de type a été créé, en tant que résultat,
en tant que complexité de tous les types que c'est utilisé,
je pense que c'est moins que 5 fois que tout ce type a été créé,
et dans tous ces cas, il y a un fixage assez facile,
et je pense que, en tant que beaucoup de ces types,
et si vous voulez, vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,

et vous pouvez vous appuyer sur le podcast,
et vous pouvez vous appuyer sur le podcast,
je vous souhaite vraiment que vous aurez un peu de sujets.
Je pense que l'une des types de la température littérale
est une des types de la température littérale,
et il y a un point d'essieu pour une inference spécifique.
Je ne vais pas utiliser le même type de saison,
car ce n'est pas possible,
vous pouvez le refermer très spécifiquement.
Mais essentiellement, si vous avez vu ce type de graphQL,
et vous avez des backticks,
et vous pouvez les interpréter en ce type,
et vous pouvez vous appuyer sur le point d'essieu.
Il y a des types de support pour ça,
mais c'est très limité.
Il y a un issue ouvert, et en fait un PR ouvert,
ça va ajouter beaucoup plus de capacité,
et faire que ça soit plus aligné
avec la capacité de la corse,
de la pièce de la pièce de la pièce de la pièce,
de la pièce de la pièce de la pièce de la pièce,
comme la pièce de l'API,
comme la pièce de l'API que j'utilise.
Mais c'est juste...
Ils sont comme, oh, nous sommes inquiets
de la capacité trop grande,
de la capacité de la pièce de la pièce,
de l'amélioration d'un type,
et d'un type de la pièce de la pièce de la pièce.
C'est bien, c'est pas considérable,
mais les gens m'ont déjà fait ça,
et ça leur donnera un moyen correctement concrètement
pour faire ça,
ce qui serait vraiment intéressant pour beaucoup de gens.
Vous avez déjà fait ça,
vous devez le placer.
Mais si vous pensez au sens
de la façon dont les expressions de string
travaillent,
vous pouvez régler un string
ou un numéro, comme en type script, et ça va travailler.
Alors, comment si tu veux faire votre propre type custom ?
Si tu veux dire string ou user, ou un type de type que tu définis.
Il y a beaucoup de moyens pour faire ça.
Tu peux prendre votre type de user et écrire dot ou string.
Nous exposerons ce API, c'est exactement pour être utile en quelques cas.
Ou tu peux utiliser quelque chose de la scope,
qui m'a mentionné un peu plus tard, qui vous permet de définir vos keywords.
Et ça va faire un tout petit peu de choses.
Tu peux directement référer à une expression de string,
de n'importe quel type que tu définis.
C'est génial.
Mais je veux une overhead mentale pour les nouveaux utilisateurs,
pour être le plus bas possible.
Tu n'as pas besoin de la scope pour faire beaucoup de choses.
En ce type, les choses les plus belles,
qui sont les plus belles,
sont des types co-recursives,
où tu as un de la référence A et un de la référence B.
Nous voulons un moment pour résolver ça.
Mais d'autre que ça, tu peux faire quelque chose sans la scope,
et c'est un de l'option.
Mais c'est cool si tu peux avoir le bénéfice de
interpréter les keywords customes de ton propre.
C'est exactement ce que les types de type de template littérales.
Tu peux avoir un type existant,
interpréter directement dans le string de la union,
et référer à un utilisateur.
Et tu n'auras pas besoin de créer une scope,
ou d'autres overheads qui sont à la base.
C'est super, c'est super.
Il y a des choses comme ça,
les types de JSON sont très cool,
car les definitions d'arc sont survisibles.
Tu peux créer un file de JSON,
et les types de script ne vont pas être négés dans les importations.
C'est une très facile chose.
J'espère qu'ils vont faire ça.
Et l'autre, un de la feature générale,
n'a pas aidé Miatan,
mais c'est très bon pour la communauté.
J'ai une question sur ce sujet,
pourquoi ça serait bien.
C'est des types exacts,
où vous pouvez dire que cet objectif n'est pas allowed
d'avoir d'autres quilles.
Ils sont inquiets que les gens ne vont pas utiliser ça.
Mais je pense que ça donnerait beaucoup de valeur,
surtout si vous pensez à des trucs comme object.keys,
ne pas être narré, etc.
C'est un type de point de pain,
qui est un peu annouvel,
pour interpréter les objets,
créer les associations que vous voulez.
Si vous avez l'objet d'un type n'est pas allowed
d'avoir d'autres quilles,
vous pouvez avoir un inférieur narré
où vous faites object.keys
d'un type exact,
et vous avez des trucs ou des barres
ou des choses que vous avez décédées.
Ce sont les trois que je pense.
Mais je vais dire que
type.trip a fait
beaucoup de choses,
et c'est assez efficace
de faire des choses que je veux.
Je ne pense pas que c'est
tout le monde,
mais c'est un peu trop
fondamental,
et je suis pas d'accord
que je suis totalement bloqué
parce que c'est x, y, z.
Ces choses sont très bonnes
de les avoir.
Mais franchement,
je dirais que
tant de choses sont possibles,
donc je fasse
partie des trucs qui peuvent être faits.
Donc, vous avez juste
avance avec type.trip 2.0,
et le gros feature de la headline
c'est que c'est 100 fois plus facile.
Comment vous accomplissez
cette grande, grande
jump en performance?
Oui, ok.
C'est un peu
un peu dans les weds,
mais
il y a
juste en temps
de l'optimisation
que vous pouvez faire
si vous pouvez
procéder
d'un code
basé sur
certaines références
constantes et des choses.
Donc, essentiellement,
si vous pensez
en Write in Code,
si
type.trip
est
string,
ou type.trip
est le numéro,
et c'est
comme une fonction
que vous avez écrit
ou quelque chose comme ça.
On dirait que vous avez
mis le 1000 fois
comme v8,
et en général
comme
d'autres engines
qui sont très extenses
vont être très, très bonnes
en faisant ça extrêmement vite.
Mais si votre
logique
ressemble
à quelque chose
que vous ne pouvez pas imaginer
dans une libraire,
comme pour
comme
vous savez,
constrain de
comme, vous savez,
ce type constrain
de faire un peu
d'abstract de choses
parce qu'on doit impliquer
à un niveau plus haut
ce qui va se faire
plus vite.
Donc, c'est essentiellement
ce qui s'adresse à
ce que
c'est que
quand vous créez le type,
c'est
comme un peu de code JavaScript
qui est
comme
très concrète
référence à toutes les chevaux
que vous faites
que c'est un
très engin
optimisé et
de l'air
et c'est
comme un environnement
qui supporte
comme exécuter
une nouvelle fonction
comme, ou c'est comme
évaluer le code
dans un contexte
sorti, mais c'est
ce que c'est
que ce que ça va faire
c'est qu'il va
remplacer
les
des
des
des
implementations standardes
de
basément
checker les types de type
avec ces
versions optimisées
que ça crée
en place
et c'est ce qui
fait que c'est si vite.
Ou bien que c'est part
de ça, mais
il y a un nombre de
enjeux enceintes
que je suis en train de
optimiser ces choses
de plus en plus.
Et il y a vraiment
un nombre de
enjeux enceintes que vous pouvez
faire.
Je vais dire
une chose que je
suis particulièrement
très excité
de voir
dans les
benchmarkes

communautés
des
benchmarks
qui sont
les comparations
basées
dans les
paroles
des
paroles
discriminées
dans les
unions.
Donc,
dans notre type
je m'ai mentionné
à la première
fois que l'une des
plus
unique des aspects
était le type
système
où il a
l'objet de comparer
les types
d'un autre
et comprendre
les relations.
Part
de ça,
pour les
branches
de l'Union,
il peut
intersecter
et dire
que
ici
sont les places
où je peux
vérifier
et que ça
me disait
si je suis
en train de

vérifier


de l'Union
qui est
vraiment
discriminé.
Il
y a des
tests
qui disent
que je vais
vérifier
cette branch
ou que je vais
vérifier
cette branch
et je veux
savoir ça
d'ailleurs.
Normalement,
c'est un

tag.
Mais
il peut
dire
que
un
enjeu
ou un enjeu
est une
union
parce que
une check
de la
top
et
qui est

branch
je peux
dire
je ne
n'ai pas
utilisé
cette optimization
mais
on peut
dire
une
objectif
avec une
property
où
une branch
est plus

que 0
et la
autre
c'est moins
que 0
parce que
vous pouvez vérifier
cette
property
et vérifier
si c'est plus
que 0
et le point
de
ça
est un couple
mais
c'est
que vous
vérifiez
une
union
en
constant
en
en
en
nego

Il
que ça peut utiliser et que ça peut faire de nombreuses rounds de discrimination.
Donc, quand vous définissez une union, vous n'avez pas de la question de dire explicitement
qu'elle est discriminante et que c'est une union,
ça va figure de la question de ce que les checks sont les plus optimaux que ça peut faire
pour expliquer toutes les branches et aller au le droit le plus vite possible.
Et ça c'est la chose où, oui, vous ne pouvez même pas voir ça dans les
basic, comme les benchmarks de validation de runtime, mais c'est la chose qui peut être super
impactueux si vous avez des types complexe ou des unions et vous n'avez pas de faire
quelque chose ou même savoir que ça se passe extérieurement pour le bénéficier de vous
vraiment significatif, aussi en termes de messages d'air, parce que vous avez vu une
réelle message d'un message d'un union d'air, ça peut être assez offre, mais ça peut être
beaucoup mieux si c'est comme, ok, je l'ai figuré que vous devez essayer de créer cette
branche parce que votre propre de la faute est faute, donc je vais vous donner les messages d'air
pour cette branche, car ça semble être ce que vous essayez de faire et c'est beaucoup
plus facile de ne pas faire le coup, donc il y a beaucoup de bons bénéfices,
et des optimisations sur le genre. Ce genre de choses, en temps de compilation,
peut faire des choses beaucoup plus vite, c'est aussi assez gros parce que j'ai
de la validation, comme 4 de différentes manières pour pouvoir faire tout ça,
parce que c'est la validation qui est faite, si quelque chose est assis ou pas,
ça fait que ça retourne à la faute, et il y a la validation qui est faite et qui donne
un message d'air détaillé, parce que c'est moins efficace, on fait seulement des cas où vous
faîtes, et puis il y a le jit optimisé, j'ai de l'air de l'aider dans le string de JavaScript,
version de la fin ou la fin de la fin, et puis le jit optimisé, on va faire un message d'air
aidant quand la chose s'est faite. C'est un peu de pain, et c'est très grand,
c'est tellement rapide, mais je vais vous leveler, c'est un feature de headline,
parce que les gens sont vraiment excitées à la performance, mais je pense que compared
à Zod, il y a une micro-seconde pour faire ça, et le type ARK est comme, je vais faire ça dans 10 nanoseconds,
est-ce que c'est vraiment votre performance de bobble-neck ? Oui, c'est 100 fois plus rapide,
mais c'est déjà assez rapide que ce n'est pas le numéro 1 qui va vous couler,
donc je dirais que la performance type est probablement plus réellement basée sur le
travail de consultations que je fais, où les gens sont en train de se battre avec Zod ou T-RPC ou
des choses différentes, comme de cracher leur éditor. Donc ce genre de choses est probablement
plus probable d'être un bobble-neck, et le pur de la chose est, c'est super si vous
faites quelque chose où vous êtes validé de tant de données, et peut-être dans des cas
que je vous ai mentionné avec les unions, si vous avez des unions complexes, ça peut prendre
longtemps, et peut-être que certaines d'entre eux sont vraiment aidables pour vous, mais
je pense que les gens tendent à vraiment fixer ces métriques, et je vais admettre que
la partie de ma motivation pour optimiser ces métriques était que je savais que les gens
m'aimaient vraiment de leur appréciation, et j'ai beaucoup de réponses sur ça avec le premier
élevé, comme « comment est-ce que ça va » et « tout le monde veut savoir ce genre de choses,
mais pour ceux qui ne le savent pas, c'est probablement pas le plus impactif pour une
library de validation. Oui, pour sûr, et bien, surtout parce que beaucoup de fois,
vous êtes validé, probablement, sur les côtés de votre API, donc comme les choses sont en train de
[? unwalker, » Just if you get a
n't niceанс qualifier, it's just it's a
il a été un peu raisonnable pour le faire.
Et je pense que, à l'heure, les gens qui regardent les benchmarks de performance
sont comme, Zod doit être très lent, il doit être comme,
qu'est-ce qu'il fait ? Il a dû avoir écrit une bonne code.
Et ce n'est pas tout le monde qui a raison pour ce genre de choses.
C'est un grand différentiel.
Et je suis très proche de Colin.
Je pense que je ne devrais pas le faire,
mais il est probablement bon.
Je sais que il implemente des choses comme,
juste en temps, des optimisations pour Zod4.
Donc peut-être que les gens vont avoir quelque chose à voir,
quand c'est prêt.
Mais, tout de suite,
et je pense que 1% de l'utilisation
sera vraiment bénéficiant de cette optimisation.
Et c'est assez marginal pour les gens.
Oui, les choses importantes pour la librairie de validation,
c'est comme, la performance baseline, il faut être bon.
Je pense que ce que vous avez dit,
c'est que la performance de type
devient un grand délire.
Donc, pour quelqu'un qui ne s'est pas en train de prendre Zod,
je vais juste dire Zod,
parce que j'ai utilisé ça en code de production.
Si vous avez beaucoup de z.info,
où vous avez un validateur et un type script type
qui est créé,
ça peut être très très très slow pour la check-in type.
Et surtout si vous avez beaucoup de ces types.
Je suis curieux de voir comment ce type,
et de la performance de type.
Et puis, une chose que je veux parler de après,
c'est la autre chose importante pour les validateurs,
c'est les erreurs.
Parce que, si vous ne savez pas,
la toute raison de faire la validation de runtime,
c'est pour que nous voulons matcher la logique de nos types
avec ces types de temps,
mais qu'on aussi doit savoir ce qui se passe.
Et ça peut être très facile de faire un array de trucs.
C'est comme,
ce qui est de la clé de la clé de la clé,
ça a un problème et ça ne vous dit rien.
Je suis curieux de voir ces deux choses.
Ok, cool.
Donc, la première chose,
comme je l'ai dit,
j'ai créé un type benchmark,
un test,
c'est aussi un type,
j'ai créé un type test
où je pouvais faire des assertions,
un test,
un certain valeur,
qui est le plus important à la runtime,
et puis, un type.2 string,
un type de snapshot,
ou un type de snapshot,
ou des completions de snapshot type,
et il n'y a pas d'autre libraire
que l'écosystème qui fait ça.
Donc,
les gens devraient utiliser ça
si ils sont en train de faire des libraries.
Je ne m'en occupe pas,
je ne vais pas vraiment essayer de promouvoir un test,
mais je suis juste comme,
si vous voulez avoir une fonctionnalité de type robuste,
vous avez besoin d'un truc
qui peut faire des assertions sur ces choses,
parce que,
juste en utilisant les trucs qui sont construits,
ou les tests,
ou tout ça,
qu'ils justent des chevaux
avec deux types de la même ou quelque chose,
ça est mieux que rien.
Mais si vous faites un library
où le type est un part de la fonctionnalité,
vous avez besoin d'un peu plus de ça.
Je pense que c'est mon
tantrum de chute
pour avoir un type test plus robuste.
Mais,
c'est vraiment
très absent
dans un grand nombre de libraries
dans l'écosystème
qui font beaucoup de utilisation
de cette fonctionnalité de type.
Et même avec le type benchmark,
évidemment,
les gens ne le font pas.
Donc,
je pense que le plus grand
c'est que,
comme je l'ai dit,
j'ai eu des benchmarks
pour toutes les expressions individuelles
qui se sont passées
et toutes ces scénarios
et des types de type
pour que,
quand je fais des changements
pour le type de parsing,
il n'y a pas de preuves et de performances
ou, comme je l'ai dit,
si je rajoute un peu de feature,
je pense que c'est important
et que ça donne un meilleur
type de message,
des messages type d'air
ou quelque chose.
Je peux faire ces traitements
de la connaissance
et dire que c'est dommage
de 3%
de la performance
de type ou quelque chose comme ça.
Et je pense que les gens
n'ont pas d'idée.
Et c'est...
C'est juste
que vous ne pouvez pas
avoir de bonnes intuitions
même si vous avez fait
beaucoup de choses
pour être confiants
que,
que ce soit le changement
que vous faites,
vous ne pourrez pas
juste de la performance
du type de type
de 50%.
C'est juste
trop facile
de faire quelque chose
qui semble complètement
arbitraire
et c'est un désastre.
Je vois ça encore.
C'est...
Ça me dérange
parfois.
Donc, des choses
que vous pouvez ajouter
qui semblent
innocents,
mais peut-être
que ça se crée
quelque part
ou quelque chose.
Et tout de suite,
tout de suite,
tout de suite,
tout de suite,
tout de suite.
Donc,
je pense que c'est
le plus grand
chose.
C'est juste que
chaque changement
que nous avons fait
était
de savoir
l'impact exact
et pour les meilleurs
libraries,
c'est l'opposite.
Et c'est pas
à dire que
n'importe quel
chose
était
évidemment
mal ou quelque chose.
C'est juste que
sans savoir,
c'est vraiment innocu,
c'est
vraiment
encore,
ça pourrait être
que
il n'y a pas de
cashing
qui est
type-trip
dans le passé
qui est
pu réutiliser
la plupart
quand vous répétez
quelque type
pour le faire
une deuxième fois.
C'est possible
de réutiliser ça.
Et maintenant,
ça ne ne ne ne ne ne
pas, pour des raisons
comme un extra
contexte
de l'intervention
ou quelque chose
comme ça.
Et
maintenant,
ça ne prend
trois fois plus
plus de
check
de votre repo
ou quelque chose
parce que c'est
ça.
Donc,
c'est probablement
le plus grand
en termes de
compétitions.
Et puis, évidemment,
construire
ces intuitions
aussi,
ça fait
beaucoup plus
plus facile
d'apporter
où les choses
travaillent
bien
dans le premier
endroit.
Depuis que j'ai
construit
la version naïve
qui n'a pas travaillé
en termes de
type-trip
et qui a
gardé l'intervention
jusqu'à un
mieux
construit
beaucoup plus
de intuitions
sur qui je dois
commencer
avec un approach
qui a un peu plus
plus
comme ça
et que
j'espère
que je ne vais pas
être
trop
intérêts.
En termes
de
les mises
de runtime
être
plus
et
que
c'est
quelque chose
que
depuis le début
je pense
qu'il a
senti super important
et
j'ai voulu
arriver
avec une
stratégie
pour
se dévier
et je pense
classiquement
que les
mises
sont les
plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus
les plus

les plus
les plus
les plus
les plus
les plus
les plus
les plus
on

l
este
T
a



a
pas
H

position
d'aux
effets
Would
cupboard
Bitcoin
h
aty


pas
les
paying
tan
c'est que nous pouvons prendre les langues que vous avez faites et les mettre en place
pour les composer dans une message de l'air union qui est vraiment facile à lire et comprendre
ou si vous avez juste arbitrairement écrit ce format que vous voulez dans un sentiment complet
on n'aurait pas pu réutiliser ça en ce moment où ça a été facile à faire
donc comme ça, quand nous créons la message de l'air union
nous pouvons vraiment aller en passant et essayer de faire un délirement de choses comme nous pouvons
donc par exemple si il y a beaucoup d'erreurs sur chaque branché dans le même path,
nous pouvons comme ça collapse ces deux ensemble et dire que
ce path a dû être l'une des cinq choses ou quelque chose comme ça,
en disant que ce objet a dû avoir une marque de foule qui était celle-ci ou celui qui a dû avoir
une marque de foule qui était celle-ci. Donc il y a une façon où vous pouvez les mettre ensemble
un autre est comme, je pense, oh man, j'ai perdu ma train de faire un petit peu de ceci,
je vais être honnête avec vous.
Mais je vais dire que, essentiellement, il y a plusieurs manières où nous avons
des optimisations qui vont être éternelles sur les messages de l'air union et essayer de
les déclencher pour devenir comme éteints que possible et je pense que généralement,
ça a vraiment aidé un ton d'être capable de pouvoir avoir un niveau de haut,
comme un summary éteint de l'humain de l'air, de ce que ce n'est pas le cas,
et puis vous avez encore toutes les intérêts que vous pouvez éteindre sur l'arrêt et
vérifier les individuaires et les mapper et faire les choses que vous avez besoin.
Mais oui, je pense que, à ce niveau de haut,
à un moment, on a des plans de ce qui est pas correct, et de faire un effort très
difficile pour faire la description des éteintes comme éteintes que possible,
même quand elles commencent à se faire complexe, c'est un point de sale,
je pense, de l'alcool qui est beaucoup plus meilleur que la plupart des autres
choses que j'ai vues là-bas, c'est une solution pour ces problèmes.
Donc, ça veut dire que vous avez impliqué l'architecture dans le système type
pour composer ces erreurs, hein ?
Oui, donc il y a spécifiquement une logique dans la note de l'Union qui est
comment je crée mon message d'erreur, et ça va éterner les erreurs de l'architecture
et appeler des logiques qui disent que, un bunch de choses ont éteint dans
ce path ou un bunch d'elles ont éteint par la valeur de ce type,
ou comme je l'ai dit avant, peut-être que l'une des choses les plus impacibles
de l'un des choses les plus impacibles, c'est de pouvoir automatiquement
discriminer l'Union pour qu'on puisse éliminer un nombre de cas que
ne serait pas réellement pas basé sur une propre que vous avez
offertée et vous donner la information sur pourquoi l'un des cas
qui semble être le cas que vous essayez d'en faire, a fallu.
Donc, oui, je me sens comme si il y avait un énorme amount d'eux,
un énorme nombre d'eux qui ont bénéfit, et je suis excité pour les gens
de l'alcool pour les quelques-uns de ces choses, parce que je pense que c'est
des zones où les gens sont juste tentant de construire,
c'est une nouvelle bivé, et les gens sont toujours tentant de construire
les analyses comparé à ce qu'ils ont été mises sur le gât, et je pense que
beaucoup de gens sont toujours interprétérés sur les erreurs et
tentant de se faire comprendre ce qu'ils ont fait.
C'est bien que c'est introspectable et tout ça, mais
je pense qu'il y a encore plus de choses qui peuvent être faites
pour optimiser ces messages uniaires et discriminer
dans un moyen vraiment utile, mais peut-être qu'on
doit encore donner un contexte pour dire,
parce que parfois ça peut être un peu surprenant,
si vous pensez que je vais essayer de spécialiser
cette baisse, et que c'est parce que vous avez dit que le genre est de la faute,
mais peut-être que 50 autres propriétés sont matchées
sur certaines autres baisse, je ne peux pas vraiment
se faire comprendre en un manière performant.
Donc il y a beaucoup de nuances comme ça, et je suis
content de avoir plus de réponses de la communauté, mais
basicement je ne pense vraiment que quelqu'un d'autre
ait essayé de faire un message uniaire,
donc je pense que avoir quelque chose à l'aise
qui t'aimera à faire quelque chose de ce que je travaille pour vous
sera un grand improvement, et ça va se faire mieux
quand nous avons plus de réponses sur ce que c'est intuitif
et ce que c'est.
Oui, je l'ai fait un peu de type gymnastics,
et vous avez à la fin de tout le type check,
vous avez checké cette message, et vous êtes comme,
comment est-il que quelqu'un d'autre
va savoir ce que ça veut dire?
Et puis, de pouvoir composer des messages de la faute
dans le type système, c'est aussi un grand mental,
comme un étudiant, comme un hurdle,
donc tout ce qui est facilement accessible
par un bon API est un grand win.
Oui, je pense que c'est un des trucs cool
sur les API type archtipés,
c'est un niveau d'abstraction,
en comparaison à un API standard,
où on peut construire
tout ce que nous voulons dans le langage,
donc c'est cool.
Mais, second,
ce n'est pas le mécanisme primaire
pour donner des messages d'air,
ce n'est pas le type type standard,
comme le type que vous devriez passer,
et puis vous avez un type type qui s'est créé
pour que ce message d'air,
et ça ne peut pas vraiment ne pas fonctionner
dans un...
Ce n'est pas le cas.
Mais, pour le coup,
vous ne pouvez pas mettre des strings
ou des strings validées,
vous ne pouvez pas les faire comme ça.
Il doit être comme fonction,
pour que ce soit validé.
Mais second,
même si vous pouvez, pour certaines choses,
ce serait vraiment difficile de lire,
comme vous le décidez,
comment nous ne l'avons pas dit,
pour que l'externe de l'externe
puisse comprendre ceci.
Et donc,
si vous n'avez pas vu
ce que l'un des messages d'air archtipé
ressemble à,
si vous, pour exemple,
vous avez mis une parenthèse
dans un de les types que vous avez évoqué,
ou un référence de string,
et vous vous laissez le nom ou tout.
Vous vous recevez
quelque chose,
comme
un string n'est pas assigné à,
et puis, dans les quotes,
ça ne sera pas un string non résolvable,
ou ça sera comme
une parenthèse de la même chose,
avant un array,
ou quelque chose comme ça.
Vous vous recevez,
c'est comme si vous aviez un éditor,
mais vous vous recevez
dans un string
comme le raison
pourquoi votre type n'est pas valide,
et avec l'extension,
ça va
enlérer
ce partage
pour vous
et vous vous extracter,
et donc,
quand vous avez type quelque chose d'accord,
vous verrez quelque chose comme
un string non résolvable,
ou vous verrez
ce qui dit
que vous avez mis
une parenthèse de la même chose,
avant un array.
Mais,
parce que de cette façon,
nous avons utilisé
pour valider votre définition,
mais,
nous pouvons donner
quelque chose de type,
nous pouvons donner
quelque chose de custom d'air,
de ce type de type,
de ce type,
nous ne sommes pas en train de
dire
d'accord,
ici était la structure que nous voulions,
et ici était la structure que nous avons donné,
et donc,
à quel point
l'arbitrary issue
s'est-il arrivé,
comme type de type
qui génère
quelque chose de potentiellement complexe,
un message pour ça,
si c'est d'inclutir les unions,
et d'inclutir
des arrays ou des tuppes,
ou tout ça,
mais pour nous,
nous nous sommes toujours
en contrôle
de ce que nous
nous donnons,
de ce que nous nous donnons,
nous vous donnons à un niveau type,
de toute façon,
donc nous avons
l'aider à
enrayer un type de type
et d'ailleurs,
on peut juste vous dire,
et en plein de temps,
on va vraiment vous dire
ce que vous faites,
comme essayer de le faire,
ou juste
changer votre force pour être ce que vous faites,
et c'est tout juste
en fonction du type,
type, type système,
mais
ça fait

ça fait que ce que vous faites
ce genre d'abstraction
où
vous ne pensez pas
de
type,
type,
vous donner des messages

plus tard
quand vous définissez
une définition d'arc type,
parce que
vous vous devez
de notre
message d'arrêt
qui est
juste un
très,

oui,
évidemment,
on doit utiliser
type,
type,
type système
à un moment,
mais comme
le seul interface
pour ça
c'est juste que
vous avez un message
de retour qui dit
que votre input
n'est pas signé
que vous avez
votre custom string
d'air message
donc on a
un peu de bypass
de ça
et je pense que ça
lead
à des meilleures expériences
dans beaucoup de cas
parce que
comme vous l'avez dit,
c'est juste
trop facile
comme les types
ont un plus complexe
pour juste
les avoir
il faut un peu
de parcer
ou quelque chose
peut-être
comme vous le faites
en copie
pour un LLM ou quelque chose
je ne sais pas
mais c'est
un défi
je me souviens
quand j'étais
le premier à commencer
j'ai vu un message d'air
et c'était
dot à dot
et j'ai oublié
combien de millions
de personnages
c'était
que ça m'a omité
mais je me souviens
de faire des math
et c'était
7 fois plus
plus
que les
books de Harry Potter
combinés ou quelque chose
et je me suis dit
que
tu as généré ça?
comme quoi?
je veux dire
c'est fou
bien sûr
que non
on ne peut pas
passer ça
mais
il y a beaucoup de scenarios
qui sont
assez
très basse
mais il n'y a pas de
manière
qu'un homme
pourrait comprendre ça
donc
oui
c'est l'un des gros improvements
que je pense que notre type
fait
par avoir un peu plus
de contrôle
sur
ce que
ce sont les réponses
qui sont là
c'est un
library impressionnant
pour sûr
et j'ai
particulièrement aimé
l'éditer
comme
enceinte
juste pour
faire
tu sais
syntaxe
dans
le string
pour faire
ça
comme
comme un
type
je pense
que l'une
chose que tu as
pour

un type
type
c'est
comme
c'est
un motivateur très fort
je veux dire
quand j'ai commencé
tu sais
c'est
en plus
en plus
les indications sont
comme
je me suis dit
je me demande
comment ça va être
mais comme
je
especially
pense avec le tooling
et puis si tu
tu as
la
familiarity
de typescript syntaxe
et puis tu as
les choses comme
tes
constraints
juste comme
être able
de refiner
types
tu sais
base sur les valeurs
ou whatever
il devient
incroyablement
incroyablement
powerful
et tu sais
combiné
ce avec bonne erreurs
et tout
et c'est
c'est
c'est
c'est
un super power
c'est vraiment
intéressant
et
je ne
je
le API
pour moi
serait
très non-obvious
comme ce n'est pas
ce n'est pas
quelque chose qui
serait
comme
fallout
pour juste comme
si je vais
essayer de
construire
un
library
comme ça
je pense que
comme
l'application

serait
comme
probablement
ce que j'ai
étendu
mais
comme on l'a dit
c'est comme
les erreurs ou les harders
et il y a un peu de
comme
les hards
des choses
donc
je pense que c'est
comme un grand
je l'apprécie
je pense
je pense que
à un point de vue
comme ça
ça
fait
un peu de


mais
juste
de la type
en fait
en pensant
dans le respect
de
comme
comment
comment
je vais faire de l'aviation
c'est
comme
si tu penses
comme
comment
je peux faire
quelque chose
qui
ressemble
comme
type type type
possible
et puis
utiliser
en temps
comme
c'est
c'est
c'est
ce que tu pourras
faire
et il n'y a pas
pas
que la
ambiguité
à ça
comme
je pense
que le seul
c'est
comme
peut-être
tu dois
juste
le

et
comme
comment ça ne fonctionne
si tu as
tu as
tous les objectifs
en taxant
ce type
en strings
aussi
et
comme
c'est
assez
obvious
que
comme
après
en pensant
en essayant
ça ne devrait pas être
comme
immédiatement
mais comme
c'est pas
c'est pas
c'est
bon
parce que
type type
c'est
beaucoup plus
efficace
à
parcer
l'entire
de
que c'est
comme
en utilisant
les types de
objectes
donc les strings
ne sont pas
comme super super
ça fait du sens
parce que
tu as déjà
ça
en JavaScript
tu as déjà
ces structures
comme
pourquoi pas
réutiliser
les objectifs
et les literaux
et des choses comme ça
qui sont
répliquées
pour les trucs
dans J.S.
pour que l'autocomplete
soit encore
vraiment bien
et
tu peux encore
les messages
vraiment détails
et tout ça
donc ça serait
le seul point
où tu peux dire
que tu peux
faire
exactement
1 à 1
et juste
tromper tout
mais
en termes
d'expérience
et surtout
si tu n'as pas
des textes
ou quelque chose
qui
m'a voulu
être
une bonne expérience
pour les gens
même si
ils n'ont pas
l'expérience
édite
ou quelque chose
comme ça
qui

en train de
s'exprimer
comme vous l'avez mentionné
et qui
peut
les mettre
en ligne
type
des messages
dans un
utile
mais
mais aussi
pour que ça soit
une expérience
comme
en termes
d'expérience
si tu as
cette chose
mais comme
ça ne devrait pas
être
comme
complètement
comme si tu as
un GitHub
comme
un PR
et c'est comme
un total
non sens
parce que tu ne peux pas
voir ce qu'il se passe
parce que c'est tout un petit peu
de choses
en strings
et
et comme
je pense que ça
pourrait
être
expérience
très rapidement
si tu as
essayé de
le serrer
et tout
donc ça
était vraiment
le seul point
qui est
comme
tu sais
peut-être
il y a un autre
moyen de faire
ça
mais ça
me semble
comme
comment
tu veux
aller
sur
si tu es
tenter de
murer
un type script
dans un
manière
qui
se scale
et
vous savez
ça
devrait
bien
ou pas
vous avez
l'extension
et donc
comme
oui
je ne veux pas
prendre
trop de crédit
c'est un

des
validateurs
pour
type script
et puis
si tu fais
ça
tu peux
comme
déjà
faire
des types
que tu
as
déjà
tu as
comme

de
le type script
syntaxe
et puis
tu peux
juste
comme
naturellement
éclater
ça
tu sais
pour
inclure
autre
genre
de
validation
de

mais
oui
je pense
que c'est
comme
le danger
est que
les gens
ne font
pas
cette connexion
et c'est
comme
oh mon dieu
comme
ce qui est
ce qui est
ce qui est
comme
un
genre
je peux
voir
pourquoi ça
serait
intimidant
donc
je suis en train de
communiquer
les gens
comme possible
que
comme
tu sais
en fait
ce est
vraiment
juste
développé
pour
pour

et pour
vous
pour
l'exprimer
mais
comme
tu peux
prendre
tout le knowledge
que tu as
pour
les types
types
et c'est
comme
totalement
transferable
et tu peux
juste
tu peux
utiliser
pour
faire
tout le
que tu as
et
oui
je pense que c'est
ce qui fait
c'est
j'ai
je pense que
c'est
�itan
au

ce que
on
遠

tone
l'ib et
type type,
c'est un formule de definition
très facile à comprendre.
C'est bien, mais c'est bien,
c'est que tu n'as pas besoin de faire ça,
c'est déjà si proche de ce qu'on a en type-trip.
Tu n'as pas besoin de demander
comment c'est un infert pour voir
exactement ce que la forme est.
Je pense que c'est un bénéfice
de la compétition avec les types.
Un endroit où tu vas
comment ça soit pour ce genre.
De long terme,
tu te rends compte que tes
celles-ci seEntuschent
?
C'estkon..."
type pass, c'est comme un type-système, comme type-script, où on peut comparer types
à un autre.
Ça inclut les constraintes aussi.
C'est comme une extension de type-script type-système où, si tu dis,
un type qui est un numéro plus de 5, est assignable à un type qui est un numéro plus
de 0 comme ça, parce que si un numéro plus de 5 sera plus de 0, le revers ne
serait pas vrai.
Et la même chose, si tu intersectes un numéro divisible de Y2 avec un numéro divisible
de Y3, il sera un numéro divisible de Y6.
Et ça peut déterminer l'assignabilité, incluant ce que les gens pensent historiquement
de la constrainte de runtime.
Mais ça fait que ça donne l'introspectabilité de type-level, pour inclure les extensions de
type-script type-script pour rangements et deviseurs et regecs et d'autres choses comme
ça.
Il y a aussi des transformations, des morphes.
C'est un système qui adaptera uniquement le type-système pour les gens d'accommoder.
Mais ce que ça veut dire dans un type, c'est que ça accepte un string et que
ce string soit transformé dans un numéro ou quelque chose comme ça.
Il y a des règles un peu uniques sur ceci.
Mais tout est dégagé par ces principaux principaux de types de set-face qui sont
les mêmes principaux que le type-script type-système est dégagé.
Et je ne dois pas trop risquer de la dévergir du type-script en termes de, je pense,
d'extender le type-script pour dire, OK, on va maintenant en rangements.
Parce que, oui, peut-être que un type-script type-script apportera des rangements et vous
pouvez dire un numéro plus grand que zéro.
Ils peuvent tout de suite faire ça parce que j'ai élevé le logiciel que ils
devaient faire pour ça.
Donc ils peuvent définitivement ajouter ça et ça devrait totalement travailler pour eux.
Ils devaient avoir besoin d'une logique additionnelle qui dit comment, quand vous
vous faites une expression de JS ou quelque chose, si vous dis que le numéro est en zéro et
que je ajoute un numéro positif pour ça, peut-être que ça va être encore un numéro
pour un numéro de zéro ou quelque chose.
Ils auraient dû avoir une logique unique sur ça.
Mais pour la plupart, c'est assez, c'est totalement
le genre de ce qu'ils ont.
Et c'est très clair, comme la définition de la base de la base de ce qui devrait
arriver où je n'ai pas besoin de ne pas être inquiétant pour les
types de la dévergir.
Mais je l'ai fait parce que c'est comme un
mathématique qui ne pourrait pas être pas le genre.
Il n'y a que l'une qui est la vraie réponse à la question de comment les rangements
se dépassent ou comment les devines se dépassent ou si l'une implique un autre.
Ce que je dois ne pas se dépasser, c'est que des
langues qui sont des corques, où quand je suis en train de
construire un système robuste, je veux vraiment
se dépasser.
Je ne sais pas, l'idée que comme un objectif élevé, si vous
fais des syntaxes littéraux avec
aucun propriétaire, comme dans un type-strip, ça
pourrait être assigné comme un numéro ou un string ou
quelque chose, parce que c'est juste de vérifier si c'est quelque chose qui
permet d'avoir un accesso de propriétaire.
C'est une des choses qui sont toujours élevé sur un type-strip.
Je me demande si je veux vraiment maintenir ça.
Et je n'ai pas voulu dire que non, je ne veux pas
faire ça.
Je pense que ça crée un peu de problèmes internaux aussi.
C'est un cas où je dois décider que je vais
dévergir pour l'existence de la fonctionnalité,
pour ce type-strip que j'ai fait.
Parce que je pense que ça sera plus intuitive,
même si ça crée une consistance,
l'expérience d'aujourd'hui sera plus intuitive.
Si je ne me maintiens pas ceci,
il y a un peu d'autres choses.
Les quarts numeriques, qui sont très élevéles,
dans un type-strip, vous n'avez pas des quarts numeriques.
Mais dans un type-strip, vous pouvez dire qu'un quarts de quarts
et vous avez desquels que l'on crée des numéros
et des quarts numeriques, et c'est très confusé.
Ce n'est pas un truc distinct à la runtime.
Comment représente-je ça ?
Et il y a quelques zones où je dois
faire ce que je veux faire,
comment est-ce que ça aurait été un changement de décision
pour moi pour dévergir et faire quelque chose
qui serait plus intuitive et plus facile à utiliser.
Pour le plus grand, il y a beaucoup de cas où je
n'avais pas de ce type de système.
Mais il y a quelques zones où je suis toujours
malade et je ne peux pas...
Je n'ai un système de type nouveau
qui fonctionne dans un de ces très précisés manières
et qui a des garanties.
Un type-strip, pourquoi vous faites ça ?
Vous vous mettez dans une position off
de décider si vous vous en faites
ou si vous maintenez cette compétition
avec ceci ou pour faire quelque chose
que je pense que ça va être plus facile pour les utilisateurs.
Mais c'est des choses qui me font de la nuit.
C'est un problème de la nuit.
C'est un des groupes qui veut
rester au sol pour le Maker.
Ça fait que des gens겠다 originalement
ne peux pas en Carroll dist genetically
avec des machines Tannerah pour là,


» il y a aktuellement

et le 2.0 a beaucoup de réchauffé.
Je suis content d'avoir fait ça.
Mais je savais que ce serait un feature de fast follow-on
parce que c'était déjà prêt.
Et si vous pensez à la match de pattern,
c'est comme, c'est ça.
Si c'est ça, fais ça.
Si c'est ça, fais ça.
Ce n'est pas déjà comme validation,
avec un peu d'un extrait sur le rap.
C'est un feature très petit,
dans des manières où je suis vraiment
en train de faire le bénéfice
de tout ce type de choses.
Mais c'est là où j'adore.
C'est super cool.
C'est vraiment excitant,
ce que vous pouvez faire avec un type de type de run-time.
Si vous vous dites que vous avez des logiques
qui disent que si A,
vous avez un fonction de ce type,
si B, vous avez un fonction de ce type, etc.
La définition doit être émettue légèrement.
On dirait que c'est 100 cas,
vous devez aller à chaque cas
et sequentially vérifier si elles matchent.
Parce que, par définition,
vous devez les faire en ordre.
C'est comme la match de pattern.
De l'air rental,
c'est pour les εί ou l' מא� ou un patch de desired de filters


en temps, c'est comme 100 cas que doit être garantie que l'un des cas matchs, comme
plus tard, dans l'expression, sera fait avant tout ce qui s'occupe plus tard.
Mais parce que nous avons cette grande introspectabilité, on peut dire, OK,
bien sûr, ils doivent être renseignés légèrement, mais parce que nous savons que
ces deux choses ne peuvent jamais se réciter, nous pouvons écrire à la
78e branch et faire ceci, parce que nous savons que,
depuis que ceci est matché, rien d'autre que les autres.
Il y a des choses qui sont comme, il y a beaucoup de possibilités, je pense,
avec ce type de système introspectable, que,
en JavaScript, je pense que le langage, en itself, est un
match de pattern, c'est un proposé pour mettre en place le langage,
mais ça ne pourrait jamais faire de quoi, parce qu'il n'y a pas de type
ou de type de base, type de comparaison et logique en JavaScript.
Même si ils ont évoqué ça, même si vous l'avez écrit en syntaxe native,
vous ne pourriez jamais pouvoir traverser un match de pattern en temps constant,
mais parce que nous avons l'obligation de comparer ces...
C'est une union ordre, et tout ça se passe en ce moment.
J'aime ce genre de choses, comme le type de système est si puissant.
Donc parfois, vous pouvez construire ces petits rappeurs qui
font des choses qui se sentent totalement impossibles,
comme dans d'autres contextes, et qui sont magiques.
Et bien sûr, c'est très satisfait de construire ça,
parce que c'est plus de travail que de construire le type de système.
Mais ce que vous avez fait, ça se sent vraiment magnifique.
Je vais le réélever cette semaine.
Je pense que les gens seront vraiment excitées.
C'est le même niveau de syntaxe,
c'est très concis, très réel,
comme le type de API, vous pouvez le dire,
des types de définitions, etc.
Mais aussi, ça a un profit de performance
où vous pouvez avoir une performance
que vous n'aurez jamais pu avoir,
même nativement, comme en cas de la maquillage,
un style de pattern,
donc je suis très, très excité de vous montrer.
C'est super incroyable.
Je suis un grand type de T.S.
Je l'utilise beaucoup,
et les caractéristiques de performance ne sont pas super bonnes.
J'ai testé un peu contre ça,
et c'est totalement raisonnable.
La performance, je vais le mettre dans la carrière,
c'est bon, et il n'y a rien d'invité,
et les gens ne devraient pas utiliser ça
parce que c'est la performance,
mais je pense que,
peut-être plus, pour la maquillage,
et pour beaucoup de validation en général,
c'est probablement une partie de votre code
qui peut être sur le path hot,
si vous avez un certain nombre de formes
sur un objet et sur un autre,
ça pourrait faire une différence.
Je pense que ça a beaucoup de potentiel,
et je suis excité pour les autres authors,
pour être plus intégrés,
et pour évoluer la respectibilité,
parce que c'est un des choses
où JavaScript n'a jamais vraiment eu
un système de runtime
qui a permis ce genre de choses,
et je sais que je ne peux pas...
Je peux avoir des idées pour les choses
que je peux construire,
mais je suis sûr que d'autres gens
peuvent avoir des idées cool
pour les choses que ça pourrait enlever,
donc je suis certainement
en regardant plus de l'intégration
et en en savoir plus de choses
pour les autres,
pour les autres,
pour les autres.
C'est intéressant.
Ça remet les questions, David.
Merci d'avoir regardé.
Vous avez mis un nombre d'expertises
dans cette bibliothèque,
et la prochaine fois que je dois avoir
des besoins de validation,
je vais être en train de le faire.
Merci d'avoir regardé le podcast.
C'est génial.
Merci d'avoir regardé.
C'était un bon moment.
Oui, c'est génial.