Permalink
Browse files

Merge pull request #89 from Tovim/master

DOCS: Docs-cs latest translations
  • Loading branch information...
greggirwin committed Sep 19, 2018
2 parents 60dc40b + 8d60c09 commit 89a5e65134ec706064f0b68b27e1886318fe6888
Showing with 714 additions and 3 deletions.
  1. +3 −0 cs/SUMMARY.adoc
  2. +5 −2 cs/datatypes.adoc
  3. +26 −0 cs/datatypes/block.adoc
  4. +1 −1 cs/datatypes/date.adoc
  5. +190 −0 cs/datatypes/error.adoc
  6. +81 −0 cs/datatypes/percent.adoc
  7. +336 −0 cs/datatypes/time.adoc
  8. +72 −0 cs/vid.adoc
View
@@ -6,6 +6,7 @@
.. link:datatypes/block.adoc[Datový typ block!]
.. link:datatypes/date.adoc[Datový typ date!]
.. link:datatypes/email.adoc[Datový typ email!]
.. link:datatypes/erorr.adoc[Datový typ erorr!]
.. link:datatypes/file.adoc[Datový typ file!]
.. link:datatypes/float.adoc[Datový typ float!]
.. link:datatypes/get-path.adoc[Datový typ get-path!]
@@ -23,11 +24,13 @@
.. link:datatypes/pair.adoc[Datový typ pair!]
.. link:datatypes/paren.adoc[Datový typ paren!]
.. link:datatypes/path.adoc[Datový typ path!]
.. link:datatypes/percent.adoc[Datový typ percent!]
.. link:datatypes/refinement.adoc[Datový typ refinement!]
.. link:datatypes/set-path.adoc[Datový typ set-path!]
.. link:datatypes/set-word.adoc[Datový typ set-word!]
.. link:datatypes/string.adoc[Datový typ string!]
.. link:datatypes/tag.adoc[Datový typ tag!]
.. link:datatypes/time.adoc[Datový typ time!]
.. link:datatypes/tuple.adoc[Datový typ tuple!]
.. link:datatypes/unset.adoc[Datový typ unset!]
.. link:datatypes/url.adoc[Datový typ url!]
View
@@ -10,6 +10,7 @@ _This is a work in progress, only some of the datatypes are currently documented
```red
action!
binary!
bitset!
block!
char!
@@ -30,15 +31,17 @@ _This is a work in progress, only some of the datatypes are currently documented
issue!
lit-path!
lit-word!
logic!
logic!
map!
native!
none!
object!
op!
paren!
pair!
path!
point!
percent!
point!
refinement!
routine!
set-path!
View
@@ -99,6 +99,32 @@ Ok: `[42 print "foo"]`
Not ok: `[42 pr int "foo"]`
== Přístup k prvkům bloku
Elementy bloku jsou přístupné prostřednictvím lomítka a indexem elementu:
----
>> b: [12 34 56]
== [12 34 56]
>> b/1
== 12
----
Blok lze rovněž používat jako uložiště dvojic key/value:
----
>> b: [x 12 y 34]
== [x 12 y 34]
>> b/x
== 12
>> b/y
== 34
----
== Komparace
View
@@ -204,7 +204,7 @@ make date! [99 12 31]
== Přístup ve formátu cesty
Přístup ve formátu cesty (path accessor) poskytuje vhodný způsob získání či zadání všech polí hodoty `date!`.
Přístup ve formátu `path!` (path accessor) poskytuje vhodný způsob získání či zadání všech polí hodoty `date!`.
=== /date
View
@@ -0,0 +1,190 @@
= Datový typ error!
:numbered:
== Úvodem
Hodnoty `error!` reprezentují specielní hodnoty entity `object!`, používané při výskytu chyby. Hodnoty typu error! obsahují pevný počet slov (polí), definovaných v `system/standard/error`.
```red
SYSTEM/STANDARD/ERROR je kontejner typu object! s těmito slovy a hodnotami:
code none! none
type none! none
id none! none
arg1 none! none
arg2 none! none
arg3 none! none
near none! none
where none! none
stack none! none
```
Typ `error!` je člen těchto typesetů: `any-object!`, `default!`
== Vytvoření
Hodnoty 'error' mohou být vytvořeny při běhu programu (runtime) použitím `make` nebo `cause-error`.
Je-li zadaným argumentem funkce `make` hodnota typu `integer!`, je error v příslušném seznemu vyhledán podle pole `code`. Chybové hlášení (error message) bude sestaveno z hodnoty `string!` prvního pole `id` v seznamu jmen `id`.
```red
SYSTEM/CATALOG/ERRORS/MATH is an object! with the following words and values:
code integer! 400
type string! "Math Error"
zero-divide string! "attempt to divide by zero"
overflow string! "math or number overflow"
positive string! "positive number required"
>> make error! 400
*** Math Error: attempt to divide by zero ; id is the word zero-divide
*** Where: ???
```
Přístup ke zbývajícím chybovým hlášení se vytvoří inkrementálně zvětšenou hodnotou typu `code`.
```red
>> make error! 401
*** Math Error: math or number overflow
*** Where: ???
>> make error! 402
*** Math Error: positive number required
*** Where: ???
```
Přístup k neexistující pozici rezultuje v chybě "value out of range".
```red
>> make error! 403
*** Script Error: value out of range: 403
*** Where: make
*** Stack:
```
Je-li argumentem zadaným funkci `make` hodota typu `block!`, musí tento blok obsahovat dvě slova, vážící se k polím `type` a `id`.
Je-li argumentem zadaným funkci `make` hodnota typu `object!`, musí být požadovaná pole typu `type` a `id`. Volitelná pole jsou `arg1`, `arg2`, `arg3`, `near`, `where` a `stack`.
Použijte následující slova pro hodnotu typu `type` v chybném objektu.: `throw`,`note`, `syntax`, `script`, `math`, `access`, `user`, `internal`
Identifikaci dostupných typů chyb lze získat zadáním `help system/catalog/errors/<error-type>` do konzoly Redu, kde `<error-type>` je jedno z výše uvedených slov.
```red
>> help system/catalog/errors/throw
SYSTEM/CATALOG/ERRORS/THROW is an object! with the following words and values:
code integer! 0
type string! "Throw Error"
break string! "no loop to break"
return string! "return or exit not in function"
throw block! length: 2 ["no catch for throw:" :arg1]
continue string! "no loop to continue"
while-cond string! {BREAK/CONTINUE cannot be used in WHILE condition block}
```
Použití bloku se dvěmi slovy:
```red
>> make error! [throw type] ; type is the word throw, id is the word type
*** Throw Error: Throw Error
*** Where: ???
>> make error! [throw break] ; type is the word throw, id is the word break
*** Throw Error: no loop to break
*** Where: ???
>> make error! [throw while-cond] ; type is the word throw, id is the word while-cond
*** Throw Error: BREAK/CONTINUE cannot be used in WHILE condition block
*** Where: ???
```
Použití těla objektu:
```red
>> make error! [type: throw Id: throw arg1: "foo"]
*** Throw Error: no catch for throw: "foo"
*** Where: throw
*** Stack:
```
```red
>> make error! [type: 'script id: 'move-bad arg1: "foo" arg2: "bar" where: 'somewhere?]
*** Script Error: Cannot MOVE elements from "foo" to "bar"
*** Where: somewhere?
```
Použití hodnoty `string!`:
Je-li argumentem funkce `make` hodnota typu `string!` value, typem chyby bude `User Error`.
```red
>> foo: make error! "oops"
*** User Error: "oops"
*** Where: ???
```
Použití funkce `cause-error`:
Funkce `cause-error` volá `make error!` s `type`, `id` a blokem hodnot pro `arg1`, `arg2` a `arg3`. Neobsahuje-li chybové hlášení žádné hodnoty `arg`, dosadí se prázdný blok.
```red
>> cause-error 'throw 'break []
*** Throw Error: no loop to break
*** Where: do
*** Stack: cause-error
```
Arg values in the block are reduced.
```red
>> cause-error 'syntax 'missing ['foo 'bar]
*** Syntax Error: missing foo at bar
*** Where: do
*** Stack: cause-error
>> cause-error 'syntax 'missing ["foo" "bar"]
*** Syntax Error: missing "foo" at "bar"
*** Where: do
*** Stack: cause-error
>> cause-error 'syntax 'missing [foo bar]
*** Script Error: foo has no value
*** Where: reduce
*** Stack: cause-error
```
== Literálová skladba
```
<error> ::= make error! <error-spec>
<error-spec> ::= <integer> | <block> | <string>
```
== Testování hodnot
Použijte `error?` k ověření, zda je hodnota typu `error!`.
```red
>> error? foo
== true
```
Použijte `type?` ke zjištění datového typu zadané hodnoty.
```red
>> type? foo
== error!
```
== Předdefinovaná slova
=== Actions
`put`, `select`
=== Functions
`attempt`, `cause-error`
=== Natives
`in`, `try`
View
@@ -0,0 +1,81 @@
= Datový typ percent!
:toc:
:numbered:
== Úvodem
Hodnoty typu `percent!` reprezentují hodnoty typu link:float.adoc[float!], vyjádřené jako procenta.
Typ `percent!` je člen těchto typesetů: `number!`, `scalar!`
== Vytvoření
Hodnoty typu percent! lze vytvořit s použitím literálové syntaxe nebo při běhu programu konstruktorem `make` nebo konverzí `to`.
```red
>> 100%
== 100%
>> 12.2%
== 12.2%
>> .76%
== 0.76%
```
```red
>> make percent! 1
== 100%
>> make percent! .1
== 10%
>> make percent! .01
== 1%
```
```red
>> to percent! 1
== 100%
>> to percent! .1
== 10%
>> to percent! .01
== 1%
```
== Literálová skladba
```
<percent-literal> ::= <integer-literal>% | <float-literal>%
```
== Komparace
Na hodnoty typu `percent!` lze aplikovat všechny komparační operátory: `=, ==, <>, >, <, >=, &lt;=, =?`. Navíc jsou podporovány funkce `min` a `max`.
== Testování hodnot
Použijte `percent?` k ověření, zda je hodnota typu `percent!`.
```red
>> percent? 42%
== true
```
Použijte `type?` ke zjištění datového typu zadané hodnoty.
```red
>> type? 42%
== percent!
```
== Předdefinovaná slova
=== Functions
`percent?`, `to-percent`
Oops, something went wrong.

0 comments on commit 89a5e65

Please sign in to comment.