spaces in code and link spans

2025-08-13 18:24:39 +02:00 · 2024-04-20 22:52:07 -07:00
parent c9f7d9a92c
commit 12cb60f1b7
9 changed files with 156 additions and 162 deletions
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -15,4 +15,4 @@ jobs:
        with:
          ruby-version: '3.2'
      - run: gem install mdl
-      - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD047
+      - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD038,MD039,MD047
--- a/es-es/raku-es.html.markdown
+++ b/es-es/raku-es.html.markdown
@@ -10,7 +10,6 @@ translators:
    - ["Luis F. Uceta", "https://github.com/uzluisf"]
 lang: es-es
 ---
-
 Raku es un lenguaje de programación altamente capaz y con características
 abundantes para hacerlo el lenguage ideal por los próximos 100 años.

@@ -207,7 +206,7 @@ con-nombre-mandatorio(str => "Mi texto"); #=> Mi texto!
 con-nombre-mandatorio;    # error al tiempo de ejecución:
                          # "Required named parameter not passed"
                          # ("Parámetro nombrado requerido no proveído")
-con-nombre-mandatorio(3);# error al tiempo de ejecución:
+con-nombre-mandatorio(3); # error al tiempo de ejecución:
                          # "Too many positional parameters passed"
                          # ("Demasiados argumentos posicionales proveídos")

@@ -716,7 +715,6 @@ multi dilo(Str $s) { # un multi es una subrutina por defecto
 }
 dilo("azul"); # prints "Cadena de texto: azul"
 dilo(True); # falla al *tiempo de compilación* con
-            # "calling 'dilo' will never work with arguments of types ..."
            # (invocar 'dilo' nunca funcionará con argumentos de tipos ...")
 ## con precondición arbitraria (¿recuerdas los subconjuntos?):
 multi es-grande(Int $n where * > 50) { "¡Sí!" } # usando una clausura
@@ -1926,8 +1924,7 @@ Si quieres ir más allá de lo que se muestra aquí, puedes:
 explicaciones. Las publicaciones fueron suspendidas al final del 2015 cuando
 el lenguaje fue declarado estable y Raku.c fue lanzado.
 - Unirte a `#raku` en `irc.freenode.net`. Las personas aquí son siempre serviciales.
- - Chequear la [fuente de las funciones y clases de Raku
- ](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
+ - Chequear la [fuente de las funciones y clases de Raku](https://github.com/rakudo/rakudo/tree/master/src/core.c). Rakudo está principalmente
 escrito en Raku (con mucho de NQP, "Not Quite Perl" ("No Perl Todavía"), un
 subconjunto de Raku que es más fácil de implementar y optimizar).
 - Leer [documentos acerca del diseño del lenguaje](http://design.raku.org).
--- a/fr-fr/elixir-fr.html.markdown
+++ b/fr-fr/elixir-fr.html.markdown
@@ -13,7 +13,6 @@ lang: fr-fr
 Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
 Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités.

-
 ```elixir
 # Un commentaire simple sur une seule ligne commence par un dièse.

@@ -471,7 +470,7 @@ Agent.update(my_agent, fn colors -> ["blue" | colors] end)
 ## Références

 * [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
-* [Documentation Elixir ](https://elixir-lang.org/docs.html)
+* [Documentation Elixir](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
 * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
--- a/hi-in/amd.html.markdown
+++ b/hi-in/amd.html.markdown
@@ -14,10 +14,10 @@ lang: hi-in
 ### मूल अवधारणा

 ```javascript
-// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : ` define` और` require`
+// बुनियादी एएमडी एपीआई दो तरीकों लेकिन कुछ भी नहीं होते : `define` और `require`
 // और सभी मॉड्यूल परिभाषा और खपत के बारे में है :
 // `define` एक मॉड्यूल को परिभाषित करता है
-// ` require` निर्भरता का एक सेट का आयात करता है और
+// `require` निर्भरता का एक सेट का आयात करता है और
 // पारित कर दिया कॉलबैक में उन्हें सेवन करती है

 // एक नया नाम देकर हम मॉड्यूल को परिभाषित करने का उपयोग करके शुरू करते हैं
@@ -29,13 +29,13 @@ define('awesomeAMD', function(){
  };
 // एक मॉड्यूल के कारखाने समारोह की मान है
  // जब प्राप्त होगा क्या अन्य मॉड्यूल या आवश्यकता कॉल
-  // हमारे ` awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
+  // हमारे `awesomeAMD` मॉड्यूल की आवश्यकता होती है ।
  // निर्यात मूल्य कुछ भी हो सकता है, (निर्माता ) काम करता है,
  // वस्तुओं, पुरातन, (जो कि बहुत ज्यादा मदद नहीं करेगा , हालांकि) भी अपरिभाषित ।
  return isAMDAwesome;
 });

-// अब, हमारे ` awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
+// अब, हमारे `awesomeAMD` मॉड्यूल पर निर्भर करता है कि किसी अन्य मॉड्यूल परिभाषित करते हैं।
 // हमारे परिभाषित करने के लिए एक अतिरिक्त तर्क है कि नोटिस
 अब // मॉड्यूल की निर्भरता :
 define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
@@ -51,8 +51,8 @@ define('loudmouth', ['awesomeAMD'], function(awesomeAMD){
  return tellEveryone;
 });

-// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए ` require` का उपयोग करते हैं
-// हमारे कार्यक्रम बंद किक । ` require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
+// हम अब परिभाषित का उपयोग करने के लिए कैसे जानते हैं के रूप में, के लिए `require` का उपयोग करते हैं
+// हमारे कार्यक्रम बंद किक । `require` के हस्ताक्षर है :(arrayOfDependencies, callback)`.
 require(['loudmouth'], function(loudmouth){
  loudmouth();
 });
@@ -90,7 +90,7 @@ require(['modules/someClass'], function(SomeClass){
 console.log('So here we are, waiting!'); // this will run first
 ```

-परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । ` require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की ` baseUrl` के सापेक्ष ` modules` फ़ोल्डर में माना गया है :
+परंपरा के अनुसार , आप आमतौर पर एक फाइल में एक मॉड्यूल में ही रखते है । `require.js` फ़ाइल पथ पर आधारित मॉड्यूल नाम को हल कर सकते हैं , तो आप अपने मॉड्यूल के नाम करने की जरूरत नहीं है , लेकिन बस उनके स्थान का उपयोग कर उन्हें संदर्भित कर सकते हैं । उदाहरण के `में someClass` आपके विन्यास की `baseUrl` के सापेक्ष `modules` फ़ोल्डर में माना गया है :

 * app/
  * main.js
@@ -102,7 +102,7 @@ console.log('So here we are, waiting!'); // this will run first
    * things.js
    * ...

-इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना ` someClass` परिभाषित कर सकते हैं :
+इसका मतलब यह है कि हम एक मॉड्यूल आईडी निर्दिष्ट किए बिना `someClass` परिभाषित कर सकते हैं :

 ```javascript
 /* file: app/modules/someClass.js */
@@ -116,7 +116,7 @@ define(['daos/things', 'modules/someHelpers'], function(thingsDao, helpers){
 });
 ```

-अपने ` main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग ` requirejs.config ( configObj ) ` में परिवर्तन करने के लिए:
+अपने `main.js` में डिफ़ॉल्ट पथ मानचित्रण व्यवहार का उपयोग `requirejs.config ( configObj )` में परिवर्तन करने के लिए:

 ```javascript
 /* file: main.js */
@@ -129,13 +129,13 @@ requirejs.config({
  }
 });
 require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolLib, helpers){
-  //एक ` main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
+  //एक `main` फ़ाइल में कम से कम एक बार की आवश्यकता को फोन करने की जरूरत है,
  // अन्यथा कोई कोड कभी चलेंगे
  coolLib.doFancyStuffWith(helpers.transform($('#foo')));
 });
 ```

-` require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में ` require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु (` main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :
+`require.js` आधारित क्षुधा आमतौर पर एक डाटा विशेषता के रूप में `require.js` स्क्रिप्ट टैग को पारित कर दिया है कि एक एकल प्रवेश बिंदु ( `main.js` ) होगा। यह स्वचालित रूप से भरी हुई है और pageload पर क्रियान्वित किया जाएगा :

 ```html
 <!DOCTYPE html>
@@ -153,7 +153,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL

 कई लोगों को विकास के दौरान समझदार कोड संगठन के लिए एएमडी का उपयोग कर पसंद करते हैं, लेकिन अभी भी पेज लोड पर XHRs के सैकड़ों करने के बजाय उत्पादन में एक भी स्क्रिप्ट फ़ाइल जहाज करने के लिए चाहते हैं।

-(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) ` require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि ` r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
+(राइनो भी समर्थन किया है, तो आप शायद Node.js में चलेगा ) `require.js` ( अपनी परियोजना की निर्भरता ग्राफ का विश्लेषण , और अपने सभी मॉड्यूल युक्त एक एकल फाइल निर्माण कर सकते हैं कि `r.js` नामक एक स्क्रिप्ट के साथ आता है ठीक से minified और उपभोग के लिए तैयार है, ) नाम दिया है।
 Install it using `npm`:

 ```shell
@@ -183,33 +183,34 @@ $ r.js -o app.build.js
 })
 ```

-उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस ` Data-main` स्वैप:
+उत्पादन में बनाया फ़ाइल का उपयोग करने के लिए, बस `Data-main` स्वैप:

 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```

-एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन] (https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।
+एक अविश्वसनीय रूप से विस्तृत [निर्माण विकल्पों में से अवलोकन](https://github.com/jrburke/r.js/blob/master/build/example.build.js) GitHub रेपो में उपलब्ध है।

 ### विषय इस ट्यूटोरियल में शामिल नहीं
-* [लोडर प्लगइन्स / रूपांतरण] (http://requirejs.org/docs/plugins.html)
-* [CommonJS शैली लोड हो रहा है और निर्यात] (http://requirejs.org/docs/commonjs.html)
-* [उन्नत विन्यास] (http://requirejs.org/docs/api.html#config)
-* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)] (http://requirejs.org/docs/api.html#config-shim)
-* [सीएसएस लदान और require.js साथ अनुकूलन] (http://requirejs.org/docs/optimization.html#onecss)
-* (Https://github.com/jrburke/almond) [बनाता है के लिए almond.js का प्रयोग]
+
+* [लोडर प्लगइन्स / रूपांतरण](http://requirejs.org/docs/plugins.html)
+* [CommonJS शैली लोड हो रहा है और निर्यात](http://requirejs.org/docs/commonjs.html)
+* [उन्नत विन्यास](http://requirejs.org/docs/api.html#config)
+* [शिम विन्यास (गैर एएमडी मॉड्यूल लोडिंग)](http://requirejs.org/docs/api.html#config-shim)
+* [सीएसएस लदान और require.js साथ अनुकूलन](http://requirejs.org/docs/optimization.html#onecss)
+* [बनाता है के लिए almond.js का प्रयोग](Https://github.com/jrburke/almond)

 ### अग्रिम पठन:

-* [सरकारी कल्पना] (https://github.com/amdjs/amdjs-api/wiki/AMD)
-* [क्यों एएमडी?] (Http://requirejs.org/docs/whyamd.html)
-* [यूनिवर्सल मॉड्यूल परिभाषा] (https://github.com/umdjs/umd)
+* [सरकारी कल्पना](https://github.com/amdjs/amdjs-api/wiki/AMD)
+* [क्यों एएमडी?](Http://requirejs.org/docs/whyamd.html)
+* [यूनिवर्सल मॉड्यूल परिभाषा](https://github.com/umdjs/umd)

 ### कार्यान्वयन:

-* [Require.js] (http://requirejs.org)
-* [डोजो टूलकिट] (http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
-* [Cujo.js] (http://cujojs.com/)
-* [Curl.js] (https://github.com/cujojs/curl)
-* [Lsjs] (https://github.com/zazl/lsjs)
-* [एमडी] (https://github.com/alexlawrence/mmd)
+* [Require.js](http://requirejs.org)
+* [डोजो टूलकिट](http://dojotoolkit.org/documentation/tutorials/1.9/modules/)
+* [Cujo.js](http://cujojs.com/)
+* [Curl.js](https://github.com/cujojs/curl)
+* [Lsjs](https://github.com/zazl/lsjs)
+* [एमडी](https://github.com/alexlawrence/mmd)
--- a/hi-in/d.html.markdown
+++ b/hi-in/d.html.markdown
@@ -18,16 +18,15 @@ void main(string[] args) {
 ```

 अगर आप मेरे जैसे हैं और इंटरनेट पर समय बहुत अधिक समय खर्च करते हैं, तो आप बाधाओं के बारे में सुना है
-के बारे में [डी ] ( http://dlang.org/ )। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
+के बारे में [डी](http://dlang.org/)। डी प्रोग्रामिंग भाषा में एक आधुनिक, सामान्य प्रयोजन है ,
 सब कुछ के लिए समर्थन कम स्तर की सुविधाओं से करने के साथ बहु - प्रतिमान भाषा
 अर्थपूर्ण उच्च स्तरीय चीजें ।

 D सक्रिय रूप से सुपर स्मार्ट लोगों का एक बड़ा समूह द्वारा विकसित की है और नेतृत्व द्वारा किया जाता है
-[ वाल्टर ब्राइट ] ( https://en.wikipedia.org/wiki/Walter_Bright ) और
-[ आंद्रेई Alexandrescu ] ( https://en.wikipedia.org/wiki/Andrei_Alexandrescu )।
+[वाल्टर ब्राइट](https://en.wikipedia.org/wiki/Walter_Bright) और
+[आंद्रेई Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu)।
 जिस तरह की है कि सभी के साथ बाहर, चलो कुछ उदाहरणों पर गौर करते हैं!

-
 ```c
 import std.stdio;

@@ -48,9 +47,9 @@ void main() {
    do {
        n -= (n / 2);
    } while(n > 0);
-    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
-    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
-    // लेकिन पिछले छोड़कर।
+    // लिए और जब तक अच्छा कर रहे हैं, लेकिन D में हम 'foreach' छोरों पसंद करते हैं।
+    // '..' पहला मान सहित एक सतत श्रृंखला बनाता है,
+    // लेकिन पिछले छोड़कर।
    foreach(i; 1..1_000_000) {
        if(n % 2 == 0)
            writeln(i);
@@ -67,7 +66,7 @@ void main() {
 }
 ```

-हम ' struct`, `class`,` union`, और `` enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
+हम `struct`, `class`, `union`, और `enum` साथ नए प्रकार परिभाषित कर सकते हैं। Structs और unions
 मूल्य से कार्य करने के लिए पारित कर रहे हैं (यानी नकल) और वर्गों के संदर्भ द्वारा पारित कर रहे हैं। इसके अलावा,
 हम प्रकारों और मानों दोनों पर करने के लिए टेम्पलेट का उपयोग कर सकते हैं!

@@ -130,8 +129,8 @@ auto mat = new Matrix!(3, 3);

 Classes की बात हो रही है , एक दूसरे के लिए गुणों के बारे में बात करते हैं। एक संपत्ति
 एक value की तरह कार्य कर सकते हैं कि एक समारोह में मोटे तौर पर है, इसलिए हम कर सकते हैं
-के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (` structure.x = 7` ) है
-मनुष्य और सेटर तरीकों ( ` object.setX (7) `) !
+के शब्दों के साथ पॉड संरचनाओं की वाक्य रचना (`structure.x = 7`) है
+मनुष्य और सेटर तरीकों (`object.setX(7)`) !

 ```c
 // Consider a class parameterized on types 'T' & 'U'.
@@ -197,15 +196,15 @@ void main() {
 सीधे सदस्यों तक पहुँचने !

 हमारे निपटान पर अन्य वस्तु उन्मुख उपहार
-` interface`s , ` सार class`es शामिल
-और ` तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
+`interface`s , `सार class`es शामिल
+और `तरीकों override`ing । डी सिर्फ जावा की तरह विरासत करता है:
 आप कृपया के रूप में कई इंटरफेस को लागू करने, एक वर्ग का विस्तार ।

 हम डी एस OOP सुविधाओं देखा , लेकिन स्विच गियर छोड़ दिया । डी प्रस्तावों
-प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, ` pure`
+प्रथम श्रेणी के कार्यों के साथ कार्यात्मक प्रोग्रामिंग, `pure`
 काम करता है, और अपरिवर्तनीय डेटा । इसके अलावा, अपने पसंदीदा के सभी
 कार्यात्मक एल्गोरिदम ( नक्शा, फिल्टर , कम करने और मित्र हो सकते हैं)
-अद्भुत ` std.algorithm` मॉड्यूल में पाया!
+अद्भुत `std.algorithm` मॉड्यूल में पाया!

 ```c
 import std.algorithm : map, filter, reduce;
@@ -229,7 +228,7 @@ void main() {
 यही कारण है कि एक डी नवाचार करने के लिए धन्यवाद वर्दी समारोह कॉल सिंटेक्स के रूप में जानते हैं।
 UFCS के साथ, हम एक विधि के रूप में एक समारोह कॉल लिखने के लिए चुन सकते हैं
 या मुफ्त समारोह कॉल ! वाल्टर इस पर एक अच्छा लेख लिखा था
-[यहाँ ।] ( http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394 )
+[यहाँ ।](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
 संक्षेप में, आप जिनकी पहली पैरामीटर कार्यों कॉल कर सकते हैं
 एक विधि के रूप में ग्रुप ए की किसी भी अभिव्यक्ति पर कुछ प्रकार एक की है ।

--- a/it-it/logtalk-it.html.markdown
+++ b/it-it/logtalk-it.html.markdown
@@ -45,7 +45,7 @@ Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggett

 # Compilazione e il caricamento dei file sorgenti

-Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
+Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file `list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):

 ```logtalk
 ?- {list}.
@@ -475,7 +475,7 @@ X = 3
 yes
 ```

-Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e` abolish_events/5` .
+Gli eventi possono essere impostati e cancellati dinamicamente in fase di esecuzione chiamando i predicati predefiniti `define_events/5` e `abolish_events/5`.

 La programmazione event-driven può essere vista come una forma di _computational reflection_. Si noti però che gli eventi sono generati solo quando si utilizza il costrutto di controllo per l'invio di messaggi `::/2`.

--- a/pt-br/d-pt.html.markdown
+++ b/pt-br/d-pt.html.markdown
@@ -21,13 +21,13 @@ void main(string[] args) {
 ```

 Se você é como eu e passa muito tempo na Internet, é provável que tenha ouvido
-sobre [D] (http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
+sobre [D](http://dlang.org/). A linguagem de programação D é moderna, de uso geral,
 linguagem multiparadigma com suporte para tudo, desde recursos de baixo nível até
 abstrações expressivas de alto nível.

 D é desenvolvido ativamente por um grande grupo de pessoas super-inteligentes e é liderado por
-[Walter Bright] (https://en.wikipedia.org/wiki/Walter_Bright) e
-[Andrei Alexandrescu] (https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
+[Walter Bright](https://en.wikipedia.org/wiki/Walter_Bright) e
+[Andrei Alexandrescu](https://en.wikipedia.org/wiki/Andrei_Alexandrescu).
 Com tudo isso fora do caminho, vamos dar uma olhada em alguns exemplos!

 ```d
@@ -71,7 +71,7 @@ void main() {
 }
 ```

-Podemos definir novos tipos com `struct`,` class`, `union` e` enum`. Estruturas e uniões
+Podemos definir novos tipos com `struct`, `class`, `union` e `enum`. Estruturas e uniões
 são passados para funções por valor(ou seja, copiados) e as classes são passadas por referência. Além disso,
 podemos usar modelos para parametrizar tudo isso em tipos e valores!

@@ -232,7 +232,7 @@ Observe como conseguimos construir um bom pipeline haskelliano para calcular num
 Isso se deve a uma inovação em D, conhecida como Uniform Function Call Syntax (UFCS).
 Com o UFCS, podemos optar por escrever uma chamada de função como método
 ou chamada de função grátis! Walter escreveu um bom artigo sobre isso
-[aqui.] (http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394)
+[aqui](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394).
 Em resumo, você pode chamar funções cujo primeiro parâmetro
 é de algum tipo A em qualquer expressão do tipo A como método.

--- a/ru-ru/php-composer-ru.html.markdown
+++ b/ru-ru/php-composer-ru.html.markdown
@@ -27,12 +27,12 @@ curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filena
 ```

 Пользователи Windows должны следовать
-[Инструкциям по установке в Windows ](https://getcomposer.org/doc/00-intro.md#installation-windows)
+[Инструкциям по установке в Windows](https://getcomposer.org/doc/00-intro.md#installation-windows)

 ## Подтверждение установки

 ```sh
-# # Проверить версию и перечислить параметры
+# Проверить версию и перечислить параметры
 composer

 # Получить дополнительную помощь для параметров
@@ -99,12 +99,11 @@ composer search mailgun
 [Packagist.org](https://packagist.org/) является основным хранилищем для пакетов Composer.
 Существующие сторонние пакеты ищите там.

-## composer.json` и `composer.lock`
+## `composer.json` и `composer.lock`

 Файл `composer.json` хранит параметры допустимых версий каждой зависимости
 вашего проекта, а также другую информацию.

-
 Файл `composer.lock` хранит точную загруженную версию каждой зависимости.
 Никогда не редактируйте этот файл.

@@ -141,7 +140,6 @@ $mailgun = new Mailgun\Mailgun("key");

 ### PSR-4-совместимый автозагрузчик

-
 Вы можете добавить в автозагрузчик свои собственные пространства имён.

 Добавьте поле `autoload` в `composer.json`:
@@ -190,7 +188,7 @@ composer clear-cache

 * Создание и распространение ваших собственных пакетов на Packagist.org или в другом репозитории
 * Предварительные и пост-скриптовые перехватчики: запуск задач,
-когда происходят определенные события Composer
+ когда происходят определенные события Composer

 ### Ссылки

--- a/tr-tr/css-tr.html.markdown
+++ b/tr-tr/css-tr.html.markdown
@@ -236,7 +236,7 @@ Stilin önceliği ise aşağıdaki gibidir. Unutmayın, öncelik **her bir özel

 * `E` `!important` kelimesi yüzünden en yüksek önceliğe sahiptir. Kullanımından kaçınmanız önerilir.
 * `F` satıriçi stil olduğu için bir sonraki önceliğe sahiptir.
-* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf` class1`, bir öznitelik `attr = 'değer'.
+* `A` bir sonraki önceliğe sahiptir. Çünkü her şeyden daha "özgüdür". 3 belirteci vardır: `p` ögesinin adı, sınıf `class1`, bir öznitelik `attr = 'değer'.
 * `C`, `B` ile aynı özdeşliğe sahip olsa da, bundan sonra geldiğinden dolayı öncelik hakkına sahiptir.
 * `B` bir sonraki önceliğe sahiptir.
 * Sonuncu önceliğe sahip olan`D`'dir.