summaryrefslogtreecommitdiff
path: root/doc/yue-pt-br.md
diff options
context:
space:
mode:
Diffstat (limited to 'doc/yue-pt-br.md')
-rw-r--r--doc/yue-pt-br.md2496
1 files changed, 2 insertions, 2494 deletions
diff --git a/doc/yue-pt-br.md b/doc/yue-pt-br.md
index 7bab231..dac3aad 100644
--- a/doc/yue-pt-br.md
+++ b/doc/yue-pt-br.md
@@ -1,11 +1,5 @@
1---
2title: Referência
3---
4
5# Documentação do YueScript 1# Documentação do YueScript
6 2
7<img src="/image/yuescript.svg" width="250px" height="250px" alt="logo" style="padding-top: 3em; padding-bottom: 2em;"/>
8
9Bem-vindo à documentação oficial do <b>YueScript</b>!<br/> 3Bem-vindo à documentação oficial do <b>YueScript</b>!<br/>
10Aqui você encontra recursos da linguagem, uso, exemplos de referência e materiais úteis.<br/> 4Aqui você encontra recursos da linguagem, uso, exemplos de referência e materiais úteis.<br/>
11Selecione um capítulo na barra lateral para começar a aprender YueScript. 5Selecione um capítulo na barra lateral para começar a aprender YueScript.
@@ -21,17 +15,6 @@ do
21print var -- nil aqui 15print var -- nil aqui
22``` 16```
23 17
24<YueDisplay>
25
26```yue
27do
28 var = "hello"
29 print var
30print var -- nil aqui
31```
32
33</YueDisplay>
34
35O **do** do YueScript também pode ser usado como expressão. Permitindo combinar múltiplas linhas em uma. O resultado da expressão do é a última instrução em seu corpo. Expressões `do` suportam usar `break` para interromper o fluxo de execução e retornar múltiplos valores antecipadamente. 18O **do** do YueScript também pode ser usado como expressão. Permitindo combinar múltiplas linhas em uma. O resultado da expressão do é a última instrução em seu corpo. Expressões `do` suportam usar `break` para interromper o fluxo de execução e retornar múltiplos valores antecipadamente.
36 19
37```yuescript 20```yuescript
@@ -42,18 +25,6 @@ status, value = do
42 break "small", n 25 break "small", n
43``` 26```
44 27
45<YueDisplay>
46
47```yue
48status, value = do
49 n = 12
50 if n > 10
51 break "large", n
52 break "small", n
53```
54
55</YueDisplay>
56
57```yuescript 28```yuescript
58counter = do 29counter = do
59 i = 0 30 i = 0
@@ -65,21 +36,6 @@ print counter!
65print counter! 36print counter!
66``` 37```
67 38
68<YueDisplay>
69
70```yue
71counter = do
72 i = 0
73 ->
74 i += 1
75 i
76
77print counter!
78print counter!
79```
80
81</YueDisplay>
82
83```yuescript 39```yuescript
84tbl = { 40tbl = {
85 key: do 41 key: do
@@ -88,18 +44,6 @@ tbl = {
88} 44}
89``` 45```
90 46
91<YueDisplay>
92
93```yue
94tbl = {
95 key: do
96 print "assigning key!"
97 1234
98}
99```
100
101</YueDisplay>
102
103# Decoradores de linha 47# Decoradores de linha
104 48
105Por conveniência, o loop for e a instrução if podem ser aplicados a instruções únicas no final da linha: 49Por conveniência, o loop for e a instrução if podem ser aplicados a instruções únicas no final da linha:
@@ -108,28 +52,12 @@ Por conveniência, o loop for e a instrução if podem ser aplicados a instruçÃ
108print "hello world" if name == "Rob" 52print "hello world" if name == "Rob"
109``` 53```
110 54
111<YueDisplay>
112
113```yue
114print "hello world" if name == "Rob"
115```
116
117</YueDisplay>
118
119E com loops básicos: 55E com loops básicos:
120 56
121```yuescript 57```yuescript
122print "item: ", item for item in *items 58print "item: ", item for item in *items
123``` 59```
124 60
125<YueDisplay>
126
127```yue
128print "item: ", item for item in *items
129```
130
131</YueDisplay>
132
133E com loops while: 61E com loops while:
134 62
135```yuescript 63```yuescript
@@ -138,16 +66,6 @@ game\update! while game\isRunning!
138reader\parse_line! until reader\eof! 66reader\parse_line! until reader\eof!
139``` 67```
140 68
141<YueDisplay>
142
143```yue
144game\update! while game\isRunning!
145
146reader\parse_line! until reader\eof!
147```
148
149</YueDisplay>
150
151# Macro 69# Macro
152 70
153## Uso comum 71## Uso comum
@@ -183,39 +101,6 @@ if $and f1!, f2!, f3!
183 print "OK" 101 print "OK"
184``` 102```
185 103
186<YueDisplay>
187
188```yue
189macro PI2 = -> math.pi * 2
190area = $PI2 * 5
191
192macro HELLO = -> "'hello world'"
193print $HELLO
194
195macro config = (debugging) ->
196 global debugMode = debugging == "true"
197 ""
198
199macro asserts = (cond) ->
200 debugMode and "assert #{cond}" or ""
201
202macro assert = (cond) ->
203 debugMode and "assert #{cond}" or "#{cond}"
204
205$config true
206$asserts item ~= nil
207
208$config false
209value = $assert item
210
211-- as expressões passadas são tratadas como strings
212macro and = (...) -> "#{ table.concat {...}, ' and ' }"
213if $and f1!, f2!, f3!
214 print "OK"
215```
216
217</YueDisplay>
218
219## Inserir códigos brutos 104## Inserir códigos brutos
220 105
221Uma função macro pode retornar uma string YueScript ou uma tabela de configuração contendo códigos Lua. 106Uma função macro pode retornar uma string YueScript ou uma tabela de configuração contendo códigos Lua.
@@ -246,36 +131,6 @@ end
246]==] 131]==]
247``` 132```
248 133
249<YueDisplay>
250
251```yue
252macro yueFunc = (var) -> "local #{var} = ->"
253$yueFunc funcA
254funcA = -> "fail to assign to the Yue macro defined variable"
255
256macro luaFunc = (var) -> {
257 code: "local function #{var}() end"
258 type: "lua"
259}
260$luaFunc funcB
261funcB = -> "fail to assign to the Lua macro defined variable"
262
263macro lua = (code) -> {
264 :code
265 type: "lua"
266}
267
268-- os símbolos inicial e final da string bruta são aparados automaticamente
269$lua[==[
270-- inserção de códigos Lua brutos
271if cond then
272 print("output")
273end
274]==]
275```
276
277</YueDisplay>
278
279## Exportar macro 134## Exportar macro
280 135
281Funções macro podem ser exportadas de um módulo e importadas em outro módulo. Você deve colocar funções export macro em um único arquivo para uso, e apenas definição de macro, importação de macro e expansão de macro inline podem ser colocadas no módulo exportador de macro. 136Funções macro podem ser exportadas de um módulo e importadas em outro módulo. Você deve colocar funções export macro em um único arquivo para uso, e apenas definição de macro, importação de macro e expansão de macro inline podem ser colocadas no módulo exportador de macro.
@@ -295,27 +150,6 @@ import "utils" as {
295[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _ 150[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
296``` 151```
297 152
298<YueDisplay>
299
300```yue
301-- arquivo: utils.yue
302export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
303export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
304export macro foreach = (items, action) -> "for _ in *#{items}
305 #{action}"
306
307-- arquivo main.yue
308--[[
309import "utils" as {
310 $, -- símbolo para importar todas as macros
311 $foreach: $each -- renomear macro $foreach para $each
312}
313[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _
314]]
315```
316
317</YueDisplay>
318
319## Macro embutida 153## Macro embutida
320 154
321Existem algumas macros embutidas, mas você pode sobrescrevê-las declarando macros com os mesmos nomes. 155Existem algumas macros embutidas, mas você pode sobrescrevê-las declarando macros com os mesmos nomes.
@@ -325,15 +159,6 @@ print $FILE -- obtém string do nome do módulo atual
325print $LINE -- obtém número 2 159print $LINE -- obtém número 2
326``` 160```
327 161
328<YueDisplay>
329
330```yue
331print $FILE -- obtém string do nome do módulo atual
332print $LINE -- obtém número 2
333```
334
335</YueDisplay>
336
337## Gerando macros com macros 162## Gerando macros com macros
338 163
339No YueScript, as funções macro permitem que você gere código em tempo de compilação. Aninhando funções macro, você pode criar padrões de geração mais complexos. Este recurso permite que você defina uma função macro que gera outra função macro, permitindo geração de código mais dinâmica. 164No YueScript, as funções macro permitem que você gere código em tempo de compilação. Aninhando funções macro, você pode criar padrões de geração mais complexos. Este recurso permite que você defina uma função macro que gera outra função macro, permitindo geração de código mais dinâmica.
@@ -356,28 +181,6 @@ print "Valid enum type:", $BodyType Static
356-- print "Compilation error with enum type:", $BodyType Unknown 181-- print "Compilation error with enum type:", $BodyType Unknown
357``` 182```
358 183
359<YueDisplay>
360
361```yue
362macro Enum = (...) ->
363 items = {...}
364 itemSet = {item, true for item in *items}
365 (item) ->
366 error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
367 "\"#{item}\""
368
369macro BodyType = $Enum(
370 Static
371 Dynamic
372 Kinematic
373)
374
375print "Valid enum type:", $BodyType Static
376-- print "Compilation error with enum type:", $BodyType Unknown
377```
378
379</YueDisplay>
380
381## Validação de argumentos 184## Validação de argumentos
382 185
383Você pode declarar os tipos de nós AST esperados na lista de argumentos e verificar se os argumentos da macro recebidos atendem às expectativas em tempo de compilação. 186Você pode declarar os tipos de nós AST esperados na lista de argumentos e verificar se os argumentos da macro recebidos atendem às expectativas em tempo de compilação.
@@ -392,20 +195,6 @@ macro printNumAndStr = (num `Num, str `String) -> |
392$printNumAndStr 123, "hello" 195$printNumAndStr 123, "hello"
393``` 196```
394 197
395<YueDisplay>
396
397```yue
398macro printNumAndStr = (num `Num, str `String) -> |
399 print(
400 #{num}
401 #{str}
402 )
403
404$printNumAndStr 123, "hello"
405```
406
407</YueDisplay>
408
409Se você precisar de verificação de argumentos mais flexível, pode usar a função macro embutida `$is_ast` para verificar manualmente no lugar apropriado. 198Se você precisar de verificação de argumentos mais flexível, pode usar a função macro embutida `$is_ast` para verificar manualmente no lugar apropriado.
410 199
411```yuescript 200```yuescript
@@ -417,19 +206,6 @@ macro printNumAndStr = (num, str) ->
417$printNumAndStr 123, "hello" 206$printNumAndStr 123, "hello"
418``` 207```
419 208
420<YueDisplay>
421
422```yue
423macro printNumAndStr = (num, str) ->
424 error "expected Num as first argument" unless $is_ast Num, num
425 error "expected String as second argument" unless $is_ast String, str
426 "print(#{num}, #{str})"
427
428$printNumAndStr 123, "hello"
429```
430
431</YueDisplay>
432
433Para mais detalhes sobre os nós AST disponíveis, consulte as definições em maiúsculas em [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp). 209Para mais detalhes sobre os nós AST disponíveis, consulte as definições em maiúsculas em [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
434 210
435# Try 211# Try
@@ -464,38 +240,6 @@ catch err
464 print result 240 print result
465``` 241```
466 242
467<YueDisplay>
468
469```yue
470try
471 func 1, 2, 3
472catch err
473 print yue.traceback err
474
475success, result = try
476 func 1, 2, 3
477catch err
478 yue.traceback err
479
480try func 1, 2, 3
481catch err
482 print yue.traceback err
483
484success, result = try func 1, 2, 3
485
486try
487 print "trying"
488 func 1, 2, 3
489
490-- funcionando com padrão de atribuição em if
491if success, result := try func 1, 2, 3
492catch err
493 print yue.traceback err
494 print result
495```
496
497</YueDisplay>
498
499## Try? 243## Try?
500 244
501`try?` é um uso simplificado para sintaxe de tratamento de erros que omite o status booleano da instrução `try`, e retornará o resultado do bloco try quando tiver sucesso, retornando nil em vez do objeto de erro caso contrário. 245`try?` é um uso simplificado para sintaxe de tratamento de erros que omite o status booleano da instrução `try`, e retornará o resultado do bloco try quando tiver sucesso, retornando nil em vez do objeto de erro caso contrário.
@@ -518,44 +262,14 @@ catch e
518 e 262 e
519``` 263```
520 264
521<YueDisplay>
522
523```yue
524a, b, c = try? func!
525
526-- com operador de coalescência de nil
527a = (try? func!) ?? "default"
528
529-- como argumento de função
530f try? func!
531
532-- com bloco catch
533f try?
534 print 123
535 func!
536catch e
537 print e
538 e
539```
540
541</YueDisplay>
542
543# Literais de tabela 265# Literais de tabela
544 266
545Como no Lua, as tabelas são delimitadas por chaves. 267Como no Lua, as tabelas são delimitadas por chaves.
546 268
547```yuescript 269```yuescript
548some_values = [1, 2, 3, 4] 270some_values = {1, 2, 3, 4}
549```
550
551<YueDisplay>
552
553```yue
554some_values = [1, 2, 3, 4]
555``` 271```
556 272
557</YueDisplay>
558
559Diferente do Lua, atribuir um valor a uma chave em uma tabela é feito com **:** (em vez de **=**). 273Diferente do Lua, atribuir um valor a uma chave em uma tabela é feito com **:** (em vez de **=**).
560 274
561```yuescript 275```yuescript
@@ -566,18 +280,6 @@ some_values = {
566} 280}
567``` 281```
568 282
569<YueDisplay>
570
571```yue
572some_values = {
573 name: "Bill",
574 age: 200,
575 ["favorite food"]: "rice"
576}
577```
578
579</YueDisplay>
580
581As chaves podem ser omitidas se uma única tabela de pares chave-valor está sendo atribuída. 283As chaves podem ser omitidas se uma única tabela de pares chave-valor está sendo atribuída.
582 284
583```yuescript 285```yuescript
@@ -587,17 +289,6 @@ profile =
587 favorite_foods: ["ice cream", "donuts"] 289 favorite_foods: ["ice cream", "donuts"]
588``` 290```
589 291
590<YueDisplay>
591
592```yue
593profile =
594 height: "4 feet",
595 shoe_size: 13,
596 favorite_foods: ["ice cream", "donuts"]
597```
598
599</YueDisplay>
600
601Quebras de linha podem ser usadas para delimitar valores em vez de vírgula (ou ambos): 292Quebras de linha podem ser usadas para delimitar valores em vez de vírgula (ou ambos):
602 293
603```yuescript 294```yuescript
@@ -609,19 +300,6 @@ values = {
609} 300}
610``` 301```
611 302
612<YueDisplay>
613
614```yue
615values = {
616 1, 2, 3, 4
617 5, 6, 7, 8
618 name: "superman"
619 occupation: "crime fighting"
620}
621```
622
623</YueDisplay>
624
625Ao criar um literal de tabela em uma única linha, as chaves também podem ser omitidas: 303Ao criar um literal de tabela em uma única linha, as chaves também podem ser omitidas:
626 304
627```yuescript 305```yuescript
@@ -630,16 +308,6 @@ my_function dance: "Tango", partner: "none"
630y = type: "dog", legs: 4, tails: 1 308y = type: "dog", legs: 4, tails: 1
631``` 309```
632 310
633<YueDisplay>
634
635```yue
636my_function dance: "Tango", partner: "none"
637
638y = type: "dog", legs: 4, tails: 1
639```
640
641</YueDisplay>
642
643As chaves de um literal de tabela podem ser palavras-chave da linguagem sem precisar escapar: 311As chaves de um literal de tabela podem ser palavras-chave da linguagem sem precisar escapar:
644 312
645```yuescript 313```yuescript
@@ -649,17 +317,6 @@ tbl = {
649} 317}
650``` 318```
651 319
652<YueDisplay>
653
654```yue
655tbl = {
656 do: "something"
657 end: "hunger"
658}
659```
660
661</YueDisplay>
662
663Se você está construindo uma tabela a partir de variáveis e deseja que as chaves sejam iguais aos nomes das variáveis, então o operador de prefixo **:** pode ser usado: 320Se você está construindo uma tabela a partir de variáveis e deseja que as chaves sejam iguais aos nomes das variáveis, então o operador de prefixo **:** pode ser usado:
664 321
665```yuescript 322```yuescript
@@ -670,18 +327,6 @@ person = { :hair, :height, shoe_size: 40 }
670print_table :hair, :height 327print_table :hair, :height
671``` 328```
672 329
673<YueDisplay>
674
675```yue
676hair = "golden"
677height = 200
678person = { :hair, :height, shoe_size: 40 }
679
680print_table :hair, :height
681```
682
683</YueDisplay>
684
685Se você quiser que a chave de um campo na tabela seja o resultado de uma expressão, então pode envolvê-la em **[ ]**, assim como no Lua. Você também pode usar um literal de string diretamente como chave, omitindo os colchetes. Isso é útil se sua chave tiver caracteres especiais. 330Se você quiser que a chave de um campo na tabela seja o resultado de uma expressão, então pode envolvê-la em **[ ]**, assim como no Lua. Você também pode usar um literal de string diretamente como chave, omitindo os colchetes. Isso é útil se sua chave tiver caracteres especiais.
686 331
687```yuescript 332```yuescript
@@ -691,33 +336,13 @@ t = {
691} 336}
692``` 337```
693 338
694<YueDisplay> 339As tabelas Lua têm tanto uma parte array quanto uma parte hash, mas às vezes é útil fazer uma distinção semântica entre as duas. Você pode usar **[ ]** em vez de **{ }** para declarar explicitamente uma tabela como um array, fazer isso impedirá que quaisquer pares chave-valor sejam escritos dentro dela.
695
696```yue
697t = {
698 [1 + 2]: "hello"
699 "hello world": true
700}
701```
702
703</YueDisplay>
704
705As tabelas Lua têm tanto uma parte array quanto uma parte hash, mas às vezes você quer fazer uma distinção semântica entre uso de array e hash ao escrever tabelas Lua. Então você pode escrever tabela Lua com **[ ]** em vez de **{ }** para representar uma tabela array, e escrever qualquer par chave-valor em uma tabela lista não será permitido.
706 340
707```yuescript 341```yuescript
708some_values = [1, 2, 3, 4] 342some_values = [1, 2, 3, 4]
709list_with_one_element = [1, ] 343list_with_one_element = [1, ]
710``` 344```
711 345
712<YueDisplay>
713
714```yue
715some_values = [1, 2, 3, 4]
716list_with_one_element = [1, ]
717```
718
719</YueDisplay>
720
721# Compreensões 346# Compreensões
722 347
723As compreensões fornecem uma sintaxe conveniente para construir uma nova tabela iterando sobre algum objeto existente e aplicando uma expressão a seus valores. Existem dois tipos de compreensões: compreensões de lista e compreensões de tabela. Ambas produzem tabelas Lua; as compreensões de lista acumulam valores em uma tabela semelhante a array, e as compreensões de tabela permitem definir tanto a chave quanto o valor em cada iteração. 348As compreensões fornecem uma sintaxe conveniente para construir uma nova tabela iterando sobre algum objeto existente e aplicando uma expressão a seus valores. Existem dois tipos de compreensões: compreensões de lista e compreensões de tabela. Ambas produzem tabelas Lua; as compreensões de lista acumulam valores em uma tabela semelhante a array, e as compreensões de tabela permitem definir tanto a chave quanto o valor em cada iteração.
@@ -731,43 +356,18 @@ items = [ 1, 2, 3, 4 ]
731doubled = [item * 2 for i, item in ipairs items] 356doubled = [item * 2 for i, item in ipairs items]
732``` 357```
733 358
734<YueDisplay>
735
736```yue
737items = [ 1, 2, 3, 4 ]
738doubled = [item * 2 for i, item in ipairs items]
739```
740
741</YueDisplay>
742
743Os itens incluídos na nova tabela podem ser restringidos com uma cláusula when: 359Os itens incluídos na nova tabela podem ser restringidos com uma cláusula when:
744 360
745```yuescript 361```yuescript
746slice = [item for i, item in ipairs items when i > 1 and i < 3] 362slice = [item for i, item in ipairs items when i > 1 and i < 3]
747``` 363```
748 364
749<YueDisplay>
750
751```yue
752slice = [item for i, item in ipairs items when i > 1 and i < 3]
753```
754
755</YueDisplay>
756
757Como é comum iterar sobre os valores de uma tabela indexada numericamente, um operador **\*** é introduzido. O exemplo doubled pode ser reescrito como: 365Como é comum iterar sobre os valores de uma tabela indexada numericamente, um operador **\*** é introduzido. O exemplo doubled pode ser reescrito como:
758 366
759```yuescript 367```yuescript
760doubled = [item * 2 for item in *items] 368doubled = [item * 2 for item in *items]
761``` 369```
762 370
763<YueDisplay>
764
765```yue
766doubled = [item * 2 for item in *items]
767```
768
769</YueDisplay>
770
771Nas compreensões de lista, você também pode usar o operador spread `...` para achatar listas aninhadas, alcançando um efeito de flat map: 371Nas compreensões de lista, você também pode usar o operador spread `...` para achatar listas aninhadas, alcançando um efeito de flat map:
772 372
773```yuescript 373```yuescript
@@ -779,19 +379,6 @@ flat = [...v for k,v in pairs data]
779-- flat agora é [1, 2, 3, 4, 5, 6] 379-- flat agora é [1, 2, 3, 4, 5, 6]
780``` 380```
781 381
782<YueDisplay>
783
784```yue
785data =
786 a: [1, 2, 3]
787 b: [4, 5, 6]
788
789flat = [...v for k,v in pairs data]
790-- flat agora é [1, 2, 3, 4, 5, 6]
791```
792
793</YueDisplay>
794
795As cláusulas for e when podem ser encadeadas tanto quanto desejado. O único requisito é que uma compreensão tenha pelo menos uma cláusula for. 382As cláusulas for e when podem ser encadeadas tanto quanto desejado. O único requisito é que uma compreensão tenha pelo menos uma cláusula for.
796 383
797Usar múltiplas cláusulas for é o mesmo que usar loops aninhados: 384Usar múltiplas cláusulas for é o mesmo que usar loops aninhados:
@@ -804,32 +391,12 @@ points = [ [x, y] for x in *x_coords \
804for y in *y_coords] 391for y in *y_coords]
805``` 392```
806 393
807<YueDisplay>
808
809```yue
810x_coords = [4, 5, 6, 7]
811y_coords = [9, 2, 3]
812
813points = [ [x, y] for x in *x_coords \
814for y in *y_coords]
815```
816
817</YueDisplay>
818
819Loops for numéricos também podem ser usados em compreensões: 394Loops for numéricos também podem ser usados em compreensões:
820 395
821```yuescript 396```yuescript
822evens = [i for i = 1, 100 when i % 2 == 0] 397evens = [i for i = 1, 100 when i % 2 == 0]
823``` 398```
824 399
825<YueDisplay>
826
827```yue
828evens = [i for i = 1, 100 when i % 2 == 0]
829```
830
831</YueDisplay>
832
833## Compreensões de tabela 400## Compreensões de tabela
834 401
835A sintaxe para compreensões de tabela é muito semelhante, diferindo apenas por usar **{** e **}** e receber dois valores de cada iteração. 402A sintaxe para compreensões de tabela é muito semelhante, diferindo apenas por usar **{** e **}** e receber dois valores de cada iteração.
@@ -846,32 +413,10 @@ thing = {
846thing_copy = {k, v for k, v in pairs thing} 413thing_copy = {k, v for k, v in pairs thing}
847``` 414```
848 415
849<YueDisplay>
850
851```yue
852thing = {
853 color: "red"
854 name: "fast"
855 width: 123
856}
857
858thing_copy = {k, v for k, v in pairs thing}
859```
860
861</YueDisplay>
862
863```yuescript 416```yuescript
864no_color = {k, v for k, v in pairs thing when k != "color"} 417no_color = {k, v for k, v in pairs thing when k != "color"}
865``` 418```
866 419
867<YueDisplay>
868
869```yue
870no_color = {k, v for k, v in pairs thing when k != "color"}
871```
872
873</YueDisplay>
874
875O operador **\*** também é suportado. Aqui criamos uma tabela de consulta de raiz quadrada para alguns números. 420O operador **\*** também é suportado. Aqui criamos uma tabela de consulta de raiz quadrada para alguns números.
876 421
877```yuescript 422```yuescript
@@ -879,15 +424,6 @@ numbers = [1, 2, 3, 4]
879sqrts = {i, math.sqrt i for i in *numbers} 424sqrts = {i, math.sqrt i for i in *numbers}
880``` 425```
881 426
882<YueDisplay>
883
884```yue
885numbers = [1, 2, 3, 4]
886sqrts = {i, math.sqrt i for i in *numbers}
887```
888
889</YueDisplay>
890
891A tupla chave-valor em uma compreensão de tabela também pode vir de uma única expressão, caso em que a expressão deve retornar dois valores. O primeiro é usado como chave e o segundo é usado como valor: 427A tupla chave-valor em uma compreensão de tabela também pode vir de uma única expressão, caso em que a expressão deve retornar dois valores. O primeiro é usado como chave e o segundo é usado como valor:
892 428
893Neste exemplo convertemos um array de pares em uma tabela onde o primeiro item do par é a chave e o segundo é o valor. 429Neste exemplo convertemos um array de pares em uma tabela onde o primeiro item do par é a chave e o segundo é o valor.
@@ -897,15 +433,6 @@ tuples = [ ["hello", "world"], ["foo", "bar"]]
897tbl = {unpack tuple for tuple in *tuples} 433tbl = {unpack tuple for tuple in *tuples}
898``` 434```
899 435
900<YueDisplay>
901
902```yue
903tuples = [ ["hello", "world"], ["foo", "bar"]]
904tbl = {unpack tuple for tuple in *tuples}
905```
906
907</YueDisplay>
908
909## Slicing 436## Slicing
910 437
911Uma sintaxe especial é fornecida para restringir os itens sobre os quais se itera ao usar o operador **\***. Isso é equivalente a definir os limites de iteração e um tamanho de passo em um loop for. 438Uma sintaxe especial é fornecida para restringir os itens sobre os quais se itera ao usar o operador **\***. Isso é equivalente a definir os limites de iteração e um tamanho de passo em um loop for.
@@ -916,42 +443,18 @@ Aqui podemos definir os limites mínimo e máximo, pegando todos os itens com í
916slice = [item for item in *items[1, 5]] 443slice = [item for item in *items[1, 5]]
917``` 444```
918 445
919<YueDisplay>
920
921```yue
922slice = [item for item in *items[1, 5]]
923```
924
925</YueDisplay>
926
927Qualquer um dos argumentos do slice pode ser omitido para usar um padrão sensato. Neste exemplo, se o índice máximo for omitido, ele usa como padrão o comprimento da tabela. Isso pegará tudo exceto o primeiro elemento: 446Qualquer um dos argumentos do slice pode ser omitido para usar um padrão sensato. Neste exemplo, se o índice máximo for omitido, ele usa como padrão o comprimento da tabela. Isso pegará tudo exceto o primeiro elemento:
928 447
929```yuescript 448```yuescript
930slice = [item for item in *items[2,]] 449slice = [item for item in *items[2,]]
931``` 450```
932 451
933<YueDisplay>
934
935```yue
936slice = [item for item in *items[2,]]
937```
938
939</YueDisplay>
940
941Se o limite mínimo for omitido, ele usa como padrão 1. Aqui fornecemos apenas um tamanho de passo e deixamos os outros limites em branco. Isso pega todos os itens com índice ímpar: (1, 3, 5, …) 452Se o limite mínimo for omitido, ele usa como padrão 1. Aqui fornecemos apenas um tamanho de passo e deixamos os outros limites em branco. Isso pega todos os itens com índice ímpar: (1, 3, 5, …)
942 453
943```yuescript 454```yuescript
944slice = [item for item in *items[,,2]] 455slice = [item for item in *items[,,2]]
945``` 456```
946 457
947<YueDisplay>
948
949```yue
950slice = [item for item in *items[,,2]]
951```
952
953</YueDisplay>
954
955Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que os limites são contados a partir do fim da tabela. 458Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que os limites são contados a partir do fim da tabela.
956 459
957```yuescript 460```yuescript
@@ -959,29 +462,12 @@ Tanto o limite mínimo quanto o máximo podem ser negativos, o que significa que
959slice = [item for item in *items[-4,-1]] 462slice = [item for item in *items[-4,-1]]
960``` 463```
961 464
962<YueDisplay>
963
964```yue
965-- pegar os últimos 4 itens
966slice = [item for item in *items[-4,-1]]
967```
968
969</YueDisplay>
970
971O tamanho do passo também pode ser negativo, o que significa que os itens são tomados em ordem reversa. 465O tamanho do passo também pode ser negativo, o que significa que os itens são tomados em ordem reversa.
972 466
973```yuescript 467```yuescript
974reverse_slice = [item for item in *items[-1,1,-1]] 468reverse_slice = [item for item in *items[-1,1,-1]]
975``` 469```
976 470
977<YueDisplay>
978
979```yue
980reverse_slice = [item for item in *items[-1,1,-1]]
981```
982
983</YueDisplay>
984
985### Expressão de slicing 471### Expressão de slicing
986 472
987O slicing também pode ser usado como expressão. Isso é útil para obter uma sublista de uma tabela. 473O slicing também pode ser usado como expressão. Isso é útil para obter uma sublista de uma tabela.
@@ -994,18 +480,6 @@ sub_list = items[2, 4]
994last_four_items = items[-4, -1] 480last_four_items = items[-4, -1]
995``` 481```
996 482
997<YueDisplay>
998
999```yue
1000-- pegar o 2º e 4º itens como nova lista
1001sub_list = items[2, 4]
1002
1003-- pegar os últimos 4 itens
1004last_four_items = items[-4, -1]
1005```
1006
1007</YueDisplay>
1008
1009# Programação orientada a objetos 483# Programação orientada a objetos
1010 484
1011Nestes exemplos, o código Lua gerado pode parecer avassalador. É melhor focar primeiro no significado do código YueScript e depois olhar o código Lua se desejar conhecer os detalhes da implementação. 485Nestes exemplos, o código Lua gerado pode parecer avassalador. É melhor focar primeiro no significado do código YueScript e depois olhar o código Lua se desejar conhecer os detalhes da implementação.
@@ -1024,22 +498,6 @@ class Inventory
1024 @items[name] = 1 498 @items[name] = 1
1025``` 499```
1026 500
1027<YueDisplay>
1028
1029```yue
1030class Inventory
1031 new: =>
1032 @items = {}
1033
1034 add_item: (name) =>
1035 if @items[name]
1036 @items[name] += 1
1037 else
1038 @items[name] = 1
1039```
1040
1041</YueDisplay>
1042
1043Uma classe é declarada com uma instrução class seguida de uma declaração semelhante a tabela onde todos os métodos e propriedades são listados. 501Uma classe é declarada com uma instrução class seguida de uma declaração semelhante a tabela onde todos os métodos e propriedades são listados.
1044 502
1045A propriedade new é especial pois se tornará o construtor. 503A propriedade new é especial pois se tornará o construtor.
@@ -1056,16 +514,6 @@ inv\add_item "t-shirt"
1056inv\add_item "pants" 514inv\add_item "pants"
1057``` 515```
1058 516
1059<YueDisplay>
1060
1061```yue
1062inv = Inventory!
1063inv\add_item "t-shirt"
1064inv\add_item "pants"
1065```
1066
1067</YueDisplay>
1068
1069Como a instância da classe precisa ser enviada aos métodos quando são chamados, o operador \ é usado. 517Como a instância da classe precisa ser enviada aos métodos quando são chamados, o operador \ é usado.
1070 518
1071Todas as propriedades de uma classe são compartilhadas entre as instâncias. Isso é bom para funções, mas para outros tipos de objetos, resultados indesejados podem ocorrer. 519Todas as propriedades de uma classe são compartilhadas entre as instâncias. Isso é bom para funções, mas para outros tipos de objetos, resultados indesejados podem ocorrer.
@@ -1088,26 +536,6 @@ b\give_item "shirt"
1088print item for item in *a.clothes 536print item for item in *a.clothes
1089``` 537```
1090 538
1091<YueDisplay>
1092
1093```yue
1094class Person
1095 clothes: []
1096 give_item: (name) =>
1097 table.insert @clothes, name
1098
1099a = Person!
1100b = Person!
1101
1102a\give_item "pants"
1103b\give_item "shirt"
1104
1105-- vai imprimir tanto pants quanto shirt
1106print item for item in *a.clothes
1107```
1108
1109</YueDisplay>
1110
1111A forma correta de evitar esse problema é criar o estado mutável do objeto no construtor: 539A forma correta de evitar esse problema é criar o estado mutável do objeto no construtor:
1112 540
1113```yuescript 541```yuescript
@@ -1116,16 +544,6 @@ class Person
1116 @clothes = [] 544 @clothes = []
1117``` 545```
1118 546
1119<YueDisplay>
1120
1121```yue
1122class Person
1123 new: =>
1124 @clothes = []
1125```
1126
1127</YueDisplay>
1128
1129## Herança 547## Herança
1130 548
1131A palavra-chave extends pode ser usada em uma declaração de classe para herdar as propriedades e métodos de outra classe. 549A palavra-chave extends pode ser usada em uma declaração de classe para herdar as propriedades e métodos de outra classe.
@@ -1138,18 +556,6 @@ class BackPack extends Inventory
1138 super name 556 super name
1139``` 557```
1140 558
1141<YueDisplay>
1142
1143```yue
1144class BackPack extends Inventory
1145 size: 10
1146 add_item: (name) =>
1147 if #@items > size then error "backpack is full"
1148 super name
1149```
1150
1151</YueDisplay>
1152
1153Aqui estendemos nossa classe Inventory e limitamos a quantidade de itens que ela pode carregar. 559Aqui estendemos nossa classe Inventory e limitamos a quantidade de itens que ela pode carregar.
1154 560
1155Neste exemplo, não definimos um construtor na subclasse, então o construtor da classe pai é chamado quando criamos uma nova instância. Se definirmos um construtor, podemos usar o método super para chamar o construtor pai. 561Neste exemplo, não definimos um construtor na subclasse, então o construtor da classe pai é chamado quando criamos uma nova instância. Se definirmos um construtor, podemos usar o método super para chamar o construtor pai.
@@ -1165,19 +571,6 @@ class Shelf
1165class Cupboard extends Shelf 571class Cupboard extends Shelf
1166``` 572```
1167 573
1168<YueDisplay>
1169
1170```yue
1171class Shelf
1172 @__inherited: (child) =>
1173 print @__name, "was inherited by", child.__name
1174
1175-- vai imprimir: Shelf was inherited by Cupboard
1176class Cupboard extends Shelf
1177```
1178
1179</YueDisplay>
1180
1181## Super 574## Super
1182 575
1183**super** é uma palavra-chave especial que pode ser usada de duas formas diferentes: pode ser tratado como um objeto, ou pode ser chamado como uma função. Só tem funcionalidade especial quando está dentro de uma classe. 576**super** é uma palavra-chave especial que pode ser usada de duas formas diferentes: pode ser tratado como um objeto, ou pode ser chamado como uma função. Só tem funcionalidade especial quando está dentro de uma classe.
@@ -1204,22 +597,6 @@ class MyClass extends ParentClass
1204 assert super == ParentClass 597 assert super == ParentClass
1205``` 598```
1206 599
1207<YueDisplay>
1208
1209```yue
1210class MyClass extends ParentClass
1211 a_method: =>
1212 -- os seguintes têm o mesmo efeito:
1213 super "hello", "world"
1214 super\a_method "hello", "world"
1215 super.a_method self, "hello", "world"
1216
1217 -- super como valor é igual à classe pai:
1218 assert super == ParentClass
1219```
1220
1221</YueDisplay>
1222
1223**super** também pode ser usado no lado esquerdo de um Function Stub. A única diferença principal é que, em vez da função resultante estar vinculada ao valor de super, ela está vinculada a self. 600**super** também pode ser usado no lado esquerdo de um Function Stub. A única diferença principal é que, em vez da função resultante estar vinculada ao valor de super, ela está vinculada a self.
1224 601
1225## Tipos 602## Tipos
@@ -1233,17 +610,6 @@ assert b.__class == BackPack
1233print BackPack.size -- imprime 10 610print BackPack.size -- imprime 10
1234``` 611```
1235 612
1236<YueDisplay>
1237
1238```yue
1239b = BackPack!
1240assert b.__class == BackPack
1241
1242print BackPack.size -- imprime 10
1243```
1244
1245</YueDisplay>
1246
1247## Objetos de classe 613## Objetos de classe
1248 614
1249O objeto da classe é o que criamos quando usamos uma instrução class. O objeto da classe é armazenado em uma variável com o mesmo nome da classe. 615O objeto da classe é o que criamos quando usamos uma instrução class. O objeto da classe é armazenado em uma variável com o mesmo nome da classe.
@@ -1264,14 +630,6 @@ O nome da classe quando foi declarada é armazenado como string no campo \_\_nam
1264print BackPack.__name -- imprime Backpack 630print BackPack.__name -- imprime Backpack
1265``` 631```
1266 632
1267<YueDisplay>
1268
1269```yue
1270print BackPack.__name -- imprime Backpack
1271```
1272
1273</YueDisplay>
1274
1275O objeto base é armazenado em \_\_base. Podemos modificar esta tabela para adicionar funcionalidade a instâncias que já foram criadas e às que ainda serão criadas. 633O objeto base é armazenado em \_\_base. Podemos modificar esta tabela para adicionar funcionalidade a instâncias que já foram criadas e às que ainda serão criadas.
1276 634
1277Se a classe estende de algo, o objeto da classe pai é armazenado em \_\_parent. 635Se a classe estende de algo, o objeto da classe pai é armazenado em \_\_parent.
@@ -1290,20 +648,6 @@ Things\some_func!
1290assert Things().some_func == nil 648assert Things().some_func == nil
1291``` 649```
1292 650
1293<YueDisplay>
1294
1295```yue
1296class Things
1297 @some_func: => print "Hello from", @__name
1298
1299Things\some_func!
1300
1301-- variáveis de classe não visíveis em instâncias
1302assert Things().some_func == nil
1303```
1304
1305</YueDisplay>
1306
1307Em expressões, podemos usar @@ para acessar um valor armazenado no **class de self. Assim, @@hello é abreviação para self.**class.hello. 651Em expressões, podemos usar @@ para acessar um valor armazenado no **class de self. Assim, @@hello é abreviação para self.**class.hello.
1308 652
1309```yuescript 653```yuescript
@@ -1319,37 +663,12 @@ Counter!
1319print Counter.count -- imprime 2 663print Counter.count -- imprime 2
1320``` 664```
1321 665
1322<YueDisplay>
1323
1324```yue
1325class Counter
1326 @count: 0
1327
1328 new: =>
1329 @@count += 1
1330
1331Counter!
1332Counter!
1333
1334print Counter.count -- imprime 2
1335```
1336
1337</YueDisplay>
1338
1339A semântica de chamada de @@ é semelhante a @. Chamar um nome @@ passará a classe como primeiro argumento usando a sintaxe de dois pontos do Lua. 666A semântica de chamada de @@ é semelhante a @. Chamar um nome @@ passará a classe como primeiro argumento usando a sintaxe de dois pontos do Lua.
1340 667
1341```yuescript 668```yuescript
1342@@hello 1,2,3,4 669@@hello 1,2,3,4
1343``` 670```
1344 671
1345<YueDisplay>
1346
1347```yue
1348@@hello 1,2,3,4
1349```
1350
1351</YueDisplay>
1352
1353## Instruções de declaração de classe 672## Instruções de declaração de classe
1354 673
1355No corpo de uma declaração de classe, podemos ter expressões normais além de pares chave/valor. Neste contexto, self é igual ao objeto da classe. 674No corpo de uma declaração de classe, podemos ter expressões normais além de pares chave/valor. Neste contexto, self é igual ao objeto da classe.
@@ -1361,15 +680,6 @@ class Things
1361 @class_var = "hello world" 680 @class_var = "hello world"
1362``` 681```
1363 682
1364<YueDisplay>
1365
1366```yue
1367class Things
1368 @class_var = "hello world"
1369```
1370
1371</YueDisplay>
1372
1373Estas expressões são executadas após todas as propriedades terem sido adicionadas à base. 683Estas expressões são executadas após todas as propriedades terem sido adicionadas à base.
1374 684
1375Todas as variáveis declaradas no corpo da classe são locais às propriedades da classe. Isso é conveniente para colocar valores privados ou funções auxiliares que apenas os métodos da classe podem acessar: 685Todas as variáveis declaradas no corpo da classe são locais às propriedades da classe. Isso é conveniente para colocar valores privados ou funções auxiliares que apenas os métodos da classe podem acessar:
@@ -1383,19 +693,6 @@ class MoreThings
1383 log "hello world: " .. secret 693 log "hello world: " .. secret
1384``` 694```
1385 695
1386<YueDisplay>
1387
1388```yue
1389class MoreThings
1390 secret = 123
1391 log = (msg) -> print "LOG:", msg
1392
1393 some_method: =>
1394 log "hello world: " .. secret
1395```
1396
1397</YueDisplay>
1398
1399## Valores @ e @@ 696## Valores @ e @@
1400 697
1401Quando @ e @@ são prefixados na frente de um nome, eles representam, respectivamente, esse nome acessado em self e self.\_\_class. 698Quando @ e @@ são prefixados na frente de um nome, eles representam, respectivamente, esse nome acessado em self e self.\_\_class.
@@ -1407,29 +704,12 @@ assert @ == self
1407assert @@ == self.__class 704assert @@ == self.__class
1408``` 705```
1409 706
1410<YueDisplay>
1411
1412```yue
1413assert @ == self
1414assert @@ == self.__class
1415```
1416
1417</YueDisplay>
1418
1419Por exemplo, uma forma rápida de criar uma nova instância da mesma classe a partir de um método de instância usando @@: 707Por exemplo, uma forma rápida de criar uma nova instância da mesma classe a partir de um método de instância usando @@:
1420 708
1421```yuescript 709```yuescript
1422some_instance_method = (...) => @@ ... 710some_instance_method = (...) => @@ ...
1423``` 711```
1424 712
1425<YueDisplay>
1426
1427```yue
1428some_instance_method = (...) => @@ ...
1429```
1430
1431</YueDisplay>
1432
1433## Promoção de propriedade no construtor 713## Promoção de propriedade no construtor
1434 714
1435Para reduzir o código repetitivo na definição de objetos de valor simples. Você pode escrever uma classe simples como: 715Para reduzir o código repetitivo na definição de objetos de valor simples. Você pode escrever uma classe simples como:
@@ -1448,24 +728,6 @@ class Something
1448 @@baz = baz 728 @@baz = baz
1449``` 729```
1450 730
1451<YueDisplay>
1452
1453```yue
1454class Something
1455 new: (@foo, @bar, @@biz, @@baz) =>
1456
1457-- O que é abreviação para
1458
1459class Something
1460 new: (foo, bar, biz, baz) =>
1461 @foo = foo
1462 @bar = bar
1463 @@biz = biz
1464 @@baz = baz
1465```
1466
1467</YueDisplay>
1468
1469Você também pode usar esta sintaxe para uma função comum para inicializar os campos de um objeto. 731Você também pode usar esta sintaxe para uma função comum para inicializar os campos de um objeto.
1470 732
1471```yuescript 733```yuescript
@@ -1474,16 +736,6 @@ obj = new {}, 123, "abc"
1474print obj 736print obj
1475``` 737```
1476 738
1477<YueDisplay>
1478
1479```yue
1480new = (@fieldA, @fieldB) => @
1481obj = new {}, 123, "abc"
1482print obj
1483```
1484
1485</YueDisplay>
1486
1487## Expressões de classe 739## Expressões de classe
1488 740
1489A sintaxe de classe também pode ser usada como expressão que pode ser atribuída a uma variável ou retornada explicitamente. 741A sintaxe de classe também pode ser usada como expressão que pode ser atribuída a uma variável ou retornada explicitamente.
@@ -1494,16 +746,6 @@ x = class Bucket
1494 add_drop: => @drops += 1 746 add_drop: => @drops += 1
1495``` 747```
1496 748
1497<YueDisplay>
1498
1499```yue
1500x = class Bucket
1501 drops: 0
1502 add_drop: => @drops += 1
1503```
1504
1505</YueDisplay>
1506
1507## Classes anônimas 749## Classes anônimas
1508 750
1509O nome pode ser omitido ao declarar uma classe. O atributo \_\_name será nil, a menos que a expressão da classe esteja em uma atribuição. O nome no lado esquerdo da atribuição é usado em vez de nil. 751O nome pode ser omitido ao declarar uma classe. O atributo \_\_name será nil, a menos que a expressão da classe esteja em uma atribuição. O nome no lado esquerdo da atribuição é usado em vez de nil.
@@ -1515,31 +757,12 @@ BigBucket = class extends Bucket
1515assert Bucket.__name == "BigBucket" 757assert Bucket.__name == "BigBucket"
1516``` 758```
1517 759
1518<YueDisplay>
1519
1520```yue
1521BigBucket = class extends Bucket
1522 add_drop: => @drops += 10
1523
1524assert Bucket.__name == "BigBucket"
1525```
1526
1527</YueDisplay>
1528
1529Você pode até omitir o corpo, significando que pode escrever uma classe anônima em branco assim: 760Você pode até omitir o corpo, significando que pode escrever uma classe anônima em branco assim:
1530 761
1531```yuescript 762```yuescript
1532x = class 763x = class
1533``` 764```
1534 765
1535<YueDisplay>
1536
1537```yue
1538x = class
1539```
1540
1541</YueDisplay>
1542
1543## Mistura de classes 766## Mistura de classes
1544 767
1545Você pode fazer mistura com a palavra-chave `using` para copiar funções de uma tabela simples ou de um objeto de classe predefinido para sua nova classe. Ao fazer mistura com uma tabela simples, você pode sobrescrever a função de indexação da classe (metamétodo `__index`) para sua implementação personalizada. Ao fazer mistura com um objeto de classe existente, os metamétodos do objeto da classe não serão copiados. 768Você pode fazer mistura com a palavra-chave `using` para copiar funções de uma tabela simples ou de um objeto de classe predefinido para sua nova classe. Ao fazer mistura com uma tabela simples, você pode sobrescrever a função de indexação da classe (metamétodo `__index`) para sua implementação personalizada. Ao fazer mistura com um objeto de classe existente, os metamétodos do objeto da classe não serão copiados.
@@ -1562,28 +785,6 @@ y\func!
1562assert y.__class.__parent ~= X -- X não é pai de Y 785assert y.__class.__parent ~= X -- X não é pai de Y
1563``` 786```
1564 787
1565<YueDisplay>
1566
1567```yue
1568MyIndex = __index: var: 1
1569
1570class X using MyIndex
1571 func: =>
1572 print 123
1573
1574x = X!
1575print x.var
1576
1577class Y using X
1578
1579y = Y!
1580y\func!
1581
1582assert y.__class.__parent ~= X -- X não é pai de Y
1583```
1584
1585</YueDisplay>
1586
1587# Instrução With 788# Instrução With
1588 789
1589Um padrão comum envolvendo a criação de um objeto é chamar uma série de funções e definir uma série de propriedades imediatamente após criá-lo. 790Um padrão comum envolvendo a criação de um objeto é chamar uma série de funções e definir uma série de propriedades imediatamente após criá-lo.
@@ -1602,18 +803,6 @@ with Person!
1602 print .name 803 print .name
1603``` 804```
1604 805
1605<YueDisplay>
1606
1607```yue
1608with Person!
1609 .name = "Oswald"
1610 \add_relative my_dad
1611 \save!
1612 print .name
1613```
1614
1615</YueDisplay>
1616
1617A instrução with também pode ser usada como expressão que retorna o valor ao qual foi dado acesso. 806A instrução with também pode ser usada como expressão que retorna o valor ao qual foi dado acesso.
1618 807
1619```yuescript 808```yuescript
@@ -1621,15 +810,6 @@ file = with File "favorite_foods.txt"
1621 \set_encoding "utf8" 810 \set_encoding "utf8"
1622``` 811```
1623 812
1624<YueDisplay>
1625
1626```yue
1627file = with File "favorite_foods.txt"
1628 \set_encoding "utf8"
1629```
1630
1631</YueDisplay>
1632
1633Expressões `with` suportam `break` com um valor: 813Expressões `with` suportam `break` com um valor:
1634 814
1635```yuescript 815```yuescript
@@ -1637,15 +817,6 @@ result = with obj
1637 break .value 817 break .value
1638``` 818```
1639 819
1640<YueDisplay>
1641
1642```yue
1643result = with obj
1644 break .value
1645```
1646
1647</YueDisplay>
1648
1649Depois que `break value` é usado dentro de `with`, a expressão `with` deixa de retornar seu objeto-alvo e passa a retornar o valor de `break`. 820Depois que `break value` é usado dentro de `with`, a expressão `with` deixa de retornar seu objeto-alvo e passa a retornar o valor de `break`.
1650 821
1651```yuescript 822```yuescript
@@ -1658,20 +829,6 @@ b = with obj
1658-- b é .x, não obj 829-- b é .x, não obj
1659``` 830```
1660 831
1661<YueDisplay>
1662
1663```yue
1664a = with obj
1665 .x = 1
1666-- a é obj
1667
1668b = with obj
1669 break .x
1670-- b é .x, não obj
1671```
1672
1673</YueDisplay>
1674
1675Diferente de `for` / `while` / `repeat` / `do`, `with` suporta apenas um valor de `break`. 832Diferente de `for` / `while` / `repeat` / `do`, `with` suporta apenas um valor de `break`.
1676 833
1677Ou… 834Ou…
@@ -1685,19 +842,6 @@ create_person = (name, relatives) ->
1685me = create_person "Leaf", [dad, mother, sister] 842me = create_person "Leaf", [dad, mother, sister]
1686``` 843```
1687 844
1688<YueDisplay>
1689
1690```yue
1691create_person = (name, relatives) ->
1692 with Person!
1693 .name = name
1694 \add_relative relative for relative in *relatives
1695
1696me = create_person "Leaf", [dad, mother, sister]
1697```
1698
1699</YueDisplay>
1700
1701Neste uso, with pode ser visto como uma forma especial do combinador K. 845Neste uso, with pode ser visto como uma forma especial do combinador K.
1702 846
1703A expressão na instrução with também pode ser uma atribuição, se você quiser dar um nome à expressão. 847A expressão na instrução with também pode ser uma atribuição, se você quiser dar um nome à expressão.
@@ -1708,16 +852,6 @@ with str := "Hello"
1708 print "upper:", \upper! 852 print "upper:", \upper!
1709``` 853```
1710 854
1711<YueDisplay>
1712
1713```yue
1714with str := "Hello"
1715 print "original:", str
1716 print "upper:", \upper!
1717```
1718
1719</YueDisplay>
1720
1721Você pode acessar chaves especiais com `[]` em uma instrução `with`. 855Você pode acessar chaves especiais com `[]` em uma instrução `with`.
1722 856
1723```yuescript 857```yuescript
@@ -1730,20 +864,6 @@ with tb
1730 [] = "abc" -- anexando a "tb" 864 [] = "abc" -- anexando a "tb"
1731``` 865```
1732 866
1733<YueDisplay>
1734
1735```yue
1736with tb
1737 [1] = 1
1738 print [2]
1739 with [abc]
1740 [3] = [2]\func!
1741 ["key-name"] = value
1742 [] = "abc" -- anexando a "tb"
1743```
1744
1745</YueDisplay>
1746
1747`with?` é uma versão aprimorada da sintaxe `with`, que introduz uma verificação existencial para acessar com segurança objetos que podem ser nil sem verificações explícitas de null. 867`with?` é uma versão aprimorada da sintaxe `with`, que introduz uma verificação existencial para acessar com segurança objetos que podem ser nil sem verificações explícitas de null.
1748 868
1749```yuescript 869```yuescript
@@ -1751,15 +871,6 @@ with? obj
1751 print obj.name 871 print obj.name
1752``` 872```
1753 873
1754<YueDisplay>
1755
1756```yue
1757with? obj
1758 print obj.name
1759```
1760
1761</YueDisplay>
1762
1763# Atribuição 874# Atribuição
1764 875
1765A variável é tipada dinamicamente e é definida como local por padrão. Mas você pode alterar o escopo da declaração pelas instruções **local** e **global**. 876A variável é tipada dinamicamente e é definida como local por padrão. Mas você pode alterar o escopo da declaração pelas instruções **local** e **global**.
@@ -1770,16 +881,6 @@ a, b, c = 1, 2, 3
1770hello = 123 -- usa a variável existente 881hello = 123 -- usa a variável existente
1771``` 882```
1772 883
1773<YueDisplay>
1774
1775```yue
1776hello = "world"
1777a, b, c = 1, 2, 3
1778hello = 123 -- usa a variável existente
1779```
1780
1781</YueDisplay>
1782
1783## Atualização 884## Atualização
1784 885
1785Você pode realizar atribuição de atualização com muitos operadores binários. 886Você pode realizar atribuição de atualização com muitos operadores binários.
@@ -1795,21 +896,6 @@ s ..= "world" -- adiciona um novo local se a variável local não existir
1795arg or= "valor padrão" 896arg or= "valor padrão"
1796``` 897```
1797 898
1798<YueDisplay>
1799
1800```yue
1801x = 1
1802x += 1
1803x -= 1
1804x *= 10
1805x /= 10
1806x %= 10
1807s ..= "world" -- adiciona um novo local se a variável local não existir
1808arg or= "valor padrão"
1809```
1810
1811</YueDisplay>
1812
1813## Atribuição encadeada 899## Atribuição encadeada
1814 900
1815Você pode fazer atribuição encadeada para atribuir múltiplos itens ao mesmo valor. 901Você pode fazer atribuição encadeada para atribuir múltiplos itens ao mesmo valor.
@@ -1819,15 +905,6 @@ a = b = c = d = e = 0
1819x = y = z = f! 905x = y = z = f!
1820``` 906```
1821 907
1822<YueDisplay>
1823
1824```yue
1825a = b = c = d = e = 0
1826x = y = z = f!
1827```
1828
1829</YueDisplay>
1830
1831## Locais explícitos 908## Locais explícitos
1832 909
1833```yuescript 910```yuescript
@@ -1847,27 +924,6 @@ do
1847 B = 2 924 B = 2
1848``` 925```
1849 926
1850<YueDisplay>
1851
1852```yue
1853do
1854 local a = 1
1855 local *
1856 print "declarar antecipadamente todas as variáveis como locais"
1857 x = -> 1 + y + z
1858 y, z = 2, 3
1859 global instance = Item\new!
1860
1861do
1862 local X = 1
1863 local ^
1864 print "declarar antecipadamente apenas variáveis em maiúsculas"
1865 a = 1
1866 B = 2
1867```
1868
1869</YueDisplay>
1870
1871## Globais explícitos 927## Globais explícitos
1872 928
1873```yuescript 929```yuescript
@@ -1887,27 +943,6 @@ do
1887 local Temp = "um valor local" 943 local Temp = "um valor local"
1888``` 944```
1889 945
1890<YueDisplay>
1891
1892```yue
1893do
1894 global a = 1
1895 global *
1896 print "declarar todas as variáveis como globais"
1897 x = -> 1 + y + z
1898 y, z = 2, 3
1899
1900do
1901 global X = 1
1902 global ^
1903 print "declarar apenas variáveis em maiúsculas como globais"
1904 a = 1
1905 B = 2
1906 local Temp = "um valor local"
1907```
1908
1909</YueDisplay>
1910
1911# Atribuição de varargs 946# Atribuição de varargs
1912 947
1913Você pode atribuir os resultados retornados de uma função a um símbolo varargs `...`. E então acessar seu conteúdo da forma Lua. 948Você pode atribuir os resultados retornados de uma função a um símbolo varargs `...`. E então acessar seu conteúdo da forma Lua.
@@ -1921,19 +956,6 @@ first = select 1, ...
1921print ok, count, first 956print ok, count, first
1922``` 957```
1923 958
1924<YueDisplay>
1925
1926```yue
1927list = [1, 2, 3, 4, 5]
1928fn = (ok) -> ok, table.unpack list
1929ok, ... = fn true
1930count = select '#', ...
1931first = select 1, ...
1932print ok, count, first
1933```
1934
1935</YueDisplay>
1936
1937# Atribuição em if 959# Atribuição em if
1938 960
1939Os blocos `if` e `elseif` podem receber uma atribuição no lugar de uma expressão condicional. Ao avaliar o condicional, a atribuição será realizada e o valor que foi atribuído será usado como expressão condicional. A variável atribuída está no escopo apenas para o corpo do condicional, ou seja, nunca está disponível se o valor não for truthy. E você precisa usar o "operador walrus" `:=` em vez de `=` para fazer a atribuição. 961Os blocos `if` e `elseif` podem receber uma atribuição no lugar de uma expressão condicional. Ao avaliar o condicional, a atribuição será realizada e o valor que foi atribuído será usado como expressão condicional. A variável atribuída está no escopo apenas para o corpo do condicional, ou seja, nunca está disponível se o valor não for truthy. E você precisa usar o "operador walrus" `:=` em vez de `=` para fazer a atribuição.
@@ -1943,15 +965,6 @@ if user := database.find_user "moon"
1943 print user.name 965 print user.name
1944``` 966```
1945 967
1946<YueDisplay>
1947
1948```yue
1949if user := database.find_user "moon"
1950 print user.name
1951```
1952
1953</YueDisplay>
1954
1955```yuescript 968```yuescript
1956if hello := os.getenv "hello" 969if hello := os.getenv "hello"
1957 print "Você tem hello", hello 970 print "Você tem hello", hello
@@ -1961,19 +974,6 @@ else
1961 print "nada :(" 974 print "nada :("
1962``` 975```
1963 976
1964<YueDisplay>
1965
1966```yue
1967if hello := os.getenv "hello"
1968 print "Você tem hello", hello
1969elseif world := os.getenv "world"
1970 print "você tem world", world
1971else
1972 print "nada :("
1973```
1974
1975</YueDisplay>
1976
1977Atribuição em if com múltiplos valores de retorno. Apenas o primeiro valor é verificado, os outros valores estão no escopo. 977Atribuição em if com múltiplos valores de retorno. Apenas o primeiro valor é verificado, os outros valores estão no escopo.
1978 978
1979```yuescript 979```yuescript
@@ -1982,16 +982,6 @@ if success, result := pcall -> "obter resultado sem problemas"
1982print "OK" 982print "OK"
1983``` 983```
1984 984
1985<YueDisplay>
1986
1987```yue
1988if success, result := pcall -> "obter resultado sem problemas"
1989 print result -- variável result está no escopo
1990print "OK"
1991```
1992
1993</YueDisplay>
1994
1995## Atribuição em while 985## Atribuição em while
1996 986
1997Você também pode usar atribuição em if em um loop while para obter o valor como condição do loop. 987Você também pode usar atribuição em if em um loop while para obter o valor como condição do loop.
@@ -2002,16 +992,6 @@ while byte := stream\read_one!
2002 print byte 992 print byte
2003``` 993```
2004 994
2005<YueDisplay>
2006
2007```yue
2008while byte := stream\read_one!
2009 -- fazer algo com o byte
2010 print byte
2011```
2012
2013</YueDisplay>
2014
2015# Atribuição por desestruturação 995# Atribuição por desestruturação
2016 996
2017A atribuição por desestruturação é uma forma de extrair rapidamente valores de uma tabela por seu nome ou posição em tabelas baseadas em array. 997A atribuição por desestruturação é uma forma de extrair rapidamente valores de uma tabela por seu nome ou posição em tabelas baseadas em array.
@@ -2027,17 +1007,6 @@ thing = [1, 2]
2027print a, b 1007print a, b
2028``` 1008```
2029 1009
2030<YueDisplay>
2031
2032```yue
2033thing = [1, 2]
2034
2035[a, b] = thing
2036print a, b
2037```
2038
2039</YueDisplay>
2040
2041No literal de tabela de desestruturação, a chave representa a chave para ler do lado direito, e o valor representa o nome ao qual o valor lido será atribuído. 1010No literal de tabela de desestruturação, a chave representa a chave para ler do lado direito, e o valor representa o nome ao qual o valor lido será atribuído.
2042 1011
2043```yuescript 1012```yuescript
@@ -2053,23 +1022,6 @@ print hello, the_day
2053:day = obj -- OK fazer desestruturação simples sem chaves 1022:day = obj -- OK fazer desestruturação simples sem chaves
2054``` 1023```
2055 1024
2056<YueDisplay>
2057
2058```yue
2059obj = {
2060 hello: "world"
2061 day: "tuesday"
2062 length: 20
2063}
2064
2065{hello: hello, day: the_day} = obj
2066print hello, the_day
2067
2068:day = obj -- OK fazer desestruturação simples sem chaves
2069```
2070
2071</YueDisplay>
2072
2073Isso também funciona com estruturas de dados aninhadas: 1025Isso também funciona com estruturas de dados aninhadas:
2074 1026
2075```yuescript 1027```yuescript
@@ -2085,23 +1037,6 @@ obj2 = {
2085print first, second, color 1037print first, second, color
2086``` 1038```
2087 1039
2088<YueDisplay>
2089
2090```yue
2091obj2 = {
2092 numbers: [1, 2, 3, 4]
2093 properties: {
2094 color: "green"
2095 height: 13.5
2096 }
2097}
2098
2099{numbers: [first, second], properties: {color: color}} = obj2
2100print first, second, color
2101```
2102
2103</YueDisplay>
2104
2105Se a instrução de desestruturação for complicada, sinta-se à vontade para espalhá-la em várias linhas. Um exemplo um pouco mais complicado: 1040Se a instrução de desestruturação for complicada, sinta-se à vontade para espalhá-la em várias linhas. Um exemplo um pouco mais complicado:
2106 1041
2107```yuescript 1042```yuescript
@@ -2113,75 +1048,30 @@ Se a instrução de desestruturação for complicada, sinta-se à vontade para e
2113} = obj2 1048} = obj2
2114``` 1049```
2115 1050
2116<YueDisplay>
2117
2118```yue
2119{
2120 numbers: [first, second]
2121 properties: {
2122 color: color
2123 }
2124} = obj2
2125```
2126
2127</YueDisplay>
2128
2129É comum extrair valores de uma tabela e atribuí-los a variáveis locais que têm o mesmo nome da chave. Para evitar repetição, podemos usar o operador de prefixo **:**: 1051É comum extrair valores de uma tabela e atribuí-los a variáveis locais que têm o mesmo nome da chave. Para evitar repetição, podemos usar o operador de prefixo **:**:
2130 1052
2131```yuescript 1053```yuescript
2132{:concat, :insert} = table 1054{:concat, :insert} = table
2133``` 1055```
2134 1056
2135<YueDisplay>
2136
2137```yue
2138{:concat, :insert} = table
2139```
2140
2141</YueDisplay>
2142
2143Isso é efetivamente o mesmo que import, mas podemos renomear campos que queremos extrair misturando a sintaxe: 1057Isso é efetivamente o mesmo que import, mas podemos renomear campos que queremos extrair misturando a sintaxe:
2144 1058
2145```yuescript 1059```yuescript
2146{:mix, :max, random: rand} = math 1060{:mix, :max, random: rand} = math
2147``` 1061```
2148 1062
2149<YueDisplay>
2150
2151```yue
2152{:mix, :max, random: rand} = math
2153```
2154
2155</YueDisplay>
2156
2157Você pode escrever valores padrão ao fazer desestruturação: 1063Você pode escrever valores padrão ao fazer desestruturação:
2158 1064
2159```yuescript 1065```yuescript
2160{:name = "sem nome", :job = "sem emprego"} = person 1066{:name = "sem nome", :job = "sem emprego"} = person
2161``` 1067```
2162 1068
2163<YueDisplay>
2164
2165```yue
2166{:name = "sem nome", :job = "sem emprego"} = person
2167```
2168
2169</YueDisplay>
2170
2171Você pode usar `_` como placeholder ao fazer desestruturação de lista: 1069Você pode usar `_` como placeholder ao fazer desestruturação de lista:
2172 1070
2173```yuescript 1071```yuescript
2174[_, two, _, four] = items 1072[_, two, _, four] = items
2175``` 1073```
2176 1074
2177<YueDisplay>
2178
2179```yue
2180[_, two, _, four] = items
2181```
2182
2183</YueDisplay>
2184
2185## Desestruturação por intervalo 1075## Desestruturação por intervalo
2186 1076
2187Você pode usar o operador spread `...` na desestruturação de lista para capturar um intervalo de valores. Isso é útil quando você quer extrair elementos específicos do início e do fim de uma lista enquanto coleta o restante entre eles. 1077Você pode usar o operador spread `...` na desestruturação de lista para capturar um intervalo de valores. Isso é útil quando você quer extrair elementos específicos do início e do fim de uma lista enquanto coleta o restante entre eles.
@@ -2194,18 +1084,6 @@ print bulk -- imprime: {"second", "third", "fourth"}
2194print last -- imprime: last 1084print last -- imprime: last
2195``` 1085```
2196 1086
2197<YueDisplay>
2198
2199```yue
2200orders = ["first", "second", "third", "fourth", "last"]
2201[first, ...bulk, last] = orders
2202print first -- imprime: first
2203print bulk -- imprime: {"second", "third", "fourth"}
2204print last -- imprime: last
2205```
2206
2207</YueDisplay>
2208
2209O operador spread pode ser usado em diferentes posições para capturar diferentes intervalos, e você pode usar `_` como placeholder para os valores que não quer capturar: 1087O operador spread pode ser usado em diferentes posições para capturar diferentes intervalos, e você pode usar `_` como placeholder para os valores que não quer capturar:
2210 1088
2211```yuescript 1089```yuescript
@@ -2219,21 +1097,6 @@ O operador spread pode ser usado em diferentes posições para capturar diferent
2219[first, ..._, last] = orders 1097[first, ..._, last] = orders
2220``` 1098```
2221 1099
2222<YueDisplay>
2223
2224```yue
2225-- Capturar tudo após o primeiro elemento
2226[first, ...rest] = orders
2227
2228-- Capturar tudo antes do último elemento
2229[...start, last] = orders
2230
2231-- Capturar tudo exceto os elementos do meio
2232[first, ..._, last] = orders
2233```
2234
2235</YueDisplay>
2236
2237## Desestruturação em outros lugares 1100## Desestruturação em outros lugares
2238 1101
2239A desestruturação também pode aparecer em lugares onde uma atribuição ocorre implicitamente. Um exemplo disso é um loop for: 1102A desestruturação também pode aparecer em lugares onde uma atribuição ocorre implicitamente. Um exemplo disso é um loop for:
@@ -2248,20 +1111,6 @@ for [left, right] in *tuples
2248 print left, right 1111 print left, right
2249``` 1112```
2250 1113
2251<YueDisplay>
2252
2253```yue
2254tuples = [
2255 ["hello", "world"]
2256 ["egg", "head"]
2257]
2258
2259for [left, right] in *tuples
2260 print left, right
2261```
2262
2263</YueDisplay>
2264
2265Sabemos que cada elemento na tabela array é uma tupla de dois itens, então podemos desempacotá-lo diretamente na cláusula de nomes da instrução for usando desestruturação. 1114Sabemos que cada elemento na tabela array é uma tupla de dois itens, então podemos desempacotá-lo diretamente na cláusula de nomes da instrução for usando desestruturação.
2266 1115
2267# A cláusula Using; controlando atribuição destrutiva 1116# A cláusula Using; controlando atribuição destrutiva
@@ -2284,26 +1133,6 @@ my_func!
2284print i -- vai imprimir 0 1133print i -- vai imprimir 0
2285``` 1134```
2286 1135
2287<YueDisplay>
2288
2289```yue
2290i = 100
2291
2292-- muitas linhas de código...
2293
2294my_func = ->
2295 i = 10
2296 while i > 0
2297 print i
2298 i -= 1
2299
2300my_func!
2301
2302print i -- vai imprimir 0
2303```
2304
2305</YueDisplay>
2306
2307Em my_func, sobrescrevemos o valor de i por engano. Neste exemplo é bem óbvio, mas considere uma base de código grande ou estrangeira onde não está claro quais nomes já foram declarados. 1136Em my_func, sobrescrevemos o valor de i por engano. Neste exemplo é bem óbvio, mas considere uma base de código grande ou estrangeira onde não está claro quais nomes já foram declarados.
2308 1137
2309Seria útil dizer quais variáveis do escopo envolvente pretendemos alterar, para evitar que alteremos outras por acidente. 1138Seria útil dizer quais variáveis do escopo envolvente pretendemos alterar, para evitar que alteremos outras por acidente.
@@ -2320,20 +1149,6 @@ my_func!
2320print i -- imprime 100, i não é afetado 1149print i -- imprime 100, i não é afetado
2321``` 1150```
2322 1151
2323<YueDisplay>
2324
2325```yue
2326i = 100
2327
2328my_func = (using nil) ->
2329 i = "hello" -- uma nova variável local é criada aqui
2330
2331my_func!
2332print i -- imprime 100, i não é afetado
2333```
2334
2335</YueDisplay>
2336
2337Múltiplos nomes podem ser separados por vírgulas. Os valores do closure ainda podem ser acessados, apenas não podem ser modificados: 1152Múltiplos nomes podem ser separados por vírgulas. Os valores do closure ainda podem ser acessados, apenas não podem ser modificados:
2338 1153
2339```yuescript 1154```yuescript
@@ -2349,23 +1164,6 @@ my_func(22)
2349print i, k -- estes foram atualizados 1164print i, k -- estes foram atualizados
2350``` 1165```
2351 1166
2352<YueDisplay>
2353
2354```yue
2355tmp = 1213
2356i, k = 100, 50
2357
2358my_func = (add using k, i) ->
2359 tmp = tmp + add -- uma nova variável local tmp é criada
2360 i += tmp
2361 k += tmp
2362
2363my_func(22)
2364print i, k -- estes foram atualizados
2365```
2366
2367</YueDisplay>
2368
2369# Uso 1167# Uso
2370 1168
2371## Módulo Lua 1169## Módulo Lua
@@ -2534,55 +1332,6 @@ with apple
2534export 🌛 = "Script da Lua" 1332export 🌛 = "Script da Lua"
2535``` 1333```
2536 1334
2537<YueDisplay>
2538
2539```yue
2540-- sintaxe de importação
2541import p, to_lua from "yue"
2542
2543-- literais de objeto
2544inventory =
2545 equipment:
2546 - "sword"
2547 - "shield"
2548 items:
2549 - name: "potion"
2550 count: 10
2551 - name: "bread"
2552 count: 3
2553
2554-- compreensão de lista
2555map = (arr, action) ->
2556 [action item for item in *arr]
2557
2558filter = (arr, cond) ->
2559 [item for item in *arr when cond item]
2560
2561reduce = (arr, init, action): init ->
2562 init = action init, item for item in *arr
2563
2564-- operador pipe
2565[1, 2, 3]
2566 |> map (x) -> x * 2
2567 |> filter (x) -> x > 4
2568 |> reduce 0, (a, b) -> a + b
2569 |> print
2570
2571-- manipulação de metatable
2572apple =
2573 size: 15
2574 <index>:
2575 color: 0x00ffff
2576
2577with apple
2578 p .size, .color, .<index> if .<>?
2579
2580-- sintaxe de exportação estilo js
2581export 🌛 = "Script da Lua"
2582```
2583
2584</YueDisplay>
2585
2586## Sobre o Dora SSR 1335## Sobre o Dora SSR
2587 1336
2588O YueScript está sendo desenvolvido e mantido em conjunto com o motor de jogo open-source [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). Tem sido usado para criar ferramentas do motor, demonstrações de jogos e protótipos, validando suas capacidades em cenários do mundo real e aprimorando a experiência de desenvolvimento do Dora SSR. 1337O YueScript está sendo desenvolvido e mantido em conjunto com o motor de jogo open-source [Dora SSR](https://github.com/Dora-SSR/Dora-SSR). Tem sido usado para criar ferramentas do motor, demonstrações de jogos e protótipos, validando suas capacidades em cenários do mundo real e aprimorando a experiência de desenvolvimento do Dora SSR.
@@ -2641,18 +1390,6 @@ else
2641 print "Sem moedas" 1390 print "Sem moedas"
2642``` 1391```
2643 1392
2644<YueDisplay>
2645
2646```yue
2647have_coins = false
2648if have_coins
2649 print "Tem moedas"
2650else
2651 print "Sem moedas"
2652```
2653
2654</YueDisplay>
2655
2656Uma sintaxe curta para instruções únicas também pode ser usada: 1393Uma sintaxe curta para instruções únicas também pode ser usada:
2657 1394
2658```yuescript 1395```yuescript
@@ -2660,15 +1397,6 @@ have_coins = false
2660if have_coins then print "Tem moedas" else print "Sem moedas" 1397if have_coins then print "Tem moedas" else print "Sem moedas"
2661``` 1398```
2662 1399
2663<YueDisplay>
2664
2665```yue
2666have_coins = false
2667if have_coins then print "Tem moedas" else print "Sem moedas"
2668```
2669
2670</YueDisplay>
2671
2672Como instruções if podem ser usadas como expressões, isso também pode ser escrito como: 1400Como instruções if podem ser usadas como expressões, isso também pode ser escrito como:
2673 1401
2674```yuescript 1402```yuescript
@@ -2676,15 +1404,6 @@ have_coins = false
2676print if have_coins then "Tem moedas" else "Sem moedas" 1404print if have_coins then "Tem moedas" else "Sem moedas"
2677``` 1405```
2678 1406
2679<YueDisplay>
2680
2681```yue
2682have_coins = false
2683print if have_coins then "Tem moedas" else "Sem moedas"
2684```
2685
2686</YueDisplay>
2687
2688Condicionais também podem ser usados em instruções de retorno e atribuições: 1407Condicionais também podem ser usados em instruções de retorno e atribuições:
2689 1408
2690```yuescript 1409```yuescript
@@ -2702,25 +1421,6 @@ else
2702print message -- imprime: Sou muito alto 1421print message -- imprime: Sou muito alto
2703``` 1422```
2704 1423
2705<YueDisplay>
2706
2707```yue
2708is_tall = (name) ->
2709 if name == "Rob"
2710 true
2711 else
2712 false
2713
2714message = if is_tall "Rob"
2715 "Sou muito alto"
2716else
2717 "Não sou tão alto"
2718
2719print message -- imprime: Sou muito alto
2720```
2721
2722</YueDisplay>
2723
2724O oposto de if é unless: 1424O oposto de if é unless:
2725 1425
2726```yuescript 1426```yuescript
@@ -2728,27 +1428,10 @@ unless os.date("%A") == "Monday"
2728 print "não é segunda-feira!" 1428 print "não é segunda-feira!"
2729``` 1429```
2730 1430
2731<YueDisplay>
2732
2733```yue
2734unless os.date("%A") == "Monday"
2735 print "não é segunda-feira!"
2736```
2737
2738</YueDisplay>
2739
2740```yuescript 1431```yuescript
2741print "Você tem sorte!" unless math.random! > 0.1 1432print "Você tem sorte!" unless math.random! > 0.1
2742``` 1433```
2743 1434
2744<YueDisplay>
2745
2746```yue
2747print "Você tem sorte!" unless math.random! > 0.1
2748```
2749
2750</YueDisplay>
2751
2752## Em expressão 1435## Em expressão
2753 1436
2754Você pode escrever código de verificação de intervalo com uma `in-expression`. 1437Você pode escrever código de verificação de intervalo com uma `in-expression`.
@@ -2763,20 +1446,6 @@ if a in list
2763 print "verificando se `a` está na lista" 1446 print "verificando se `a` está na lista"
2764``` 1447```
2765 1448
2766<YueDisplay>
2767
2768```yue
2769a = 5
2770
2771if a in [1, 3, 5, 7]
2772 print "verificando igualdade com valores discretos"
2773
2774if a in list
2775 print "verificando se `a` está na lista"
2776```
2777
2778</YueDisplay>
2779
2780O operador `in` também pode ser usado com tabelas e suporta a variante `not in` para negação: 1449O operador `in` também pode ser usado com tabelas e suporta a variante `not in` para negação:
2781 1450
2782```yuescript 1451```yuescript
@@ -2790,21 +1459,6 @@ not_exist = item not in list
2790check = -> value not in table 1459check = -> value not in table
2791``` 1460```
2792 1461
2793<YueDisplay>
2794
2795```yue
2796has = "foo" in {"bar", "foo"}
2797
2798if a in {1, 2, 3}
2799 print "a está na tabela"
2800
2801not_exist = item not in list
2802
2803check = -> value not in table
2804```
2805
2806</YueDisplay>
2807
2808Uma lista ou tabela de único elemento verifica igualdade com esse elemento: 1462Uma lista ou tabela de único elemento verifica igualdade com esse elemento:
2809 1463
2810```yuescript 1464```yuescript
@@ -2819,22 +1473,6 @@ with tb
2819 c = a in [1] 1473 c = a in [1]
2820``` 1474```
2821 1475
2822<YueDisplay>
2823
2824```yue
2825-- [1,] verifica se valor == 1
2826c = a in [1,]
2827
2828-- {1} também verifica se valor == 1
2829c = a in {1}
2830
2831-- Sem vírgula, [1] é acesso por índice (tb[1])
2832with tb
2833 c = a in [1]
2834```
2835
2836</YueDisplay>
2837
2838# Loop For 1476# Loop For
2839 1477
2840Existem duas formas de loop for, assim como no Lua. Uma numérica e uma genérica: 1478Existem duas formas de loop for, assim como no Lua. Uma numérica e uma genérica:
@@ -2850,21 +1488,6 @@ for key, value in pairs object
2850 print key, value 1488 print key, value
2851``` 1489```
2852 1490
2853<YueDisplay>
2854
2855```yue
2856for i = 10, 20
2857 print i
2858
2859for k = 1, 15, 2 -- um passo opcional fornecido
2860 print k
2861
2862for key, value in pairs object
2863 print key, value
2864```
2865
2866</YueDisplay>
2867
2868Os operadores de slicing e **\*** podem ser usados, assim como com compreensões: 1491Os operadores de slicing e **\*** podem ser usados, assim como com compreensões:
2869 1492
2870```yuescript 1493```yuescript
@@ -2872,15 +1495,6 @@ for item in *items[2, 4]
2872 print item 1495 print item
2873``` 1496```
2874 1497
2875<YueDisplay>
2876
2877```yue
2878for item in *items[2, 4]
2879 print item
2880```
2881
2882</YueDisplay>
2883
2884Uma sintaxe mais curta também está disponível para todas as variações quando o corpo é apenas uma linha: 1498Uma sintaxe mais curta também está disponível para todas as variações quando o corpo é apenas uma linha:
2885 1499
2886```yuescript 1500```yuescript
@@ -2889,16 +1503,6 @@ for item in *items do print item
2889for j = 1, 10, 3 do print j 1503for j = 1, 10, 3 do print j
2890``` 1504```
2891 1505
2892<YueDisplay>
2893
2894```yue
2895for item in *items do print item
2896
2897for j = 1, 10, 3 do print j
2898```
2899
2900</YueDisplay>
2901
2902Um loop for também pode ser usado como expressão. A última instrução no corpo do loop for é convertida em expressão e anexada a uma tabela array acumuladora. 1506Um loop for também pode ser usado como expressão. A última instrução no corpo do loop for é convertida em expressão e anexada a uma tabela array acumuladora.
2903 1507
2904Dobrando cada número par: 1508Dobrando cada número par:
@@ -2911,18 +1515,6 @@ doubled_evens = for i = 1, 20
2911 i 1515 i
2912``` 1516```
2913 1517
2914<YueDisplay>
2915
2916```yue
2917doubled_evens = for i = 1, 20
2918 if i % 2 == 0
2919 i * 2
2920 else
2921 i
2922```
2923
2924</YueDisplay>
2925
2926Além disso, os loops for suportam break com valores de retorno, permitindo que o próprio loop seja usado como expressão que sai antecipadamente com um resultado significativo. Expressões `for` suportam `break` com múltiplos valores. 1518Além disso, os loops for suportam break com valores de retorno, permitindo que o próprio loop seja usado como expressão que sai antecipadamente com um resultado significativo. Expressões `for` suportam `break` com múltiplos valores.
2927 1519
2928Por exemplo, para encontrar o primeiro número maior que 10: 1520Por exemplo, para encontrar o primeiro número maior que 10:
@@ -2932,15 +1524,6 @@ first_large = for n in *numbers
2932 break n if n > 10 1524 break n if n > 10
2933``` 1525```
2934 1526
2935<YueDisplay>
2936
2937```yue
2938first_large = for n in *numbers
2939 break n if n > 10
2940```
2941
2942</YueDisplay>
2943
2944Esta sintaxe de break-com-valor permite padrões concisos e expressivos de busca ou saída antecipada diretamente em expressões de loop. 1527Esta sintaxe de break-com-valor permite padrões concisos e expressivos de busca ou saída antecipada diretamente em expressões de loop.
2945 1528
2946```yuescript 1529```yuescript
@@ -2948,15 +1531,6 @@ key, score = for k, v in pairs data
2948 break k, v * 10 if k == "target" 1531 break k, v * 10 if k == "target"
2949``` 1532```
2950 1533
2951<YueDisplay>
2952
2953```yue
2954key, score = for k, v in pairs data
2955 break k, v * 10 if k == "target"
2956```
2957
2958</YueDisplay>
2959
2960Você também pode filtrar valores combinando a expressão do loop for com a instrução continue. 1534Você também pode filtrar valores combinando a expressão do loop for com a instrução continue.
2961 1535
2962Loops for no final do corpo de uma função não são acumulados em uma tabela para valor de retorno (em vez disso, a função retornará nil). Uma instrução return explícita pode ser usada, ou o loop pode ser convertido em compreensão de lista. 1536Loops for no final do corpo de uma função não são acumulados em uma tabela para valor de retorno (em vez disso, a função retornará nil). Uma instrução return explícita pode ser usada, ou o loop pode ser convertido em compreensão de lista.
@@ -2969,18 +1543,6 @@ print func_a! -- imprime nil
2969print func_b! -- imprime objeto table 1543print func_b! -- imprime objeto table
2970``` 1544```
2971 1545
2972<YueDisplay>
2973
2974```yue
2975func_a = -> for i = 1, 10 do print i
2976func_b = -> return for i = 1, 10 do i
2977
2978print func_a! -- imprime nil
2979print func_b! -- imprime objeto table
2980```
2981
2982</YueDisplay>
2983
2984Isso é feito para evitar a criação desnecessária de tabelas para funções que não precisam retornar os resultados do loop. 1546Isso é feito para evitar a criação desnecessária de tabelas para funções que não precisam retornar os resultados do loop.
2985 1547
2986# Continue 1548# Continue
@@ -2995,18 +1557,6 @@ while i < 10
2995 print i 1557 print i
2996``` 1558```
2997 1559
2998<YueDisplay>
2999
3000```yue
3001i = 0
3002while i < 10
3003 i += 1
3004 continue if i % 2 == 0
3005 print i
3006```
3007
3008</YueDisplay>
3009
3010continue também pode ser usado com expressões de loop para impedir que essa iteração seja acumulada no resultado. Este exemplo filtra a tabela array para apenas números pares: 1560continue também pode ser usado com expressões de loop para impedir que essa iteração seja acumulada no resultado. Este exemplo filtra a tabela array para apenas números pares:
3011 1561
3012```yuescript 1562```yuescript
@@ -3016,17 +1566,6 @@ odds = for x in *my_numbers
3016 x 1566 x
3017``` 1567```
3018 1568
3019<YueDisplay>
3020
3021```yue
3022my_numbers = [1, 2, 3, 4, 5, 6]
3023odds = for x in *my_numbers
3024 continue if x % 2 == 1
3025 x
3026```
3027
3028</YueDisplay>
3029
3030# Switch 1569# Switch
3031 1570
3032A instrução switch é uma forma abreviada de escrever uma série de instruções if que verificam o mesmo valor. Observe que o valor é avaliado apenas uma vez. Como as instruções if, os switches podem ter um bloco else para tratar ausência de correspondências. A comparação é feita com o operador ==. Na instrução switch, você também pode usar expressão de atribuição para armazenar valor de variável temporária. 1571A instrução switch é uma forma abreviada de escrever uma série de instruções if que verificam o mesmo valor. Observe que o valor é avaliado apenas uma vez. Como as instruções if, os switches podem ter um bloco else para tratar ausência de correspondências. A comparação é feita com o operador ==. Na instrução switch, você também pode usar expressão de atribuição para armazenar valor de variável temporária.
@@ -3041,20 +1580,6 @@ switch name := "Dan"
3041 print "Não sei quem você é com o nome #{name}" 1580 print "Não sei quem você é com o nome #{name}"
3042``` 1581```
3043 1582
3044<YueDisplay>
3045
3046```yue
3047switch name := "Dan"
3048 when "Robert"
3049 print "Você é Robert"
3050 when "Dan", "Daniel"
3051 print "Seu nome é Dan"
3052 else
3053 print "Não sei quem você é com o nome #{name}"
3054```
3055
3056</YueDisplay>
3057
3058Uma cláusula when de um switch pode corresponder a múltiplos valores listando-os separados por vírgula. 1583Uma cláusula when de um switch pode corresponder a múltiplos valores listando-os separados por vírgula.
3059 1584
3060Os switches também podem ser usados como expressões; aqui podemos atribuir o resultado do switch a uma variável: 1585Os switches também podem ser usados como expressões; aqui podemos atribuir o resultado do switch a uma variável:
@@ -3070,21 +1595,6 @@ next_number = switch b
3070 error "não consigo contar tão alto!" 1595 error "não consigo contar tão alto!"
3071``` 1596```
3072 1597
3073<YueDisplay>
3074
3075```yue
3076b = 1
3077next_number = switch b
3078 when 1
3079 2
3080 when 2
3081 3
3082 else
3083 error "não consigo contar tão alto!"
3084```
3085
3086</YueDisplay>
3087
3088Podemos usar a palavra-chave then para escrever o bloco when de um switch em uma única linha. Nenhuma palavra-chave extra é necessária para escrever o bloco else em uma única linha. 1598Podemos usar a palavra-chave then para escrever o bloco when de um switch em uma única linha. Nenhuma palavra-chave extra é necessária para escrever o bloco else em uma única linha.
3089 1599
3090```yuescript 1600```yuescript
@@ -3094,17 +1604,6 @@ msg = switch math.random(1, 5)
3094 else "não tão sortudo" 1604 else "não tão sortudo"
3095``` 1605```
3096 1606
3097<YueDisplay>
3098
3099```yue
3100msg = switch math.random(1, 5)
3101 when 1 then "você tem sorte"
3102 when 2 then "você quase tem sorte"
3103 else "não tão sortudo"
3104```
3105
3106</YueDisplay>
3107
3108Se você quiser escrever código com uma indentação a menos ao escrever uma instrução switch, pode colocar a primeira cláusula when na linha de início da instrução, e então todas as outras cláusulas podem ser escritas com uma indentação a menos. 1607Se você quiser escrever código com uma indentação a menos ao escrever uma instrução switch, pode colocar a primeira cláusula when na linha de início da instrução, e então todas as outras cláusulas podem ser escritas com uma indentação a menos.
3109 1608
3110```yuescript 1609```yuescript
@@ -3120,23 +1619,6 @@ else
3120 print "não tão sortudo" 1619 print "não tão sortudo"
3121``` 1620```
3122 1621
3123<YueDisplay>
3124
3125```yue
3126switch math.random(1, 5)
3127 when 1
3128 print "você tem sorte" -- duas indentações
3129 else
3130 print "não tão sortudo"
3131
3132switch math.random(1, 5) when 1
3133 print "você tem sorte" -- uma indentação
3134else
3135 print "não tão sortudo"
3136```
3137
3138</YueDisplay>
3139
3140Vale notar a ordem da expressão de comparação do case. A expressão do case está no lado esquerdo. Isso pode ser útil se a expressão do case quiser sobrescrever como a comparação é feita definindo um metamétodo eq. 1622Vale notar a ordem da expressão de comparação do case. A expressão do case está no lado esquerdo. Isso pode ser útil se a expressão do case quiser sobrescrever como a comparação é feita definindo um metamétodo eq.
3141 1623
3142## Correspondência de tabela 1624## Correspondência de tabela
@@ -3158,25 +1640,6 @@ for item in *items
3158 print "tamanho #{width}, #{height}" 1640 print "tamanho #{width}, #{height}"
3159``` 1641```
3160 1642
3161<YueDisplay>
3162
3163```yue
3164items =
3165 * x: 100
3166 y: 200
3167 * width: 300
3168 height: 400
3169
3170for item in *items
3171 switch item
3172 when :x, :y
3173 print "Vec2 #{x}, #{y}"
3174 when :width, :height
3175 print "tamanho #{width}, #{height}"
3176```
3177
3178</YueDisplay>
3179
3180Você pode usar valores padrão para opcionalmente desestruturar a tabela para alguns campos. 1643Você pode usar valores padrão para opcionalmente desestruturar a tabela para alguns campos.
3181 1644
3182```yuescript 1645```yuescript
@@ -3189,20 +1652,6 @@ switch item
3189 print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará 1652 print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará
3190``` 1653```
3191 1654
3192<YueDisplay>
3193
3194```yue
3195item = {}
3196
3197{pos: {:x = 50, :y = 200}} = item -- obtém erro: attempt to index a nil value (field 'pos')
3198
3199switch item
3200 when {pos: {:x = 50, :y = 200}}
3201 print "Vec2 #{x}, #{y}" -- a desestruturação de tabela ainda passará
3202```
3203
3204</YueDisplay>
3205
3206Você também pode corresponder contra elementos de array, campos de tabela, e até estruturas aninhadas com literais de array ou tabela. 1655Você também pode corresponder contra elementos de array, campos de tabela, e até estruturas aninhadas com literais de array ou tabela.
3207 1656
3208Corresponder contra elementos de array. 1657Corresponder contra elementos de array.
@@ -3217,20 +1666,6 @@ switch tb
3217 print "1, 2, #{b}" 1666 print "1, 2, #{b}"
3218``` 1667```
3219 1668
3220<YueDisplay>
3221
3222```yue
3223switch tb
3224 when [1, 2, 3]
3225 print "1, 2, 3"
3226 when [1, b, 3]
3227 print "1, #{b}, 3"
3228 when [1, 2, b = 3] -- b tem valor padrão
3229 print "1, 2, #{b}"
3230```
3231
3232</YueDisplay>
3233
3234Corresponder contra campos de tabela com desestruturação. 1669Corresponder contra campos de tabela com desestruturação.
3235 1670
3236```yuescript 1671```yuescript
@@ -3243,20 +1678,6 @@ switch tb
3243 print "inválido" 1678 print "inválido"
3244``` 1679```
3245 1680
3246<YueDisplay>
3247
3248```yue
3249switch tb
3250 when success: true, :result
3251 print "sucesso", result
3252 when success: false
3253 print "falhou", result
3254 else
3255 print "inválido"
3256```
3257
3258</YueDisplay>
3259
3260Corresponder contra estruturas de tabela aninhadas. 1681Corresponder contra estruturas de tabela aninhadas.
3261 1682
3262```yuescript 1683```yuescript
@@ -3269,20 +1690,6 @@ switch tb
3269 print "inválido" 1690 print "inválido"
3270``` 1691```
3271 1692
3272<YueDisplay>
3273
3274```yue
3275switch tb
3276 when data: {type: "success", :content}
3277 print "sucesso", content
3278 when data: {type: "error", :content}
3279 print "erro", content
3280 else
3281 print "inválido"
3282```
3283
3284</YueDisplay>
3285
3286Corresponder contra array de tabelas. 1693Corresponder contra array de tabelas.
3287 1694
3288```yuescript 1695```yuescript
@@ -3296,21 +1703,6 @@ switch tb
3296 print "correspondido", fourth 1703 print "correspondido", fourth
3297``` 1704```
3298 1705
3299<YueDisplay>
3300
3301```yue
3302switch tb
3303 when [
3304 {a: 1, b: 2}
3305 {a: 3, b: 4}
3306 {a: 5, b: 6}
3307 fourth
3308 ]
3309 print "correspondido", fourth
3310```
3311
3312</YueDisplay>
3313
3314Corresponder contra uma lista e capturar um intervalo de elementos. 1706Corresponder contra uma lista e capturar um intervalo de elementos.
3315 1707
3316```yuescript 1708```yuescript
@@ -3322,19 +1714,6 @@ switch segments
3322 print "Ação:", action -- imprime: "view" 1714 print "Ação:", action -- imprime: "view"
3323``` 1715```
3324 1716
3325<YueDisplay>
3326
3327```yue
3328segments = ["admin", "users", "logs", "view"]
3329switch segments
3330 when [...groups, resource, action]
3331 print "Grupo:", groups -- imprime: {"admin", "users"}
3332 print "Recurso:", resource -- imprime: "logs"
3333 print "Ação:", action -- imprime: "view"
3334```
3335
3336</YueDisplay>
3337
3338# Loop While 1717# Loop While
3339 1718
3340O loop while também vem em quatro variações: 1719O loop while também vem em quatro variações:
@@ -3348,19 +1727,6 @@ while i > 0
3348while running == true do my_function! 1727while running == true do my_function!
3349``` 1728```
3350 1729
3351<YueDisplay>
3352
3353```yue
3354i = 10
3355while i > 0
3356 print i
3357 i -= 1
3358
3359while running == true do my_function!
3360```
3361
3362</YueDisplay>
3363
3364```yuescript 1730```yuescript
3365i = 10 1731i = 10
3366until i == 0 1732until i == 0
@@ -3370,18 +1736,6 @@ until i == 0
3370until running == false do my_function! 1736until running == false do my_function!
3371``` 1737```
3372 1738
3373<YueDisplay>
3374
3375```yue
3376i = 10
3377until i == 0
3378 print i
3379 i -= 1
3380until running == false do my_function!
3381```
3382
3383</YueDisplay>
3384
3385Como os loops for, o loop while também pode ser usado como expressão. Expressões `while` e `until` suportam `break` com múltiplos valores. 1739Como os loops for, o loop while também pode ser usado como expressão. Expressões `while` e `until` suportam `break` com múltiplos valores.
3386 1740
3387```yuescript 1741```yuescript
@@ -3390,16 +1744,6 @@ value, doubled = while true
3390 break n, n * 2 if n > 10 1744 break n, n * 2 if n > 10
3391``` 1745```
3392 1746
3393<YueDisplay>
3394
3395```yue
3396value, doubled = while true
3397 n = get_next!
3398 break n, n * 2 if n > 10
3399```
3400
3401</YueDisplay>
3402
3403Além disso, para uma função retornar o valor acumulado de um loop while, a instrução deve ser explicitamente retornada. 1747Além disso, para uma função retornar o valor acumulado de um loop while, a instrução deve ser explicitamente retornada.
3404 1748
3405## Loop Repeat 1749## Loop Repeat
@@ -3414,18 +1758,6 @@ repeat
3414until i == 0 1758until i == 0
3415``` 1759```
3416 1760
3417<YueDisplay>
3418
3419```yue
3420i = 10
3421repeat
3422 print i
3423 i -= 1
3424until i == 0
3425```
3426
3427</YueDisplay>
3428
3429Expressões `repeat` também suportam `break` com múltiplos valores: 1761Expressões `repeat` também suportam `break` com múltiplos valores:
3430 1762
3431```yuescript 1763```yuescript
@@ -3436,18 +1768,6 @@ value, scaled = repeat
3436until false 1768until false
3437``` 1769```
3438 1770
3439<YueDisplay>
3440
3441```yue
3442i = 1
3443value, scaled = repeat
3444 break i, i * 100 if i > 3
3445 i += 1
3446until false
3447```
3448
3449</YueDisplay>
3450
3451# Stubs de função 1771# Stubs de função
3452 1772
3453É comum passar uma função de um objeto como valor, por exemplo, passando um método de instância para uma função como callback. Se a função espera o objeto em que está operando como primeiro argumento, então você deve de alguma forma empacotar esse objeto com a função para que ela possa ser chamada corretamente. 1773É comum passar uma função de um objeto como valor, por exemplo, passando um método de instância para uma função como callback. Se a função espera o objeto em que está operando como primeiro argumento, então você deve de alguma forma empacotar esse objeto com a função para que ela possa ser chamada corretamente.
@@ -3475,29 +1795,6 @@ run_callback my_object.write
3475run_callback my_object\write 1795run_callback my_object\write
3476``` 1796```
3477 1797
3478<YueDisplay>
3479
3480```yue
3481my_object = {
3482 value: 1000
3483 write: => print "the value:", @value
3484}
3485
3486run_callback = (func) ->
3487 print "running callback..."
3488 func!
3489
3490-- isso não funcionará:
3491-- a função não tem referência a my_object
3492run_callback my_object.write
3493
3494-- sintaxe de function stub
3495-- nos permite empacotar o objeto em uma nova função
3496run_callback my_object\write
3497```
3498
3499</YueDisplay>
3500
3501# Backcalls 1798# Backcalls
3502 1799
3503Backcalls são usados para desaninhar callbacks. Eles são definidos usando setas apontando para a esquerda como o último parâmetro, preenchendo por padrão uma chamada de função. Toda a sintaxe é basicamente a mesma das funções seta regulares, exceto que apenas aponta para o outro lado e o corpo da função não requer indentação. 1800Backcalls são usados para desaninhar callbacks. Eles são definidos usando setas apontando para a esquerda como o último parâmetro, preenchendo por padrão uma chamada de função. Toda a sintaxe é basicamente a mesma das funções seta regulares, exceto que apenas aponta para o outro lado e o corpo da função não requer indentação.
@@ -3507,15 +1804,6 @@ x <- f
3507print "hello" .. x 1804print "hello" .. x
3508``` 1805```
3509 1806
3510<YueDisplay>
3511
3512```yue
3513x <- f
3514print "hello" .. x
3515```
3516
3517</YueDisplay>
3518
3519Funções seta "fat" também estão disponíveis. 1807Funções seta "fat" também estão disponíveis.
3520 1808
3521```yuescript 1809```yuescript
@@ -3523,15 +1811,6 @@ Funções seta "fat" também estão disponíveis.
3523print @value 1811print @value
3524``` 1812```
3525 1813
3526<YueDisplay>
3527
3528```yue
3529<= f
3530print @value
3531```
3532
3533</YueDisplay>
3534
3535Você pode especificar um placeholder para onde deseja que a função backcall vá como parâmetro. 1814Você pode especificar um placeholder para onde deseja que a função backcall vá como parâmetro.
3536 1815
3537```yuescript 1816```yuescript
@@ -3539,15 +1818,6 @@ Você pode especificar um placeholder para onde deseja que a função backcall v
3539x * 2 1818x * 2
3540``` 1819```
3541 1820
3542<YueDisplay>
3543
3544```yue
3545(x) <- map _, [1, 2, 3]
3546x * 2
3547```
3548
3549</YueDisplay>
3550
3551Se você desejar ter mais código após seus backcalls, pode colocá-los em uma instrução do. E os parênteses podem ser omitidos com funções seta não-fat. 1821Se você desejar ter mais código após seus backcalls, pode colocá-los em uma instrução do. E os parênteses podem ser omitidos com funções seta não-fat.
3552 1822
3553```yuescript 1823```yuescript
@@ -3559,19 +1829,6 @@ result, msg = do
3559print result, msg 1829print result, msg
3560``` 1830```
3561 1831
3562<YueDisplay>
3563
3564```yue
3565result, msg = do
3566 data <- readAsync "filename.txt"
3567 print data
3568 info <- processAsync data
3569 check info
3570print result, msg
3571```
3572
3573</YueDisplay>
3574
3575# Literais de função 1832# Literais de função
3576 1833
3577Todas as funções são criadas usando uma expressão de função. Uma função simples é denotada usando a seta: **->**. 1834Todas as funções são criadas usando uma expressão de função. Uma função simples é denotada usando a seta: **->**.
@@ -3581,15 +1838,6 @@ my_function = ->
3581my_function() -- chama a função vazia 1838my_function() -- chama a função vazia
3582``` 1839```
3583 1840
3584<YueDisplay>
3585
3586```yue
3587my_function = ->
3588my_function() -- chama a função vazia
3589```
3590
3591</YueDisplay>
3592
3593O corpo da função pode ser uma instrução colocada diretamente após a seta, ou pode ser uma série de instruções indentadas nas linhas seguintes: 1841O corpo da função pode ser uma instrução colocada diretamente após a seta, ou pode ser uma série de instruções indentadas nas linhas seguintes:
3594 1842
3595```yuescript 1843```yuescript
@@ -3600,18 +1848,6 @@ func_b = ->
3600 print "The value:", value 1848 print "The value:", value
3601``` 1849```
3602 1850
3603<YueDisplay>
3604
3605```yue
3606func_a = -> print "hello world"
3607
3608func_b = ->
3609 value = 100
3610 print "The value:", value
3611```
3612
3613</YueDisplay>
3614
3615Se uma função não tem argumentos, ela pode ser chamada usando o operador !, em vez de parênteses vazios. A invocação ! é a forma preferida de chamar funções sem argumentos. 1851Se uma função não tem argumentos, ela pode ser chamada usando o operador !, em vez de parênteses vazios. A invocação ! é a forma preferida de chamar funções sem argumentos.
3616 1852
3617```yuescript 1853```yuescript
@@ -3619,29 +1855,12 @@ func_a!
3619func_b() 1855func_b()
3620``` 1856```
3621 1857
3622<YueDisplay>
3623
3624```yue
3625func_a!
3626func_b()
3627```
3628
3629</YueDisplay>
3630
3631Funções com argumentos podem ser criadas precedendo a seta com uma lista de nomes de argumentos entre parênteses: 1858Funções com argumentos podem ser criadas precedendo a seta com uma lista de nomes de argumentos entre parênteses:
3632 1859
3633```yuescript 1860```yuescript
3634sum = (x, y) -> print "sum", x + y 1861sum = (x, y) -> print "sum", x + y
3635``` 1862```
3636 1863
3637<YueDisplay>
3638
3639```yue
3640sum = (x, y) -> print "sum", x + y
3641```
3642
3643</YueDisplay>
3644
3645Funções podem ser chamadas listando os argumentos após o nome de uma expressão que avalia para uma função. Ao encadear chamadas de função, os argumentos são aplicados à função mais próxima à esquerda. 1864Funções podem ser chamadas listando os argumentos após o nome de uma expressão que avalia para uma função. Ao encadear chamadas de função, os argumentos são aplicados à função mais próxima à esquerda.
3646 1865
3647```yuescript 1866```yuescript
@@ -3651,31 +1870,12 @@ print sum 10, 20
3651a b c "a", "b", "c" 1870a b c "a", "b", "c"
3652``` 1871```
3653 1872
3654<YueDisplay>
3655
3656```yue
3657sum 10, 20
3658print sum 10, 20
3659
3660a b c "a", "b", "c"
3661```
3662
3663</YueDisplay>
3664
3665Para evitar ambiguidade ao chamar funções, parênteses também podem ser usados para envolver os argumentos. Isso é necessário aqui para garantir que os argumentos certos sejam enviados às funções certas. 1873Para evitar ambiguidade ao chamar funções, parênteses também podem ser usados para envolver os argumentos. Isso é necessário aqui para garantir que os argumentos certos sejam enviados às funções certas.
3666 1874
3667```yuescript 1875```yuescript
3668print "x:", sum(10, 20), "y:", sum(30, 40) 1876print "x:", sum(10, 20), "y:", sum(30, 40)
3669``` 1877```
3670 1878
3671<YueDisplay>
3672
3673```yue
3674print "x:", sum(10, 20), "y:", sum(30, 40)
3675```
3676
3677</YueDisplay>
3678
3679Não deve haver espaço entre o parêntese de abertura e a função. 1879Não deve haver espaço entre o parêntese de abertura e a função.
3680 1880
3681As funções convertem a última instrução em seu corpo em uma instrução de retorno, isso é chamado de retorno implícito: 1881As funções convertem a última instrução em seu corpo em uma instrução de retorno, isso é chamado de retorno implícito:
@@ -3685,29 +1885,12 @@ sum = (x, y) -> x + y
3685print "The sum is ", sum 10, 20 1885print "The sum is ", sum 10, 20
3686``` 1886```
3687 1887
3688<YueDisplay>
3689
3690```yue
3691sum = (x, y) -> x + y
3692print "The sum is ", sum 10, 20
3693```
3694
3695</YueDisplay>
3696
3697E se você precisar retornar explicitamente, pode usar a palavra-chave return: 1888E se você precisar retornar explicitamente, pode usar a palavra-chave return:
3698 1889
3699```yuescript 1890```yuescript
3700sum = (x, y) -> return x + y 1891sum = (x, y) -> return x + y
3701``` 1892```
3702 1893
3703<YueDisplay>
3704
3705```yue
3706sum = (x, y) -> return x + y
3707```
3708
3709</YueDisplay>
3710
3711Assim como no Lua, as funções podem retornar múltiplos valores. A última instrução deve ser uma lista de valores separados por vírgulas: 1894Assim como no Lua, as funções podem retornar múltiplos valores. A última instrução deve ser uma lista de valores separados por vírgulas:
3712 1895
3713```yuescript 1896```yuescript
@@ -3715,15 +1898,6 @@ mystery = (x, y) -> x + y, x - y
3715a, b = mystery 10, 20 1898a, b = mystery 10, 20
3716``` 1899```
3717 1900
3718<YueDisplay>
3719
3720```yue
3721mystery = (x, y) -> x + y, x - y
3722a, b = mystery 10, 20
3723```
3724
3725</YueDisplay>
3726
3727## Setas fat 1901## Setas fat
3728 1902
3729Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um método, uma sintaxe especial é fornecida para criar funções que incluem automaticamente um argumento self. 1903Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um método, uma sintaxe especial é fornecida para criar funções que incluem automaticamente um argumento self.
@@ -3732,14 +1906,6 @@ Como é um idioma em Lua enviar um objeto como primeiro argumento ao chamar um m
3732func = (num) => @value + num 1906func = (num) => @value + num
3733``` 1907```
3734 1908
3735<YueDisplay>
3736
3737```yue
3738func = (num) => @value + num
3739```
3740
3741</YueDisplay>
3742
3743## Valores padrão de argumentos 1909## Valores padrão de argumentos
3744 1910
3745É possível fornecer valores padrão para os argumentos de uma função. Um argumento é determinado como vazio se seu valor for nil. Qualquer argumento nil que tenha valor padrão será substituído antes da execução do corpo da função. 1911É possível fornecer valores padrão para os argumentos de uma função. Um argumento é determinado como vazio se seu valor for nil. Qualquer argumento nil que tenha valor padrão será substituído antes da execução do corpo da função.
@@ -3750,16 +1916,6 @@ my_function = (name = "something", height = 100) ->
3750 print "My height is", height 1916 print "My height is", height
3751``` 1917```
3752 1918
3753<YueDisplay>
3754
3755```yue
3756my_function = (name = "something", height = 100) ->
3757 print "Hello I am", name
3758 print "My height is", height
3759```
3760
3761</YueDisplay>
3762
3763Uma expressão de valor padrão de argumento é avaliada no corpo da função na ordem das declarações de argumentos. Por esse motivo, os valores padrão têm acesso aos argumentos declarados anteriormente. 1919Uma expressão de valor padrão de argumento é avaliada no corpo da função na ordem das declarações de argumentos. Por esse motivo, os valores padrão têm acesso aos argumentos declarados anteriormente.
3764 1920
3765```yuescript 1921```yuescript
@@ -3767,15 +1923,6 @@ some_args = (x = 100, y = x + 1000) ->
3767 print x + y 1923 print x + y
3768``` 1924```
3769 1925
3770<YueDisplay>
3771
3772```yue
3773some_args = (x = 100, y = x + 1000) ->
3774 print x + y
3775```
3776
3777</YueDisplay>
3778
3779## Considerações 1926## Considerações
3780 1927
3781Devido à forma expressiva de chamar funções sem parênteses, algumas restrições devem ser colocadas para evitar ambiguidade de análise envolvendo espaço em branco. 1928Devido à forma expressiva de chamar funções sem parênteses, algumas restrições devem ser colocadas para evitar ambiguidade de análise envolvendo espaço em branco.
@@ -3789,17 +1936,6 @@ c = x -y
3789d = x- z 1936d = x- z
3790``` 1937```
3791 1938
3792<YueDisplay>
3793
3794```yue
3795a = x - 10
3796b = x-10
3797c = x -y
3798d = x- z
3799```
3800
3801</YueDisplay>
3802
3803A precedência do primeiro argumento de uma chamada de função pode ser controlada usando espaço em branco se o argumento for um literal de string. Em Lua, é comum omitir parênteses ao chamar uma função com uma única string ou literal de tabela. 1939A precedência do primeiro argumento de uma chamada de função pode ser controlada usando espaço em branco se o argumento for um literal de string. Em Lua, é comum omitir parênteses ao chamar uma função com uma única string ou literal de tabela.
3804 1940
3805Quando não há espaço entre uma variável e um literal de string, a chamada de função tem precedência sobre quaisquer expressões seguintes. Nenhum outro argumento pode ser passado para a função quando ela é chamada dessa forma. 1941Quando não há espaço entre uma variável e um literal de string, a chamada de função tem precedência sobre quaisquer expressões seguintes. Nenhum outro argumento pode ser passado para a função quando ela é chamada dessa forma.
@@ -3811,15 +1947,6 @@ x = func"hello" + 100
3811y = func "hello" + 100 1947y = func "hello" + 100
3812``` 1948```
3813 1949
3814<YueDisplay>
3815
3816```yue
3817x = func"hello" + 100
3818y = func "hello" + 100
3819```
3820
3821</YueDisplay>
3822
3823## Argumentos multilinha 1950## Argumentos multilinha
3824 1951
3825Ao chamar funções que recebem um grande número de argumentos, é conveniente dividir a lista de argumentos em várias linhas. Devido à natureza sensível a espaço em branco da linguagem, deve-se ter cuidado ao dividir a lista de argumentos. 1952Ao chamar funções que recebem um grande número de argumentos, é conveniente dividir a lista de argumentos em várias linhas. Devido à natureza sensível a espaço em branco da linguagem, deve-se ter cuidado ao dividir a lista de argumentos.
@@ -3836,20 +1963,6 @@ cool_func 1, 2,
3836 7, 8 1963 7, 8
3837``` 1964```
3838 1965
3839<YueDisplay>
3840
3841```yue
3842my_func 5, 4, 3,
3843 8, 9, 10
3844
3845cool_func 1, 2,
3846 3, 4,
3847 5, 6,
3848 7, 8
3849```
3850
3851</YueDisplay>
3852
3853Este tipo de invocação pode ser aninhado. O nível de indentação é usado para determinar a qual função os argumentos pertencem. 1966Este tipo de invocação pode ser aninhado. O nível de indentação é usado para determinar a qual função os argumentos pertencem.
3854 1967
3855```yuescript 1968```yuescript
@@ -3859,17 +1972,6 @@ my_func 5, 6, 7,
3859 5, 4 1972 5, 4
3860``` 1973```
3861 1974
3862<YueDisplay>
3863
3864```yue
3865my_func 5, 6, 7,
3866 6, another_func 6, 7, 8,
3867 9, 1, 2,
3868 5, 4
3869```
3870
3871</YueDisplay>
3872
3873Como as tabelas também usam vírgula como delimitador, esta sintaxe de indentação ajuda a deixar os valores fazerem parte da lista de argumentos em vez de fazerem parte da tabela. 1975Como as tabelas também usam vírgula como delimitador, esta sintaxe de indentação ajuda a deixar os valores fazerem parte da lista de argumentos em vez de fazerem parte da tabela.
3874 1976
3875```yuescript 1977```yuescript
@@ -3880,18 +1982,6 @@ x = [
3880] 1982]
3881``` 1983```
3882 1984
3883<YueDisplay>
3884
3885```yue
3886x = [
3887 1, 2, 3, 4, a_func 4, 5,
3888 5, 6,
3889 8, 9, 10
3890]
3891```
3892
3893</YueDisplay>
3894
3895Embora incomum, observe como podemos dar uma indentação mais profunda para argumentos de função se soubermos que usaremos uma indentação menor mais adiante. 1985Embora incomum, observe como podemos dar uma indentação mais profunda para argumentos de função se soubermos que usaremos uma indentação menor mais adiante.
3896 1986
3897```yuescript 1987```yuescript
@@ -3901,17 +1991,6 @@ y = [ my_func 1, 2, 3,
3901] 1991]
3902``` 1992```
3903 1993
3904<YueDisplay>
3905
3906```yue
3907y = [ my_func 1, 2, 3,
3908 4, 5,
3909 5, 6, 7
3910]
3911```
3912
3913</YueDisplay>
3914
3915A mesma coisa pode ser feita com outras instruções em nível de bloco como condicionais. Podemos usar o nível de indentação para determinar a qual instrução um valor pertence: 1994A mesma coisa pode ser feita com outras instruções em nível de bloco como condicionais. Podemos usar o nível de indentação para determinar a qual instrução um valor pertence:
3916 1995
3917```yuescript 1996```yuescript
@@ -3928,24 +2007,6 @@ if func 1, 2, 3,
3928 print "I am inside if" 2007 print "I am inside if"
3929``` 2008```
3930 2009
3931<YueDisplay>
3932
3933```yue
3934if func 1, 2, 3,
3935 "hello",
3936 "world"
3937 print "hello"
3938 print "I am inside if"
3939
3940if func 1, 2, 3,
3941 "hello",
3942 "world"
3943 print "hello"
3944 print "I am inside if"
3945```
3946
3947</YueDisplay>
3948
3949## Desestruturação de parâmetros 2010## Desestruturação de parâmetros
3950 2011
3951YueScript agora suporta desestruturação de parâmetros de função quando o argumento é um objeto. Duas formas de literais de tabela de desestruturação estão disponíveis: 2012YueScript agora suporta desestruturação de parâmetros de função quando o argumento é um objeto. Duas formas de literais de tabela de desestruturação estão disponíveis:
@@ -3967,23 +2028,6 @@ arg1 = {a: 0}
3967f2 arg1, arg2 2028f2 arg1, arg2
3968``` 2029```
3969 2030
3970<YueDisplay>
3971
3972```yue
3973f1 = (:a, :b, :c) ->
3974 print a, b, c
3975
3976f1 a: 1, b: "2", c: {}
3977
3978f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
3979print a1, b, c
3980
3981arg1 = {a: 0}
3982f2 arg1, arg2
3983```
3984
3985</YueDisplay>
3986
3987## Expressão de retorno prefixada 2031## Expressão de retorno prefixada
3988 2032
3989Ao trabalhar com corpos de função profundamente aninhados, pode ser tedioso manter a legibilidade e consistência do valor de retorno. Para resolver isso, YueScript introduz a sintaxe **Expressão de Retorno Prefixada**. Sua forma é a seguinte: 2033Ao trabalhar com corpos de função profundamente aninhados, pode ser tedioso manter a legibilidade e consistência do valor de retorno. Para resolver isso, YueScript introduz a sintaxe **Expressão de Retorno Prefixada**. Sua forma é a seguinte:
@@ -3997,19 +2041,6 @@ findFirstEven = (list): nil ->
3997 return sub 2041 return sub
3998``` 2042```
3999 2043
4000<YueDisplay>
4001
4002```yue
4003findFirstEven = (list): nil ->
4004 for item in *list
4005 if type(item) == "table"
4006 for sub in *item
4007 if sub % 2 == 0
4008 return sub
4009```
4010
4011</YueDisplay>
4012
4013Isso é equivalente a: 2044Isso é equivalente a:
4014 2045
4015```yuescript 2046```yuescript
@@ -4022,20 +2053,6 @@ findFirstEven = (list) ->
4022 nil 2053 nil
4023``` 2054```
4024 2055
4025<YueDisplay>
4026
4027```yue
4028findFirstEven = (list) ->
4029 for item in *list
4030 if type(item) == "table"
4031 for sub in *item
4032 if sub % 2 == 0
4033 return sub
4034 nil
4035```
4036
4037</YueDisplay>
4038
4039A única diferença é que você pode mover a expressão de retorno final antes do token `->` ou `=>` para indicar o valor de retorno implícito da função como última instrução. Dessa forma, mesmo em funções com múltiplos loops aninhados ou ramificações condicionais, você não precisa mais escrever uma expressão de retorno no final do corpo da função, tornando a estrutura lógica mais direta e fácil de seguir. 2056A única diferença é que você pode mover a expressão de retorno final antes do token `->` ou `=>` para indicar o valor de retorno implícito da função como última instrução. Dessa forma, mesmo em funções com múltiplos loops aninhados ou ramificações condicionais, você não precisa mais escrever uma expressão de retorno no final do corpo da função, tornando a estrutura lógica mais direta e fácil de seguir.
4040 2057
4041## Varargs nomeados 2058## Varargs nomeados
@@ -4064,32 +2081,6 @@ process = (...args) ->
4064process 1, nil, 3, nil, 5 2081process 1, nil, 3, nil, 5
4065``` 2082```
4066 2083
4067<YueDisplay>
4068
4069```yue
4070f = (...t) ->
4071 print "contagem de argumentos:", t.n
4072 print "comprimento da tabela:", #t
4073 for i = 1, t.n
4074 print t[i]
4075
4076f 1, 2, 3
4077f "a", "b", "c", "d"
4078f!
4079
4080-- Tratando casos com valores nil
4081process = (...args) ->
4082 sum = 0
4083 for i = 1, args.n
4084 if args[i] != nil and type(args[i]) == "number"
4085 sum += args[i]
4086 sum
4087
4088process 1, nil, 3, nil, 5
4089```
4090
4091</YueDisplay>
4092
4093# Espaço em branco 2084# Espaço em branco
4094 2085
4095YueScript é uma linguagem sensível a espaço em branco. Você precisa escrever blocos de código na mesma indentação com espaço **' '** ou tabulação **'\t'**, como corpo de função, lista de valores e alguns blocos de controle. E expressões contendo diferentes espaços em branco podem significar coisas diferentes. Tabulação é tratada como 4 espaços, mas é melhor não misturar o uso de espaços e tabulações. 2086YueScript é uma linguagem sensível a espaço em branco. Você precisa escrever blocos de código na mesma indentação com espaço **' '** ou tabulação **'\t'**, como corpo de função, lista de valores e alguns blocos de controle. E expressões contendo diferentes espaços em branco podem significar coisas diferentes. Tabulação é tratada como 4 espaços, mas é melhor não misturar o uso de espaços e tabulações.
@@ -4102,14 +2093,6 @@ Uma instrução normalmente termina em uma quebra de linha. Você também pode u
4102a = 1; b = 2; print a + b 2093a = 1; b = 2; print a + b
4103``` 2094```
4104 2095
4105<YueDisplay>
4106
4107```yue
4108a = 1; b = 2; print a + b
4109```
4110
4111</YueDisplay>
4112
4113## Encadeamento multilinha 2096## Encadeamento multilinha
4114 2097
4115Você pode escrever chamadas de função encadeadas em múltiplas linhas com a mesma indentação. 2098Você pode escrever chamadas de função encadeadas em múltiplas linhas com a mesma indentação.
@@ -4123,19 +2106,6 @@ Rx.Observable
4123 \subscribe print 2106 \subscribe print
4124``` 2107```
4125 2108
4126<YueDisplay>
4127
4128```yue
4129Rx.Observable
4130 .fromRange 1, 8
4131 \filter (x) -> x % 2 == 0
4132 \concat Rx.Observable.of 'who do we appreciate'
4133 \map (value) -> value .. '!'
4134 \subscribe print
4135```
4136
4137</YueDisplay>
4138
4139# Comentário 2109# Comentário
4140 2110
4141```yuescript 2111```yuescript
@@ -4151,23 +2121,6 @@ Está OK.
4151func --[[port]] 3000, --[[ip]] "192.168.1.1" 2121func --[[port]] 3000, --[[ip]] "192.168.1.1"
4152``` 2122```
4153 2123
4154<YueDisplay>
4155
4156```yue
4157-- Eu sou um comentário
4158
4159str = --[[
4160Este é um comentário multilinha.
4161Está OK.
4162]] strA \ -- comentário 1
4163 .. strB \ -- comentário 2
4164 .. strC
4165
4166func --[[port]] 3000, --[[ip]] "192.168.1.1"
4167```
4168
4169</YueDisplay>
4170
4171# Atributos 2124# Atributos
4172 2125
4173Suporte de sintaxe para atributos do Lua 5.4. E você ainda pode usar tanto a declaração `const` quanto `close` e obter verificação de constante e callback com escopo funcionando ao direcionar para versões do Lua abaixo da 5.4. 2126Suporte de sintaxe para atributos do Lua 5.4. E você ainda pode usar tanto a declaração `const` quanto `close` e obter verificação de constante e callback com escopo funcionando ao direcionar para versões do Lua abaixo da 5.4.
@@ -4177,15 +2130,6 @@ const a = 123
4177close _ = <close>: -> print "Fora do escopo." 2130close _ = <close>: -> print "Fora do escopo."
4178``` 2131```
4179 2132
4180<YueDisplay>
4181
4182```yue
4183const a = 123
4184close _ = <close>: -> print "Fora do escopo."
4185```
4186
4187</YueDisplay>
4188
4189Você pode fazer desestruturação com variáveis atribuídas como constante. 2133Você pode fazer desestruturação com variáveis atribuídas como constante.
4190 2134
4191```yuescript 2135```yuescript
@@ -4193,15 +2137,6 @@ const {:a, :b, c, d} = tb
4193-- a = 1 2137-- a = 1
4194``` 2138```
4195 2139
4196<YueDisplay>
4197
4198```yue
4199const {:a, :b, c, d} = tb
4200-- a = 1
4201```
4202
4203</YueDisplay>
4204
4205Você também pode declarar uma variável global como `const`. 2140Você também pode declarar uma variável global como `const`.
4206 2141
4207```yuescript 2142```yuescript
@@ -4209,15 +2144,6 @@ global const Constant = 123
4209-- Constant = 1 2144-- Constant = 1
4210``` 2145```
4211 2146
4212<YueDisplay>
4213
4214```yue
4215global const Constant = 123
4216-- Constant = 1
4217```
4218
4219</YueDisplay>
4220
4221# Operador 2147# Operador
4222 2148
4223Todos os operadores binários e unários do Lua estão disponíveis. Além disso, **!=** é um alias para **~=**, e **\\** ou **::** podem ser usados para escrever uma chamada de função encadeada como `tb\func!` ou `tb::func!`. E o YueScript oferece alguns outros operadores especiais para escrever códigos mais expressivos. 2149Todos os operadores binários e unários do Lua estão disponíveis. Além disso, **!=** é um alias para **~=**, e **\\** ou **::** podem ser usados para escrever uma chamada de função encadeada como `tb\func!` ou `tb::func!`. E o YueScript oferece alguns outros operadores especiais para escrever códigos mais expressivos.
@@ -4227,15 +2153,6 @@ tb\func! if tb ~= nil
4227tb::func! if tb != nil 2153tb::func! if tb != nil
4228``` 2154```
4229 2155
4230<YueDisplay>
4231
4232```yue
4233tb\func! if tb ~= nil
4234tb::func! if tb != nil
4235```
4236
4237</YueDisplay>
4238
4239## Comparações encadeadas 2156## Comparações encadeadas
4240 2157
4241Comparações podem ser encadeadas arbitrariamente: 2158Comparações podem ser encadeadas arbitrariamente:
@@ -4249,19 +2166,6 @@ print 1 <= a <= 10
4249-- saída: true 2166-- saída: true
4250``` 2167```
4251 2168
4252<YueDisplay>
4253
4254```yue
4255print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
4256-- saída: true
4257
4258a = 5
4259print 1 <= a <= 10
4260-- saída: true
4261```
4262
4263</YueDisplay>
4264
4265Observe o comportamento de avaliação das comparações encadeadas: 2169Observe o comportamento de avaliação das comparações encadeadas:
4266 2170
4267```yuescript 2171```yuescript
@@ -4287,33 +2191,6 @@ print v(1) > v(2) <= v(3)
4287]] 2191]]
4288``` 2192```
4289 2193
4290<YueDisplay>
4291
4292```yue
4293v = (x) ->
4294 print x
4295 x
4296
4297print v(1) < v(2) <= v(3)
4298--[[
4299 saída:
4300 2
4301 1
4302 3
4303 true
4304]]
4305
4306print v(1) > v(2) <= v(3)
4307--[[
4308 saída:
4309 2
4310 1
4311 false
4312]]
4313```
4314
4315</YueDisplay>
4316
4317A expressão do meio é avaliada apenas uma vez, em vez de duas vezes como seria se a expressão fosse escrita como `v(1) < v(2) and v(2) <= v(3)`. No entanto, a ordem das avaliações em uma comparação encadeada é indefinida. É fortemente recomendado não usar expressões com efeitos colaterais (como impressão) em comparações encadeadas. Se efeitos colaterais forem necessários, o operador de curto-circuito `and` deve ser usado explicitamente. 2194A expressão do meio é avaliada apenas uma vez, em vez de duas vezes como seria se a expressão fosse escrita como `v(1) < v(2) and v(2) <= v(3)`. No entanto, a ordem das avaliações em uma comparação encadeada é indefinida. É fortemente recomendado não usar expressões com efeitos colaterais (como impressão) em comparações encadeadas. Se efeitos colaterais forem necessários, o operador de curto-circuito `and` deve ser usado explicitamente.
4318 2195
4319## Anexar à tabela 2196## Anexar à tabela
@@ -4325,15 +2202,6 @@ tab = []
4325tab[] = "Value" 2202tab[] = "Value"
4326``` 2203```
4327 2204
4328<YueDisplay>
4329
4330```yue
4331tab = []
4332tab[] = "Value"
4333```
4334
4335</YueDisplay>
4336
4337Você também pode usar o operador spread `...` para anexar todos os elementos de uma lista a outra: 2205Você também pode usar o operador spread `...` para anexar todos os elementos de uma lista a outra:
4338 2206
4339```yuescript 2207```yuescript
@@ -4343,17 +2211,6 @@ tbA[] = ...tbB
4343-- tbA agora é [1, 2, 3, 4, 5, 6] 2211-- tbA agora é [1, 2, 3, 4, 5, 6]
4344``` 2212```
4345 2213
4346<YueDisplay>
4347
4348```yue
4349tbA = [1, 2, 3]
4350tbB = [4, 5, 6]
4351tbA[] = ...tbB
4352-- tbA agora é [1, 2, 3, 4, 5, 6]
4353```
4354
4355</YueDisplay>
4356
4357## Spread de tabela 2214## Spread de tabela
4358 2215
4359Você pode concatenar tabelas de array ou tabelas hash usando o operador spread `...` antes de expressões em literais de tabela. 2216Você pode concatenar tabelas de array ou tabelas hash usando o operador spread `...` antes de expressões em literais de tabela.
@@ -4375,27 +2232,6 @@ b = {4, 5, y: 1}
4375merge = {...a, ...b} 2232merge = {...a, ...b}
4376``` 2233```
4377 2234
4378<YueDisplay>
4379
4380```yue
4381parts =
4382 * "shoulders"
4383 * "knees"
4384lyrics =
4385 * "head"
4386 * ...parts
4387 * "and"
4388 * "toes"
4389
4390copy = {...other}
4391
4392a = {1, 2, 3, x: 1}
4393b = {4, 5, y: 1}
4394merge = {...a, ...b}
4395```
4396
4397</YueDisplay>
4398
4399## Indexação reversa de tabela 2235## Indexação reversa de tabela
4400 2236
4401Você pode usar o operador **#** para obter os últimos elementos de uma tabela. 2237Você pode usar o operador **#** para obter os últimos elementos de uma tabela.
@@ -4406,16 +2242,6 @@ second_last = data.items[#-1]
4406data.items[#] = 1 2242data.items[#] = 1
4407``` 2243```
4408 2244
4409<YueDisplay>
4410
4411```yue
4412last = data.items[#]
4413second_last = data.items[#-1]
4414data.items[#] = 1
4415```
4416
4417</YueDisplay>
4418
4419## Metatable 2245## Metatable
4420 2246
4421O operador **<>** pode ser usado como atalho para manipulação de metatable. 2247O operador **<>** pode ser usado como atalho para manipulação de metatable.
@@ -4440,26 +2266,6 @@ print d.value
4440close _ = <close>: -> print "fora do escopo" 2266close _ = <close>: -> print "fora do escopo"
4441``` 2267```
4442 2268
4443<YueDisplay>
4444
4445```yue
4446mt = {}
4447add = (right) => <>: mt, value: @value + right.value
4448mt.__add = add
4449
4450a = <>: mt, value: 1
4451 -- definir campo com variável de mesmo nome
4452b = :<add>, value: 2
4453c = <add>: mt.__add, value: 3
4454
4455d = a + b + c
4456print d.value
4457
4458close _ = <close>: -> print "fora do escopo"
4459```
4460
4461</YueDisplay>
4462
4463### Acesso à metatable 2269### Acesso à metatable
4464 2270
4465Acesse a metatable com **<>** ou nome do metamétodo cercado por **<>** ou escrevendo alguma expressão em **<>**. 2271Acesse a metatable com **<>** ou nome do metamétodo cercado por **<>** ou escrevendo alguma expressão em **<>**.
@@ -4474,19 +2280,6 @@ tb.<> = __index: {item: "hello"}
4474print tb.item 2280print tb.item
4475``` 2281```
4476 2282
4477<YueDisplay>
4478
4479```yue
4480-- criar com metatable contendo campo "value"
4481tb = <"value">: 123
4482tb.<index> = tb.<>
4483print tb.value
4484tb.<> = __index: {item: "hello"}
4485print tb.item
4486```
4487
4488</YueDisplay>
4489
4490### Desestruturação de metatable 2283### Desestruturação de metatable
4491 2284
4492Desestruture a metatable com chave de metamétodo cercada por **<>**. 2285Desestruture a metatable com chave de metamétodo cercada por **<>**.
@@ -4496,15 +2289,6 @@ Desestruture a metatable com chave de metamétodo cercada por **<>**.
4496print item, new, close, getter 2289print item, new, close, getter
4497``` 2290```
4498 2291
4499<YueDisplay>
4500
4501```yue
4502{item, :new, :<close>, <index>: getter} = tb
4503print item, new, close, getter
4504```
4505
4506</YueDisplay>
4507
4508## Existência 2292## Existência
4509 2293
4510O operador **?** pode ser usado em diversos contextos para verificar existência. 2294O operador **?** pode ser usado em diversos contextos para verificar existência.
@@ -4524,25 +2308,6 @@ with? io.open "test.txt", "w"
4524 \close! 2308 \close!
4525``` 2309```
4526 2310
4527<YueDisplay>
4528
4529```yue
4530func?!
4531print abc?["hello world"]?.xyz
4532
4533x = tab?.value
4534len = utf8?.len or string?.len or (o) -> #o
4535
4536if print and x?
4537 print x
4538
4539with? io.open "test.txt", "w"
4540 \write "hello"
4541 \close!
4542```
4543
4544</YueDisplay>
4545
4546## Pipe 2311## Pipe
4547 2312
4548Em vez de uma série de chamadas de função aninhadas, você pode encaminhar valores com o operador **|>**. 2313Em vez de uma série de chamadas de função aninhadas, você pode encaminhar valores com o operador **|>**.
@@ -4561,24 +2326,6 @@ readFile "example.txt"
4561 |> print 2326 |> print
4562``` 2327```
4563 2328
4564<YueDisplay>
4565
4566```yue
4567"hello" |> print
45681 |> print 2 -- insere o item do pipe como primeiro argumento
45692 |> print 1, _, 3 -- pipe com um placeholder
4570
4571-- expressão pipe em multilinha
4572readFile "example.txt"
4573 |> extract language, {}
4574 |> parse language
4575 |> emit
4576 |> render
4577 |> print
4578```
4579
4580</YueDisplay>
4581
4582## Coalescência de nil 2329## Coalescência de nil
4583 2330
4584O operador de coalescência de nil **??** retorna o valor do operando esquerdo se não for **nil**; caso contrário, avalia o operando direito e retorna seu resultado. O operador **??** não avalia seu operando direito se o operando esquerdo avaliar para não-nil. 2331O operador de coalescência de nil **??** retorna o valor do operando esquerdo se não for **nil**; caso contrário, avalia o operando direito e retorna seu resultado. O operador **??** não avalia seu operando direito se o operando esquerdo avaliar para não-nil.
@@ -4591,17 +2338,6 @@ func a ?? {}
4591a ??= false 2338a ??= false
4592``` 2339```
4593 2340
4594<YueDisplay>
4595
4596```yue
4597local a, b, c, d
4598a = b ?? c ?? d
4599func a ?? {}
4600a ??= false
4601```
4602
4603</YueDisplay>
4604
4605## Objeto implícito 2341## Objeto implícito
4606 2342
4607Você pode escrever uma lista de estruturas implícitas que começa com o símbolo **\*** ou **-** dentro de um bloco de tabela. Se você está criando objeto implícito, os campos do objeto devem estar com a mesma indentação. 2343Você pode escrever uma lista de estruturas implícitas que começa com o símbolo **\*** ou **-** dentro de um bloco de tabela. Se você está criando objeto implícito, os campos do objeto devem estar com a mesma indentação.
@@ -4649,52 +2385,6 @@ tb =
4649 2385
4650``` 2386```
4651 2387
4652<YueDisplay>
4653
4654```yue
4655-- atribuição com objeto implícito
4656list =
4657 * 1
4658 * 2
4659 * 3
4660
4661-- chamada de função com objeto implícito
4662func
4663 * 1
4664 * 2
4665 * 3
4666
4667-- retorno com objeto implícito
4668f = ->
4669 return
4670 * 1
4671 * 2
4672 * 3
4673
4674-- tabela com objeto implícito
4675tb =
4676 name: "abc"
4677
4678 values:
4679 - "a"
4680 - "b"
4681 - "c"
4682
4683 objects:
4684 - name: "a"
4685 value: 1
4686 func: => @value + 1
4687 tb:
4688 fieldA: 1
4689
4690 - name: "b"
4691 value: 2
4692 func: => @value + 2
4693 tb: { }
4694```
4695
4696</YueDisplay>
4697
4698# Literais 2388# Literais
4699 2389
4700Todos os literais primitivos do Lua podem ser usados. Isso se aplica a números, strings, booleanos e **nil**. 2390Todos os literais primitivos do Lua podem ser usados. Isso se aplica a números, strings, booleanos e **nil**.
@@ -4710,19 +2400,6 @@ some_string = "Aqui está uma string
4710print "Tenho #{math.random! * 100}% de certeza." 2400print "Tenho #{math.random! * 100}% de certeza."
4711``` 2401```
4712 2402
4713<YueDisplay>
4714
4715```yue
4716some_string = "Aqui está uma string
4717 que tem uma quebra de linha."
4718
4719-- Você pode misturar expressões em literais de string usando a sintaxe #{}.
4720-- Interpolação de string está disponível apenas em strings com aspas duplas.
4721print "Tenho #{math.random! * 100}% de certeza."
4722```
4723
4724</YueDisplay>
4725
4726## Literais numéricos 2403## Literais numéricos
4727 2404
4728Você pode usar underscores em um literal numérico para aumentar a legibilidade. 2405Você pode usar underscores em um literal numérico para aumentar a legibilidade.
@@ -4733,16 +2410,6 @@ hex = 0xEF_BB_BF
4733binary = 0B10011 2410binary = 0B10011
4734``` 2411```
4735 2412
4736<YueDisplay>
4737
4738```yue
4739integer = 1_000_000
4740hex = 0xEF_BB_BF
4741binary = 0B10011
4742```
4743
4744</YueDisplay>
4745
4746## String multilinha estilo YAML 2413## String multilinha estilo YAML
4747 2414
4748O prefixo `|` introduz um literal de string multilinha no estilo YAML: 2415O prefixo `|` introduz um literal de string multilinha no estilo YAML:
@@ -4755,18 +2422,6 @@ str = |
4755 - #{expr} 2422 - #{expr}
4756``` 2423```
4757 2424
4758<YueDisplay>
4759
4760```yue
4761str = |
4762 key: value
4763 list:
4764 - item1
4765 - #{expr}
4766```
4767
4768</YueDisplay>
4769
4770Isso permite escrever texto estruturado multilinha convenientemente. Todas as quebras de linha e indentação são preservadas em relação à primeira linha não vazia, e expressões dentro de `#{...}` são interpoladas automaticamente como `tostring(expr)`. 2425Isso permite escrever texto estruturado multilinha convenientemente. Todas as quebras de linha e indentação são preservadas em relação à primeira linha não vazia, e expressões dentro de `#{...}` são interpoladas automaticamente como `tostring(expr)`.
4771 2426
4772A string multilinha YAML detecta automaticamente o prefixo comum de espaço em branco à esquerda (indentação mínima em todas as linhas não vazias) e remove-o de todas as linhas. Isso facilita a indentação visual do seu código sem afetar o conteúdo da string resultante. 2427A string multilinha YAML detecta automaticamente o prefixo comum de espaço em branco à esquerda (indentação mínima em todas as linhas não vazias) e remove-o de todas as linhas. Isso facilita a indentação visual do seu código sem afetar o conteúdo da string resultante.
@@ -4779,18 +2434,6 @@ fn = ->
4779 return str 2434 return str
4780``` 2435```
4781 2436
4782<YueDisplay>
4783
4784```yue
4785fn = ->
4786 str = |
4787 foo:
4788 bar: baz
4789 return str
4790```
4791
4792</YueDisplay>
4793
4794A indentação interna é preservada em relação ao prefixo comum removido, permitindo estruturas aninhadas limpas. 2437A indentação interna é preservada em relação ao prefixo comum removido, permitindo estruturas aninhadas limpas.
4795 2438
4796Todos os caracteres especiais como aspas (`"`) e barras invertidas (`\`) no bloco YAML Multiline são escapados automaticamente para que a string Lua gerada seja sintaticamente válida e se comporte como esperado. 2439Todos os caracteres especiais como aspas (`"`) e barras invertidas (`\`) no bloco YAML Multiline são escapados automaticamente para que a string Lua gerada seja sintaticamente válida e se comporte como esperado.
@@ -4801,16 +2444,6 @@ str = |
4801 note: 'Ele disse: "#{Hello}!"' 2444 note: 'Ele disse: "#{Hello}!"'
4802``` 2445```
4803 2446
4804<YueDisplay>
4805
4806```yue
4807str = |
4808 path: "C:\Program Files\App"
4809 note: 'Ele disse: "#{Hello}!"'
4810```
4811
4812</YueDisplay>
4813
4814# Módulo 2447# Módulo
4815 2448
4816## Import 2449## Import
@@ -4842,35 +2475,6 @@ do
4842 import "export" as {one, two, Something:{umm:{ch}}} 2475 import "export" as {one, two, Something:{umm:{ch}}}
4843``` 2476```
4844 2477
4845<YueDisplay>
4846
4847```yue
4848-- usado como desestruturação de tabela
4849do
4850 import insert, concat from table
4851 -- reporta erro ao atribuir a insert, concat
4852 import C, Ct, Cmt from require "lpeg"
4853 -- atalho para require implícito
4854 import x, y, z from 'mymodule'
4855 -- import com estilo Python
4856 from 'module' import a, b, c
4857
4858-- atalho para requerer um módulo
4859do
4860 import 'module'
4861 import 'module_x'
4862 import "d-a-s-h-e-s"
4863 import "module.part"
4864
4865-- requerer módulo com aliasing ou desestruturação de tabela
4866do
4867 import "player" as PlayerModule
4868 import "lpeg" as :C, :Ct, :Cmt
4869 import "export" as {one, two, Something:{umm:{ch}}}
4870```
4871
4872</YueDisplay>
4873
4874## Import Global 2478## Import Global
4875 2479
4876Você pode importar globais específicos para variáveis locais com `import`. Ao importar uma cadeia de acessos a variáveis globais, o último campo será atribuído à variável local. 2480Você pode importar globais específicos para variáveis locais com `import`. Ao importar uma cadeia de acessos a variáveis globais, o último campo será atribuído à variável local.
@@ -4882,17 +2486,6 @@ do
4882 print concat ["a", tostring 1] 2486 print concat ["a", tostring 1]
4883``` 2487```
4884 2488
4885<YueDisplay>
4886
4887```yue
4888do
4889 import tostring
4890 import table.concat
4891 print concat ["a", tostring 1]
4892```
4893
4894</YueDisplay>
4895
4896### Importação automática de variável global 2489### Importação automática de variável global
4897 2490
4898Você pode colocar `import global` no topo de um bloco para importar automaticamente todos os nomes que não foram explicitamente declarados ou atribuídos no escopo atual como globais. Essas importações implícitas são tratadas como consts locais que referenciam os globais correspondentes na posição da instrução. 2491Você pode colocar `import global` no topo de um bloco para importar automaticamente todos os nomes que não foram explicitamente declarados ou atribuídos no escopo atual como globais. Essas importações implícitas são tratadas como consts locais que referenciam os globais correspondentes na posição da instrução.
@@ -4914,25 +2507,6 @@ do
4914 FLAG = 123 2507 FLAG = 123
4915``` 2508```
4916 2509
4917<YueDisplay>
4918
4919```yue
4920do
4921 import global
4922 print "hello"
4923 math.random 3
4924 -- print = nil -- erro: globais importados são const
4925
4926do
4927 -- variável global explícita não será importada
4928 import global
4929 global FLAG
4930 print FLAG
4931 FLAG = 123
4932```
4933
4934</YueDisplay>
4935
4936## Export 2510## Export
4937 2511
4938A instrução export oferece uma forma concisa de definir módulos. 2512A instrução export oferece uma forma concisa de definir módulos.
@@ -4957,26 +2531,6 @@ export class Something
4957 umm: "cool" 2531 umm: "cool"
4958``` 2532```
4959 2533
4960<YueDisplay>
4961
4962```yue
4963export a, b, c = 1, 2, 3
4964export cool = "cat"
4965
4966export What = if this
4967 "abc"
4968else
4969 "def"
4970
4971export y = ->
4972 hallo = 3434
4973
4974export class Something
4975 umm: "cool"
4976```
4977
4978</YueDisplay>
4979
4980Fazendo export nomeado com desestruturação. 2534Fazendo export nomeado com desestruturação.
4981 2535
4982```yuescript 2536```yuescript
@@ -4984,15 +2538,6 @@ export :loadstring, to_lua: tolua = yue
4984export {itemA: {:fieldA = 'default'}} = tb 2538export {itemA: {:fieldA = 'default'}} = tb
4985``` 2539```
4986 2540
4987<YueDisplay>
4988
4989```yue
4990export :loadstring, to_lua: tolua = yue
4991export {itemA: {:fieldA = 'default'}} = tb
4992```
4993
4994</YueDisplay>
4995
4996Exportar itens nomeados do módulo sem criar variáveis locais. 2541Exportar itens nomeados do módulo sem criar variáveis locais.
4997 2542
4998```yuescript 2543```yuescript
@@ -5001,16 +2546,6 @@ export.<index> = items
5001export["a-b-c"] = 123 2546export["a-b-c"] = 123
5002``` 2547```
5003 2548
5004<YueDisplay>
5005
5006```yue
5007export.itemA = tb
5008export.<index> = items
5009export["a-b-c"] = 123
5010```
5011
5012</YueDisplay>
5013
5014### Export sem nome 2549### Export sem nome
5015 2550
5016Export sem nome adicionará o item alvo na parte array da tabela exportada. 2551Export sem nome adicionará o item alvo na parte array da tabela exportada.
@@ -5028,23 +2563,6 @@ export with tmp
5028 j = 2000 2563 j = 2000
5029``` 2564```
5030 2565
5031<YueDisplay>
5032
5033```yue
5034d, e, f = 3, 2, 1
5035export d, e, f
5036
5037export if this
5038 123
5039else
5040 456
5041
5042export with tmp
5043 j = 2000
5044```
5045
5046</YueDisplay>
5047
5048### Export padrão 2566### Export padrão
5049 2567
5050Usar a palavra-chave **default** na instrução export para substituir a tabela exportada por qualquer coisa. 2568Usar a palavra-chave **default** na instrução export para substituir a tabela exportada por qualquer coisa.
@@ -5055,16 +2573,6 @@ export default ->
5055 123 2573 123
5056``` 2574```
5057 2575
5058<YueDisplay>
5059
5060```yue
5061export default ->
5062 print "hello"
5063 123
5064```
5065
5066</YueDisplay>
5067
5068# Licença: MIT 2576# Licença: MIT
5069 2577
5070Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\> 2578Copyright (c) 2017-2026 Li Jin \<dragon-fly@qq.com\>
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2026-08-28 02:00:37 +0000