Add pt-br for getting-started folder #133
Conversation
|
Thanks for the PR! This section of the codebase is owned by @khaosdoctor and @danilofuchs - if they write a comment saying "LGTM" then it will be merged. |
Translation of TS for the New Programmer.mdtitle: TypeScript for The New Programmed oneline: Learn TypeScript from scratchCongratulations on choosing TypeScript as one of your first languages - you're already making good decisions! You may have heard that TypeScript is a "flavor" or a "variant" of JavaScript. The relationship between TypeScript (TS) and JavaScript (JS) is unique among modern programming languages, so learning more about this relationship will help you understand how TypeScript adds to JavaScript. What is JavaScript? A Brief HistoryJavaScript (also known as ECMAScript) began its life as a simple scriptling lingaugem for browsers. At the time it was invented, it was always expected to be used for small snippets of code embedded on a web page - writing more than a dozen lines of code would be unusual. Therefore, young browsers of the time executed such code very slowly. However, over time, JS became more and more popular and web developers began using it to create interactive experiences. Web browser developers responded to this increased use of JS by optimizing their engines by optimizing their engines (dynamic compilation) and extending what could be done with it (adding APIs), which in turn made web developers use it even more. On modern websites, your browser is often running applications that have hundreds of thousands of lines of code. This is the long and gradual growth of the web, starting as a simple network of static pages and evolving into a platform for Applications rich of all kinds. More than that, JS has become popular enough to be used outside the context of browsers, such as implementing JS servers using node.js. JS's "run anywhere" nature makes it an attractive choice for cross-platform development. There are many developers these days who use only JavaScript to program your entire suite of applications! To summarize, we have a language that was developed for quick uses and then grew into a complete tool for writing applications with millions of lines. Every language has its own Individuals - uniqueness and surprises and the humble beginning of JavaScript makes it many These. Some examples:
Most programming languages would throw an error when this type of situation occurred, some would do so at compile time - before any code was running. When writing small programs, such individualities are annoying but manageable; when writing applications with hundreds or thousands of lines of code, these constant surprises are a serious problem. TypeScript: A Static Type CheckerWe said before that some languages would not allow these programs to bug or run. Error detection without code execution is called static check. Determining what is an error and what is not based on the types of values being operated is called static verification of Types. TypeScript checks a program for errors before it runs and does so based on the kinds of values, is a static type tester. For example, the last example above has an error because of the kind from // @errors: 2551
const obj = { width: 10, height: 15 };
const area = obj.width * obj.heigth;A JavaScript Typed SupersetHow does TypeScript re-trigger with JavaScript then? SyntaxTypeScript is a language that is a Superset of JavaScript: JS syntax is therefore valid in TS. Syntax refers to the way we write text to form a program. For example, this code has a syntax because there's a lack of // @errors: 1005
let a = (4TypeScript does not consider any JavaScript code to be an error because of its syntax. This means you can take any JavaScript functional code and put it into a TypeScript file without worrying about how it's written. TypesHowever, TypeScript is a superset Typed, meaning that you add rules about how different types of values can be used. The previous error about As another example, this is JavaScript code that you can run in your browser and it will display a value: console.log(4 / []);This syntactically cool program displays // @errors: 2363
console.log(4 / []);It's possible that you actually Want split a number po rum array, maybe just to see what happens, but most of the time this is a programming error. The TypeScript type checker is designed to allow correct programs while preventing as many common errors as possible. (Later, we'll learn about settings that you can use to configure how strictly TypeScript checks your code.) If you move some code from a JavaScript file to a TypeScript file, you can see type errors depending on how the code is written. These can be legitimate problems with code or TypeScript being overconservative. Through this guide we will demonstrate how to add various TypeScript syntaxes to eliminate such errors. Runtime BehaviorTypeScript is also a programming language that preserves the runtime behavior javascript. For example, dividing by zero in JavaScript produces This means that you move JavaScript code from TypeScript, it is secure that will run the same way that TypeScript thinks the code has type errors. Maintaining the same behavior at runtime as JavaScript is a fundamental promise of TypeScript because it means that you can easily transition between two languages without worrying about subtle differences that can cause your program to stop working. Deleted TypesRoughly speaking, once the TypeScript compiler has finished checking your code, it Erases the types to produce the resulting "compiled" code. This means that once your code is compiled, the pure Result JS code has no type information. This also means that TypeScript never changes the behaviour program based on the types it infers. The end of this is that while you see type errors during compilation, the type system itself has no influence on how your program works when it runs. Finally, TypeScript does not provide any additional runtime library. Your programs will use the same standard (or external) libraries as JavaScript programs, so there are no additional TypeScript-specific tools to learn. Learning JavaScript and TypeScriptWe often see the question "Should I learn JavaScript or TypeScript?". The answer is that you can't learn TypeScript without learning JavaScript! TypeScript shares syntax and runtime behavior with JavaScript, so anything you want to learn about JavaScript will be helping you learn TypeScript at the same time. There are many, many resources available for programmers to learn JavaScript; you No you should ignore these features if you are writing TypeScript. For example, there are about 20 times as many questions in StackOverflow that are marked with If you find yourself looking for something like "how to organize a list in TypeScript," remember: TypeSript is the JavaScript execution environment with build-time type checker. The way you organize a list in TypeScript is the same in JavaScript. If you find a feature that uses TypeScript directly this is great too, but don't just think that you need specific TypeScript answers to day-to-day questions about how to achieve execution environment tasks. Next StepsThis was a short summary of the syntax and tools used in TypeScript in day-to-day life. From here, you can:
Translation of TS for OOPers.mdtitle: TypeScript for Java/C# programmers oneline: Learn TypeScript if you have a background with object-oriented languagesTypeScript is a popular choice for programmers accustomed to other static-typing languages such as C# and Java. The TypeScript type system offers many of the same benefits, such as better code completion, premature error detection, and clearer commotion between parts of your program. While TypeScript provides many familiar features for these developers, it is worth taking a step back to see how much JavaScript (as a consequence TypeScript) differs from object-oriented languages. Understanding these differences will help you write javascript code better and avoid common pitfalls that programmers who go directly from C#/Java to TypeScript fall. Co-learning JavaScriptIf you're already familiar with JavaScript but are primarily a Java or C# programmer, this introductory page can help explain some of the common misconceptions and pitfalls you might be susceptible to. Some of the forms of TypeScript type templates are quite different from Java or C# and it's important to keep those in mind when learning TypeScript. If you are a Java or C# developer who is new to JavaScript in general, we recommend learning a bit of JavaScript without types first to understand the behavior of JavaScript at runtime. Because TypeScript doesn't change the way your code is Run, you'll still have to learn how JavaScript works to write code that actually does something! It is important to remember that TypeScript uses the same execution environment that JavaScript, then any resources on how to perform certain behavior at runtime (convert a string to a number, display an alert, write a file to disk, etc.) will always apply equally to TypeScript programs. Don't limit yourself to specific TypeScript features! Rethinking the ClassC# and Java are what we can call languages compulsorily object-oriented. In these languages, the class is the basic unit of code organization and also the basic container of all data and behavior at run time. Forcing all functionality and data to be contained in classes can be a good domain model for some problems, but not every domain Need be represented in this way. Free functions and DataIn JavaScript, functions can exist anywhere and data can be sent freely without being within a Static ClassesAdditionally, certain C# and Java constructs such as singletons and static classes are unnecessary in TypeScript. POO in TypeScriptWith that said, you can still use classes if you want! Some issues are suitable to be resolved by traditional POO hierarchy, and TypeScript support for JavaScript classes will make these templates even more powerful. TypeScript supports many common patterns such as implementing interfaces, inheritance, and static methods. We will cover classes later in this guide. Rethinking TypesThe TypeScript understanding of a kind is currently quite different from c# or java. Let's explore some differences. Rated Type System ReifiedIn C# or Java, any given value or object has an exact type - be it These aspects describe a system of type nominal, reified. The types we write in code are present at runtimes, and these types are related by their statements, not their structures. Types as SetsIn C# or Java, it is significant to think of a one-to-one match between the runtime types and their build-time declarations. In TypeScript, it is better to think of a type as a set of values who share something in common. Because types are only sets, a particular value can belong to the many sets at the same time. Once you start thinking about types like sets, certain operations become quite natural. For example, in C#, it's quite strange to send a value that can be one In TypeScript, this becomes quite natural once you realize that every type is just a set. How do you describe a value that can belong to the set TypeScript provides a number of mechanisms for working with types in the form of sets and you will find that they are more intuitive if you think of types as sets. Structural Types ErasedIn TypeScript, objects No are of an exact type. For example, if we build an object that satisfies an interface, we can use this object where that interface is expected even if there is no delcartive relationship between the two. interface Ponto {
x: number;
y: number;
}
interface Nomeada {
nome: string;
}
function exibirPonto(point: Ponto) {
console.log('x = ' + point.x + ', y = ' + point.y);
}
function exibirNome(x: Nomeada) {
console.log('Olá, ' + x.nome);
}
const obj = {
x: 0,
y: 0,
nome: 'Origem'
};
exibirPonto(obj);
exibirNome(obj);The TypeScript type system is structural, not nominal: We can use The TypeScript type system is also not reified: There is nothing at run time that we will say if that Going back to the idea of Consequences of Structural TypingPOO programmers are often surprised by the particular aspects of structural typing. Empty TypesThe first is that the empty type seems to defy expectations: class Vazio {}
function fn(arg: Vazio) {
// fazer algo?
}
// Sem erro, mas isso não é um 'Vazio' ?
fn({ k: 10 });TypeScript determines whether the call to This may seem very surprising, but ultimately it is a very similar relationship to one applied in nominal POO languages. A subclass cannot remove a property of its base class, because doing so would destroy the natural subtype relationship between the derived class and its base. Structural typing systems simply identify this relationship implicitly by describing subtypes in terms of having properties of compatible types. Identical TypesAnother frequent source of surprise comes with identical types: class Carro {
dirigir() {
// pressionar o acelerador
}
}
class Golfer {
dirigir() {
// jogar a bola para longe
}
}
// Sem erro?
let w: Carro = new Golfer();Again, this is not a mistake because the Structures of these classes are the same. While this may seem like a potential source of confusion, in practice, identical classes that should not be related are not common. We learn more about how classes relate to each other in the Classes chapter. ReflectionPOO programmers are accustomed to being able to pick up the kind of any value, even a generic: // C#
static void TipoDoLog<T>() {
Console.WriteLine(typeof(T).Name);
}Because the TypeScript type system is completely erased, information about e.g. the instantiation of a generic type parameter is not available at run time. JavaScript has some limited primitives like Next StepsThis documentation is a high-level summary of syntax and types you would use in code on a day-to-day business. Hence you should:
Translation of TS for JS Programmers.mdtitle: TypeScript for JavaScript programmers oneline: Learn how TypeScript extends JavaScriptTypeScript has an unusual relationship with JavaScript. TypeScript offers all javascript features, and an additional layer at the top of this: the TypeScript type system. For example, JavaScript offers language primitives such as This means that your existing JavaScript code is also TypeScript code. The main benefit of TypeScript is that it can highlight unexpected behavior in your code, reducing the chance of bugs. This tutorial provides a summary of TypeScript, focusing on your type system. Types by InferenceTypeScript knows the JavaScript language and will generate types for you in many cases. For example when creating a variable and assigning it to a certain value, TypeScript uses the value as its type. let olaMundo = 'Olá Mundo';
// ^?Understanding how JavaScript works, TypeScript can build a system of types that accepts JavaScript code but has types. This provides a system of types without the need to add extra characters to make the types explicit in your code. This is how TypeScript knows that You may have already written JavaScript code in Visual Studio Code, and had auto-complete from the editor. Visual Studio Code uses TypeScript under the cloths to make it easier to work with JavaScript. Defining TypesYou can use a wide variety of project patterns types in JavaScript. However, some design patterns make automatic type inference difficult (for example, patterns that use dynamic programming). To cover these cases, TypeScript supports a JavaScript extension, which provides places for you to tell TypeScript what the types should be. For example, to create an objteo with an inferred type that includes const usuario = {
nome: 'Hayes',
id: 0
};You can explicitly describe the shape of this object using a declaration of interface Usuario {
nome: string;
id: number;
}You can then declare a JavaScript object according to the format of your new interface Usuario {
nome: string;
id: number;
}
// ---cut---
const usuario: Usuario = {
nome: 'Hayes',
id: 0
};If you provide an object that does not match the interface you provided, TypeScript will alert you: // @errors: 2322
interface Usuario {
nome: string;
id: number;
}
const usuario: Usuario = {
nomeDeUsuario: 'Hayes',
id: 0
};Since JavaScript supports classes and object-oriented programming, So does TypeScript. You can use the interface declaration with classes: interface Usuario {
nome: string;
id: number;
}
class UsuarioConta {
nome: string;
id: number;
constructor(nome: string, id: number) {
this.nome = nome;
this.id = id;
}
}
const usuario: Usuario = new UsuarioConta('Murphy', 1);You can use interfaces to tipar parameters and return values in functions: // @noErrors
interface Usuario {
nome: string;
id: number;
}
// ---cut---
function buscarUsuarioAdmin(): Usuario {
//...
}
function deletarUsuario(usuario: Usuario) {
// ...
}There is already a small set of primitive types available in JavaScript: You will see that there are two syntaxes for constructing types: Interfaces and Types. You should prefer Composing TypesWith TypeScript, you can create complex types by combining simple ones. There are two popular ways to do this: with unions, and with generics. UnionsWith a union, you can declare that a type can be one of many. For example, you can describe a type type MeuBooleano = true | false;Note: if you hover over the A popular use case of union types is to describe the value that a set of Literals from type EstadoDaJanela = 'aberto' | 'fechado' | 'minimizado';
type EstadosDeBloqueio = 'trancado' | 'destrancado';
type NumerosImparesMenoresQue10 = 1 | 3 | 5 | 7 | 9;Unions provide a way to manage different types as well. For example, you might have a function that receives as an argument a function buscarComprimento(obj: string | string[]) {
return obj.length;
}To know the type of a variable, use
For example, you can make a function return different types depending on whether a string or array is passed: function envolverEmArray(obj: string | string[]) {
if (typeof obj === "string") {
return [obj];
// ^?
}
return obj;
}GenericGenerics provide variables for types. A common example is an array. An array without generics can contain anything. An array with generics can describe the values that that array contains. type ArrayDeStrings = Array<string>;
type ArrayDeNumeros = Array<number>;
type ObjetoComNomeArray = Array<{ nome: string }>;You can declare your own types using generics: // @errors: 2345
interface Mochila<Tipo> {
adicionar: (obj: Tipo) => void;
buscar: () => Tipo;
}
// Esse é um atalho para dizer ao Typescript que há uma
// constante chamada mochila, e não se preocupar de onde ela veio.
declare const mochila: Mochila<string>;
// objeto é uma string, porque nós o declaramos acima como a parte variável de Mochila.
const objeto = mochila.buscar();
// Já que a variável mochila é uma string, você não pode passar um número para a função adicionar.
mochila.adicionar(23);Structural Types SystemOne of the central principles of TypeScript is that type checking is focused on format that the values have. This is sometimes called "duck typing" or "structural typing". In a structured typing system, if two objects have the same format, they are considered of the same type. interface Ponto {
x: number;
y: number;
}
function exibirPonto(p: Ponto) {
console.log(`${p.x}, ${p.y}`);
}
// exibe "12, 26"
const ponto = { x: 12, y: 26 };
exibirPonto(ponto);The variable Type matching only requires that a subset of object fields match: // @errors: 2345
interface Ponto {
x: number;
y: number;
}
function exibirPonto(p: Ponto) {
console.log(`${p.x}, ${p.y}`);
}
// ---cut---
const ponto3 = { x: 12, y: 26, z: 89 };
exibirPonto(ponto3); // logs "12, 26"
const rect = { x: 33, y: 3, largura: 30, altura: 80 };
exibirPonto(rect); // logs "33, 3"
const color = { hex: '#187ABF' };
exibirPonto(color);There is no difference between how classes and objects conform to formats: // @errors: 2345
interface Ponto {
x: number;
y: number;
}
function exibirPonto(p: Ponto) {
console.log(`${p.x}, ${p.y}`);
}
// ---cut---
class PontoVirtual {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}
const novoPontoV = new PontoVirtual(13, 56);
exibirPonto(novoPontoV); // logs "13, 56"If the object or class has all the required properties, TypeScript will say that they match, regardless of the implementation details. Next StepsThis documentation is a high-level summary of syntax and types you would use in code on a day-to-day business. Hence you should:
Translation of TS for Functional Programmers.mdtitle: TypeScript for Functional Programmers oneline: Learn Typescript if you have a history with functional programmingTypescript began its life in an attempt to bring traditionally object-oriented types to JavaScript so that programmers at Microsoft could bring traditionally object-oriented programs to the web. As it developed, the Typescript type system evolved into template code written by native JavaScripters. The resulting system is powerful, interesting and confusing. This introduction is designed to help Haskell or ML programmers who want to learn Typescript. It describes how the Typescript type system differs from the Haskell type system. It also describes the unique functionality of the Typescript typesystem that has ancestry in JavaScript code modeling. This introduction does not cover object-oriented programming. In practice, object-oriented programming in Typescript is similar to other popular languages with OO functionality. PrerequisitesIn this introduction, I take it that you have the following knowledge:
If you need to learn the good parts of Javascript, read JavaScript: The Good Parts. You may be able to skip the book if you know how to write programs in a call-by-value lexical scope dread language with too much mutability and not much else. R4RS Scheme is a good example. The C++ Programming Language is a good place to learn about c-style syntax. Concepts that are not in HaskellNative TypesJavaScript defines 8 native types:
Typescript has the corresponding primitive types for the native types:
Other important typescript types
Notes:
Types in boxesJavascript has types in boxes equivalent to primitive types that contain methods that programmers associate with these types. Typescript reflects this with, for example, the difference between the primitive type (1).toExponential();
// é equivalente a
Number.prototype.toExponential.call(1);Note that to call a method on a literal numeric it has to be in parentheses to assist the translator. Gradual typingTypescript uses type // com "noImplicitAny": false no tsconfig.json, anys: any[]
const anys = [];
anys.push(1);
anys.push('oh não');
anys.push({ qualquer: 'coisa' });And you can use expressions of the type anys.map(anys[1]); // oh não, "oh não" não é uma função
let sepsis = anys[0] + anys[1]; // isso poderia significar qualquer coisaTo have an error when Typescript produces a Structural typingStructural typing is a familiar concept for most functional programmers, even though Haskell and most MLs are not stylistually typed. Its basic form is quite simple: // @strict: false
let o = { x: 'olá', extra: 1 }; // ok
let o2: { x: string } = o; // okHere, the literal object Named types only give a name to a type; for assignment purposes there is no difference between the type name // @errors: 2322
type Um = { p: string };
interface Dois {
p: string;
}
class Tres {
p = 'Olá';
}
let x: Um = { p: 'oi' };
let dois: Dois = x;
dois = new Tres();UnionsIn Typescript, the union types are marked. In other words, they are not discriminated unions as function começar(
arg: string | string[] | (() => string) | { s: string }
): string {
// isso é super comum em Javascript
if (typeof arg === 'string') {
return casoComum(arg);
} else if (Array.isArray(arg)) {
return arg.map(casoComum).join(',');
} else if (typeof arg === 'function') {
return casoComum(arg());
} else {
return casoComum(arg.s);
}
function casoComum(s: string): string {
// finalmente, apenas converta uma string para outra string
return s;
}
}
The following types have native predicates:
Note that functions and arrays are run-time objects, but have their own predicates. IntersectionsIn addition to unions, Typescript also has intersections: type Combinada = { a: number } & { b: string };
type Conflitante = { a: number } & { a: string };
Unit typesUnit types are subtypes of primitive types that contain exactly one primitive value. For example, the string declare function encher(
s: string,
n: number,
direction: 'esquerda' | 'direita'
): string;
encher('hi', 10, 'esquerda');When necessary, the compiler Extends — converts to a super type — the unit type for a primitive type, such as // @errors: 2345
declare function encher(
s: string,
n: number,
direction: 'esquerda' | 'direita'
): string;
// ---cut---
let s = 'direita';
encher('hi', 10, s); // error: 'string' is not assignable to '"esquerda" | "direita"'How the error happens:
You can resolve this with a type notation for declare function encher(
s: string,
n: number,
direction: 'esquerda' | 'direita'
): string;
// ---cut---
let s: 'esquerda' | 'direita' = 'direita';
encher('hi', 10, s);Concepts similar to HaskellContextual typingTypeScript has some obvious places where it can infer types, such as variable declarations: let s = 'Eu sou uma string!';But it also infers types in some other places that you might not expect if you've worked with other languages with C-based syntaxes: declare function map<T, U>(f: (t: T) => U, ts: T[]): U[];
let sns = map(n => n.toString(), [1, 2, 3]);Here Note that inference will work in any order, but intellisense will only work from right to left, so TypeScript prefers to declare declare function map<T, U>(ts: T[], f: (t: T) => U): U[];Contextual typing also works recursively between literal objects, and on unit types that would be inferred as declare function rodar<T>(thunk: (t: T) => void): T;
let i: { inferencia: string } = rodar(o => {
o.inferencia = 'INSIRA O ESTADO AQUI';
});The type of
And it does this while you're typing, so that before you type Type nicknamesType nicknames are mere nicknames, as well as type Tamanho = [number, number];
let x: Tamanho = [101.1, 999.9];The closest equivalent to type FString = string & { __compileTimeOnly: any };One Discriminated UnionsThe closest equivalent to the type Forma =
| { tipo: 'circulo'; raio: number }
| { tipo: 'quadrado'; x: number }
| { tipo: 'triangulo'; x: number; y: number };Unlike Haskell, tagging, or discriminating, is just a property in each type object. Each variant has an identical property with a different unit type. This is still a normal type union; or type Forma =
| { tipo: 'circulo'; raio: number }
| { tipo: 'quadrado'; x: number }
| { tipo: 'triangulo'; x: number; y: number };
function area(s: Forma) {
if (s.tipo === 'circulo') {
return Math.PI * s.raio * s.raio;
} else if (s.tipo === 'quadrado') {
return s.x * s.x;
} else {
return (s.x * s.y) / 2;
}
}Note that the return type of Also, unlike Haskell, common properties appear in any union, so you can usually discriminate against multiple union members: type Forma =
| { tipo: 'circulo'; raio: number }
| { tipo: 'quadrado'; x: number }
| { tipo: 'triangulo'; x: number; y: number };
// ---cut---
function altura(s: Forma) {
if (s.tipo === 'circulo') {
return 2 * s.raio;
} else {
// s.tipo: "quadrado" | "triangulo"
return s.x;
}
}Type ParametersLike most languages descending from C, TypeScript requests the declaration of type parameters: function levantarArray<T>(t: T): Array<T> {
return [t];
}There is no case requirement, but type parameters are conventionally single capital letters. Type parameters can also be restricted to a type, which behaves somewhat like class constraints: function primeiro<T extends { length: number }>(t1: T, t2: T): T {
return t1.length > t2.length ? t1 : t2;
}TypeScript can usually infer type arguments from a call based on the type of arguments, so type arguments are not usually required. Because TypeScript is structural, it does not need any type parameters as many nominal systems. Specifically, they are not required to make a polymorphic function. Type parameters should be used only for propagate type information, such as restricting parameters to be of the same type: function comprimento<T extends ArrayLike<unknown>>(t: T): number {}
function comprimento(t: ArrayLike<unknown>): number {}In the first Top typesTypeScript has no higher types, so the following is not allowed: function comprimento<T extends ArrayLike<unknown>, U>(m: T<U>) {}Point-free programmingPoint-free programming — Heavy use of currying and composition functions — is possible in JavaScript, but can be verbose. In TypeScript, type inference often fails for point-free programs, so you'll end up specifying type parameters rather than value parameters. The result is so verbose that it is usually best to avoid point-free progamation. Module systemThe modern syntax of JavaScript modules is similar to Haskell's, except that any file with import { value, Type } from 'npm-package';
import { other, Types } from './local-package';
import * as prefix from '../lib/third-package';You can also import commonjs modules — modules written using the node mobile system.js: import f = require('single-function-package');You can export with an export list: export { f };
function f() {
return g();
}
function g() {} // g is not exportedOr by marking each export individually: export function f { return g() }
function g() { }The latter is more common but both are allowed, even when in the same file.
|
luk3skyw4lker
changed the title
|
LGTM |
|
There was an issue merging, maybe try again khaosdoctor. Details |
|
LGTM |
|
There was an issue merging, maybe try again khaosdoctor. Details |
|
So I guess we have a problem, and I can't see the results, @orta can you save us? |
|
LGTM |
|
There was an issue merging, maybe try again khaosdoctor. Details |
|
@danilofuchs @orta @khaosdoctor Is this PR gonna be merged? |
|
We're trying but we can't merge it. Apparently it's not working anymore |
|
LGTM |
|
Merging because @khaosdoctor is a code-owner of all the changes - thanks! |
|
YAY IT WORKED |
|
YEAHHHHHHHH |
Opening PR for translations of files from the get-started folder. first one is already translated (TS for Functional Programmers.md)