Anonymous avatar Anonymous committed f8ba60c Draft

The new nomenclature on the manual

Comments (0)

Files changed (5)

src/doc/_translation/ja/characteristics.po

 msgstr ""
 "Project-Id-Version: Kink Programming Language 0.1 (devel)\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2013-09-28 17:54\n"
+"POT-Creation-Date: 2013-10-21 23:03\n"
 "PO-Revision-Date: 2012-12-02 11:18\n"
 "Last-Translator: Automatically generated\n"
 "Language-Team: none\n"
 # 68aa935547094280a46ebb955c8a0071
 #: ../../../../src/doc/characteristics.rst:45
 msgid ""
-"You can make ``Dog_`` value which has ``bark`` function and ``howl`` "
-"function without making a class."
+"You can make ``Dog`` value which has ``bark`` function and ``howl`` function "
+"without making a class."
 msgstr ""
-"次の例では、 ``bark`` 関数と ``howl`` 関数を持つ ``Dog_`` という値を、クラス無"
-"しで作っています。"
+"次の例では、 ``bark`` 関数と ``howl`` 関数を持つ ``Dog`` という値を、クラス"
+"無しで作っています。"
 
 # bc3328894eaf4cf080e3362b2afb6cd8
 #: ../../../../src/doc/characteristics.rst:54
 msgid ""
-"You can make a variant of ``Dog_`` by making a child. A child inherits its "
+"You can make a variant of ``Dog`` by making a child. A child inherits its "
 "variables from the parent."
 msgstr ""
-"``Dog_`` の変種を作るには、子供を作ります。子供は親から変数を継承します。"
+"``Dog`` の変種を作るには、子供を作ります。子供は親から変数を継承します。"
 
 # 1fbca340674c46918b8efde2f98d2008
 #: ../../../../src/doc/characteristics.rst:64
 #: ../../../../src/doc/characteristics.rst:151
 msgid ""
 "In Kink, operators are syntax sugar for other expressions, such as function "
-"calls. Assignment is no exception. ``:Num_ = 42`` is simply read as ``:Num_."
+"calls. Assignment is no exception. ``:Num = 42`` is simply read as ``:Num."
 "op_set(42)``, hence it calls ``op_set`` function of a variable reference ``:"
-"Num_``."
+"Num``."
 msgstr ""
 "Kink の演算子は、関数呼び出しなど他の式の構文糖です。代入も例外ではありませ"
-"ん。 ``:Num_ = 42`` は単に ``:Num_.op_set(42)`` と解釈され、変数参照 ``:"
-"Num_`` の ``op_set`` 関数が呼び出されます。"
+"ん。 ``:Num = 42`` は単に ``:Num.op_set(42)`` と解釈され、変数参照 ``:"
+"Num`` の ``op_set`` 関数が呼び出されます。"
 
 # ca5bbac820b049a8b7bdf8c3bf5da145
 #: ../../../../src/doc/characteristics.rst:157

src/doc/characteristics.rst

 
 ::
 
-    :double = { (:Num_) Num_ * 2 }
+    :double = { (:Num) Num * 2 }
 
 Let's call the function.
 
 
 ::
 
-    :Doubles_ = [10 20 30].map($double)
-    printline(Doubles_) # => [20 40 60]
+    :Doubles = [10 20 30].map($double)
+    printline(Doubles) # => [20 40 60]
 
 "Pseudo" means that the language is not purely functional,
 since variables can be set multiple times in a Kink program.
 A value inherits variables from its parent.
 This type of object system is called "prototype-based."
 
-You can make ``Dog_`` value which has ``bark`` function and ``howl`` function
+You can make ``Dog`` value which has ``bark`` function and ``howl`` function
 without making a class.
 
 ::
 
-    :Dog_ = value('bark' { 'Bow' } 'howl' { 'Wow' })
-    printline(Dog_.bark) # => Bow
-    printline(Dog_.howl) # => Wow
+    :Dog = value('bark' { 'Bow' } 'howl' { 'Wow' })
+    printline(Dog.bark) # => Bow
+    printline(Dog.howl) # => Wow
 
-You can make a variant of ``Dog_`` by making a child.
+You can make a variant of ``Dog`` by making a child.
 A child inherits its variables from the parent.
 
 ::
 
-    :Puppy_ = Dog_.child
-    Puppy_.:bark = { 'Yelp' }
-    printline(Puppy_.bark) # => Yelp
-    printline(Puppy_.howl) # => Wow
+    :Puppy = Dog.child
+    Puppy.:bark = { 'Yelp' }
+    printline(Puppy.bark) # => Yelp
+    printline(Puppy.howl) # => Wow
 
 Prototype-based inheritance is used in various ways, such as:
 
 ::
 
     use('java.lang.Thread')
-    :Thread_ = Thread.new {
+    :Tick_thread = Thread.new {
         { true } .loop {
             printline('Tick!')
             Thread.sleep(1000)
         }
     }
-    Thread_.start
+    Tick_thread.start
     # => Tick!
     # => Tick!
     # => Tick!
 ::
 
     use('SET')
-    :Yokozuna_ = SET.set('Takanohana' 'Asashoryu' 'Hakuho')
-    printline(Yokozuna_) # => set('Asashoryu' 'Takanohana' 'Hakuho')
+    :Yokozuna = SET.set('Takanohana' 'Asashoryu' 'Hakuho')
+    printline(Yokozuna) # => set('Asashoryu' 'Takanohana' 'Hakuho')
 
 In this example, you have to put the second argument ``-10`` in parentheses
 to prevent the parser from reading the arguments as ``0 - 10``.
 
 ::
 
-    :List_ = ['Twift' 'Voxxx' 'Olv']
-    { List_.any? } .loop {
-        printline(List_.pop)
+    :List = ['Twift' 'Voxxx' 'Olv']
+    { List.any? } .loop {
+        printline(List.pop)
     }
     # => Olv
     # => Voxxx
 
 ::
 
-    :Fee_ = (Age_ < 12).then { Child_fee } { Adult_fee }
+    :Fee = (Age < 12).then { Child_fee } { Adult_fee }
 
 Assignment by function calls
 ============================
 In Kink, operators are syntax sugar for other expressions,
 such as function calls.
 Assignment is no exception.
-``:Num_ = 42`` is simply read as ``:Num_.op_set(42)``,
-hence it calls ``op_set`` function of a variable reference ``:Num_``.
+``:Num = 42`` is simply read as ``:Num.op_set(42)``,
+hence it calls ``op_set`` function of a variable reference ``:Num``.
 
 You can set multiple variables at once using ``=`` operator.
 It is performed by ``op_set`` function of a list
 
 ::
 
-    :Line_ = "127.0.0.1\tlocalhost"
-    [:Ip_address :Host_name] = Line_ / "\t"
+    :Line = "127.0.0.1\tlocalhost"
+    [:Ip_address :Host_name] = Line / "\t"
     printline(Ip_address)  # => 127.0.0.1
     printline(Host_name)   # => localhost
 
 
 ::
 
-    :countdown = { (:Num_)
-        printline(Num_)
-        (Num_ > 0).then { countdown(Num_ - 1) }
+    :countdown = { (:Num)
+        printline(Num)
+        (Num > 0).then { countdown(Num - 1) }
     }
     countdown(100)
     # => 100
 
 ::
 
-    :initial = { (:String_)
-        String_.switch(
+    :initial = { (:Str)
+        Str.switch(
             %'#(.*)' { (:Match_result)
                 in_comment(Match_result.group(1))
             }
         )
     }
 
-    :in_comment = { (:String_)
-        String_.switch(
+    :in_comment = { (:Str)
+        Str.switch(
             %'\n.*' {
-                initial(String_)
+                initial(Str)
             }
             %'.(.*)' { (:Match_result)
                 in_comment(Match_result.group(1))
         )
     }
 
-    :Input_ = "Takanohana # 65th\n" + "Asashoryu # 68th\n" + "Hakuho # 69th\n"
-    initial(Input_)
+    :Input = "Takanohana # 65th\n" + "Asashoryu # 68th\n" + "Hakuho # 69th\n"
+    initial(Input)
     # => Takanohana
     # => Asashoryu
     # => Hakuho

src/doc/language/core.rst

 
     'Twift'
     42
-    { (:Num_) Num_ * 2 }
+    { (:Num) Num * 2 }
 
 Basic components of values
 --------------------------
 
 ::
 
-    # Make a value which represents an account, with variables "Balance_" and "balance".
-    :Account_ = value
-    Account_.:Balance_ = 0
-    Account_.:balance = { > :A_
-        A_.Balance_
+    # Make a value which represents an account, with variables "Balance" and "balance".
+    :Account = value
+    Account.:Balance = 0
+    Account.:balance = { > :A
+        A.Balance
     }
 
-    # Make a child of the account value, overriding "Balance_" variable.
-    :Bank_account = Account_.child
-    Bank_account.:Balance_ = 42
+    # Make a child of the account value, overriding "Balance" variable.
+    :Bank_account = Account.child
+    Bank_account.:Balance = 42
 
     # Call a function stored in "balance" variable for the values.
-    printline(Account_.balance)      # => 0
+    printline(Account.balance)      # => 0
     printline(Bank_account.balance)  # => 42
 
 The relationship of values in the program can be represented
     digraph values {
         graph [size = "6, 6"];
         node [shape = box];
-        "Environment" -> "Account" [label = "variable\n\"Account_\""];
+        "Environment" -> "Account" [label = "variable\n\"Account\""];
         "Environment" -> "Bank Account" [label = "variable\n\"Bank_account\""];
-        "Bank Account" -> "42" [label = "variable\n\"Balance_\""];
+        "Bank Account" -> "42" [label = "variable\n\"Balance\""];
         "Bank Account" -> Account [label = "parent", style = "dashed"];
-        Account -> "Function\n{ > :A_ A_.Balance_ }" [label = "variable\n\"balance\""];
-        Account -> "0" [label = "variable\n\"Balance_\""];
+        Account -> "Function\n{ > :A A.Balance }" [label = "variable\n\"balance\""];
+        Account -> "0" [label = "variable\n\"Balance\""];
         Account -> base [label = "parent", style = "dashed"];
         "0" -> java0 [label = "boxed", style = "dotted"];
         java0 [shape = ellipse, label = "java.lang.Integer 0"];
 
 Nouns and verbs are not distinguished in the semantics,
 but dealt differently in the syntax.
-You can dereference a variable with a noun ``Data_`` for example ``Owner_.Data_``.
-And you can dereference a variable with a verb ``fun`` prefixing "$" for example ``Owner_.$fun``.
+You can dereference a variable with a noun ``Data`` for example ``Owner.Data``.
+And you can dereference a variable with a verb ``fun`` prefixing "$" for example ``Owner.$fun``.
 If "$" is not prefixed to a verb, it calls a function within the variable.
 Here is an example.
 
 ::
 
-    :Owner_ = value
-    Owner_.:Data_ = 42
-    Owner_.:fun = { 'Voxxx' }
+    :Owner = value
+    Owner.:Data = 42
+    Owner.:fun = { 'Voxxx' }
 
-    printline(Owner_.Data_)  # => 42
-    printline(Owner_.$fun)  # => { 'Voxxx' }
-    printline(Owner_.fun)   # => Voxxx
+    printline(Owner.Data)  # => 42
+    printline(Owner.$fun)  # => { 'Voxxx' }
+    printline(Owner.fun)   # => Voxxx
 
 By that distinction in the syntax, programmers are encouraged to use nouns for mere data,
 and verbs for functions, although it is not mandatory.
 
 A variable reference can be created by
 a :token:`variable reference expression <var_reference>`.
-For example, this expression creates a reference of a variable ``Data_``,
-whoes owner is ``Owner_``.
+For example, this expression creates a reference of a variable ``Data``,
+whoes owner is ``Owner``.
 
 ::
 
-    Owner_.:Data_
+    Owner.:Data
 
 This expression creates a reference of a variable ``fun``,
-whoes owner is ``Owner_``.
+whoes owner is ``Owner``.
 
 ::
 
-    Owner_.:fun
+    Owner.:fun
 
 There is no distinction between nouns and verbs in variable reference expressions.
 
 
 For example, this program
 
-1. assigns a number 42 to a local variable ``Num_``,
-2. assigns a function which prints out ``Num_`` to a local variable ``printnum``,
+1. assigns a number 42 to a local variable ``Num``,
+2. assigns a function which prints out ``Num`` to a local variable ``printnum``,
 3. calls a function within the local variable ``printnum``, and
 4. prints out the function itself.
 
 ::
 
-    :Num_ = 42
-    :printnum = { printline(Num_) }
+    :Num = 42
+    :printnum = { printline(Num) }
 
     printnum              # => 42
-    printline($printnum)  # => { printline(Num_) }
+    printline($printnum)  # => { printline(Num) }
 
 The program above is equivalent to the program below,
 because ``\env`` is evaluated
 
 ::
 
-    \env.:Num_ = 42
-    \env.:printnum = { \env.printline(\env.Num_) }
+    \env.:Num = 42
+    \env.:printnum = { \env.printline(\env.Num) }
 
     \env.printnum                   # => 42
-    \env.printline(\env.$printnum)  # => { \env.printline(\env.Num_) }
+    \env.printline(\env.$printnum)  # => { \env.printline(\env.Num) }
 
 .. _language-core-cru-variable:
 
 For example, the next program does assignment and dereferencing as follows.
 
 1. Assigns a value to
-   the :ref:`local variable <language-core-local-variable>` ``Window_``.
-2. Creates a variable ``Theme_`` of a value ``Window_``
+   the :ref:`local variable <language-core-local-variable>` ``Window``.
+2. Creates a variable ``Theme`` of a value ``Window``
    with a string "Dark" as an initial target.
 3. Dereferences the variable and prints out the target.
    "Dark" is printed out.
 ::
 
     # 1
-    :Window_ = value
+    :Window = value
     # 2
-    Window_.:Theme_ = 'Dark'
+    Window.:Theme = 'Dark'
     # 3
-    printline(Window_.Theme_)  # => Dark
+    printline(Window.Theme)  # => Dark
     # 4
-    Window_.:Theme_ = 'Light'
+    Window.:Theme = 'Light'
     # 5
-    printline(Window_.Theme_)  # => Light
+    printline(Window.Theme)  # => Light
 
 .. _language-core-dereference:
 
 
 ::
 
-    :WINDOW_PROTO = value
-    :APP_WINDOW_PROTO = WINDOW_PROTO.child
-    :Browser_ = APP_WINDOW_PROTO.child
-    :Editor_ = APP_WINDOW_PROTO.child
-    :Tooltip_ = WINDOW_PROTO.child
-    WINDOW_PROTO.:Theme_ = 'Dark'
-    Browser_.:Theme_ = 'Light'
+    :Window_proto = value
+    :App_window_proto = Window_proto.child
+    :Browser = App_window_proto.child
+    :Editor = App_window_proto.child
+    :Tooltip = Window_proto.child
+    Window_proto.:Theme = 'Dark'
+    Browser.:Theme = 'Light'
 
     # 1
-    printline(Browser_.Theme_)  # => Light
+    printline(Browser.Theme)  # => Light
     # 2
-    printline(Editor_.Theme_)   # => Dark
+    printline(Editor.Theme)   # => Dark
     # 3
-    printline(Tooltip_.Theme_)  # => Dark
+    printline(Tooltip.Theme)  # => Dark
 
 The beginning part of the program constructs these values and variables.
 
 
     graph [size = 4];
     node [shape = box];
-    tooltip [label = "Tooltip_"];
-    editor [label = "Editor_"];
-    browser [label = "Browser_"];
-    app_window_proto [label = "APP_WINDOW_PROTO"];
-    window_proto [label = "WINDOW_PROTO"];
+    tooltip [label = "Tooltip"];
+    editor [label = "Editor"];
+    browser [label = "Browser"];
+    app_window_proto [label = "App_window_proto"];
+    window_proto [label = "Window_proto"];
     subgraph cluster_tehems {
         style = "invis";
         dark_theme [label = "'Dark'"];
     app_window_proto -> window_proto [label = "parent", style = "dashed"];
     editor -> app_window_proto [label = "parent", style = "dashed"];
     browser -> app_window_proto [label = "parent", style = "dashed"];
-    window_proto -> dark_theme [label = "variable\n\"Theme_\""];
-    browser -> light_theme [label = "variable\n\"Theme_\""];
+    window_proto -> dark_theme [label = "variable\n\"Theme\""];
+    browser -> light_theme [label = "variable\n\"Theme\""];
 
 In that case, dereferencing 1, 2 and 3 is done as follows.
 
-1.  *Browser_* owns ``Theme_`` variable and its target is a string "Light".
-    Therefore, the result of ``Browser_.Theme_`` is "Light".
-2.  *WINDOW_PROTO* is the nearest super value of *Editor_*
-    which owns a variable with the symbol ``Theme_``.
-    Hence, the result of ``Editor_.Theme_`` is the string "Dark",
-    which is the target of ``Theme_`` variable of ``WINDOW_PROTO``.
-3.  *WINDOW_PROTO* is the nearest super value of *Tooltip_*
-    which owns a variable with the symbol ``Theme_``.
-    Hence, the result of ``Tooltip_.Theme_`` is the string "Dark",
-    which is the target of ``Theme_`` variable of *WINDOW_PROTO*.
+1.  *Browser* owns ``Theme`` variable and its target is a string "Light".
+    Therefore, the result of ``Browser.Theme`` is "Light".
+2.  *Window_proto* is the nearest super value of *Editor*
+    which owns a variable with the symbol ``Theme``.
+    Hence, the result of ``Editor.Theme`` is the string "Dark",
+    which is the target of ``Theme`` variable of ``Window_proto``.
+3.  *Window_proto* is the nearest super value of *Tooltip*
+    which owns a variable with the symbol ``Theme``.
+    Hence, the result of ``Tooltip.Theme`` is the string "Dark",
+    which is the target of ``Theme`` variable of *Window_proto*.
 
 The next program dereferences ``No_such_variable`` variable,
 which does not exist.
 
 ::
 
-    :Owner_ = value
-    Owner_.No_such_variable
+    :Owner = value
+    Owner.No_such_variable
 
 When the program is executed,
 an exception is thrown by the dereferencing and these error message is printed out.
 
 .. code-block:: none
 
-    [(stdin):2] Owner_.==>No_such_variable
+    [(stdin):2] Owner.==>No_such_variable
     No variable 'No_such_variable' in <value:hash=27219843>
 
 .. _language-core-varmissing:
 Therefore, in most cases, it is better to define ``extend_base_varmissing`` instead of ``varmissing`` directly.
 
 In this example,
-``extend_base_varmissing`` finds an alternative value for the map ``_alternatives``.
+``extend_base_varmissing`` finds an alternative value for the map ``Alternatives``.
 If the alternative value is not found,
 it returns an empty list to indicate the absence of the alternative value.
 
 
     use('MAP')
 
-    :Value_ = value
-    Value_.:Alternatives_ = MAP.map('Num_' 42)
-    Value_.:extend_base_varmissing = { > :Me_ (:Symbol_)
-        Me_.Alternatives_.haskey?(Symbol_).then {
-            [Me_.Alternatives_.get(Symbol_)]
+    :Value = value
+    Value.:Alternatives = MAP.map('Num' 42)
+    Value.:extend_base_varmissing = { > :Me (:Symbol)
+        Me.Alternatives.haskey?(Symbol).then {
+            [Me.Alternatives.get(Symbol)]
         } {
             []
         }
     }
 
-    printline(Value_.Num_)  # => 42
-    printline(Value_.Str_)  # => No variable 'Str_' in <value:hash=2765>
+    printline(Value.Num)  # => 42
+    printline(Value.Str)  # => No variable 'Str' in <value:hash=2765>
 
 .. note::
 
 Lexical scoping of local variabiles works depending that behavior of environments.
 
 Look at the example below.
-``Str_`` variable at the top level can be dereferenced in ``fun`` function.
-Assignment to ``Str_`` variable in ``fun`` function
+``Str`` variable at the top level can be dereferenced in ``fun`` function.
+Assignment to ``Str`` variable in ``fun`` function
 does not affect the variable at the top level,
 because the assignment is done for the environment of the call of ``fun`` function.
 
 ::
 
     :fun = {
-        printline(Str_)
-        :Str_ = 'Changed!'
-        printline(Str_)
+        printline(Str)
+        :Str = 'Changed!'
+        printline(Str)
     }
-    :Str_ = 'Original'
+    :Str = 'Original'
 
-    printline(Str_)
+    printline(Str)
     # => Original
 
     fun
     # => Original
     # => Changed!
 
-    printline(Str_)
+    printline(Str)
     # => Original
 
 In a Kink function, the passed receiver can be acquired
 or :ref:`\\0, \\1, \\2, ... <language-syntax-indexed-actual-argument>`
 
 In the next example, ``fun`` function prints out
-the target of ``Name_`` variable of the passed receiver,
+the target of ``Name`` variable of the passed receiver,
 and the passed arguments.
 
 ::
 
-    :Value_ = value
-    Value_.:Name_ = 'Value'
-    Value_.:fun = {
+    :Value = value
+    Value.:Name = 'Value'
+    Value.:fun = {
         printline(
-            'Name: ' + \recv.Name_
+            'Name: ' + \recv.Name
             + '  Args: ' + \args
         )
     }
-    Value_.fun('Voxxx' 'Twift')
+    Value.fun('Voxxx' 'Twift')
     # => Name: Value  Args: ['Voxxx' 'Twift']
 
-    :Child_ = Value_.child
-    Child_.:Name_ = 'Child'
-    Child_.fun('Peng!')
+    :Child = Value.child
+    Child.:Name = 'Child'
+    Child.fun('Peng!')
     # => Name: Child  Args: ['Peng!']
 
 Usually, a receiver and arguments are stored to local variables
 using syntax sugar of :ref:`function expressions <language-syntax-fun>`.
-For example, ``fun`` function in the next program stores a receiver to ``Me_`` variable,
-and arguments to ``X_``, ``Y_``, and ``Z_`` variables.
+For example, ``fun`` function in the next program stores a receiver to ``Me`` variable,
+and arguments to ``X``, ``Y``, and ``Z`` variables.
 
 ::
 
-    :Value_ = value
-    Value_.:Name_ = 'Value'
-    Value_.:fun = { > :Me_ (:X_ :Y_ :Z_)
-        printline(Me_.Name_)
-        printline(X_)
-        printline(Y_)
-        printline(Z_)
+    :Value = value
+    Value.:Name = 'Value'
+    Value.:fun = { > :Me (:X :Y :Z)
+        printline(Me.Name)
+        printline(X)
+        printline(Y)
+        printline(Z)
     }
-    Value_.fun(10 20 30)
+    Value.fun(10 20 30)
     # => Value
     # => 10
     # => 20
 
     :try_and_report = { (:fun)
         $fun.try.switch(
-            [true :Result_] {
-                printline('SUCCESS: ' + Result_)
+            [true :Result] {
+                printline('SUCCESS: ' + Result)
             }
-            [false :Exception_] {
-                printline('FAILURE: ' + Exception_.message)
+            [false :Exception] {
+                printline('FAILURE: ' + Exception.message)
             }
         )
     }

src/doc/language/lexical.rst

 ::
 
     # All expressions in one line
-    :Num_ = ARGV.first.int  :Result_ = Num_ * 3  printline(Result_)
+    :Num = ARGV.first.int  :Result = Num * 3  printline(Result)
 
     # Separate expressions by line feed characters
-    :Num_ = ARGV.first.int
-    :Result_ = Num_ * 3
-    printline(Result_)
+    :Num = ARGV.first.int
+    :Result = Num * 3
+    printline(Result)
 
 Each of following marks may have a different meaning
 if located after whitespace characters or line feed.

src/doc/language/syntax.rst

 ::
 
     voxxx
-    :Twift_
-    Peng_
+    :Twift
+    Peng
 
 The program above is equivalent to the program blow.
 
 ::
 
     \env.voxxx
-    \env.:Twift_
-    \env.Peng_
+    \env.:Twift
+    \env.Peng
 
 .. _language-syntax-actual-receiver:
 
 
 ::
 
-    :Parent_ = value(
+    :Parent = value(
         'string' { 'parent' }
         'printreceiver' {
             printline(\recv)
         }
     )
 
-    :Child_ = Parent_.child('string' { 'child' })
+    :Child = Parent.child('string' { 'child' })
 
-    Parent_.printreceiver # => parent
-    Child_.printreceiver  # => child
+    Parent.printreceiver # => parent
+    Child.printreceiver  # => child
 
 .. _language-syntax-actual-arguments:
 
 
 ::
 
-    :List_ = ['voxxx' 'twift' 'peng']
-    printline(List_)  # => ['voxxx' 'twift' 'peng']
+    :List = ['voxxx' 'twift' 'peng']
+    printline(List)  # => ['voxxx' 'twift' 'peng']
 
 In this example, the list expression on the second line expands
-a list stored in ``Sub_`` variable.
+a list stored in ``Sub`` variable.
 
 ::
 
-    :Sub_ = [1 2 3]
-    :List_ = ['ping' *** Sub_ 'pong']
-    printline(List_)  # => ['ping' 1 2 3 'pong']
+    :Sub = [1 2 3]
+    :List = ['ping' *** Sub 'pong']
+    printline(List)  # => ['ping' 1 2 3 'pong']
 
 .. _language-syntax-fun:
 
 A :dfn:`formal receiver` is a part to store the current receiver \\recv in a variable or something.
 A formal receiver can assume either of these forms.
 
-1. ``>`` and an :token:`expression`, such as ``> :Self_``. It is reduced to a function call of ``op_set``,
+1. ``>`` and an :token:`expression`, such as ``> :Self``. It is reduced to a function call of ``op_set``,
    the receiver of which is the expression, and the only argument of which is the current receiver \\recv.
-   For example, ``> :Self_`` is reduced to ``:Self_ = \recv``.
+   For example, ``> :Self`` is reduced to ``:Self = \recv``.
 2. Empty, which is reduced to an empty chunk. Thus it does nothing.
 
 A :dfn:`formal arguments` is a part to store the arguments in variables or somethings.
 A formal arguments can assume either of these forms.
 
-1.  ``(``, an :token:`series of elements producers <elements_producers_series>` and ``)``, such as ``(:X_ :Y_ :Z_)``.
+1.  ``(``, an :token:`series of elements producers <elements_producers_series>` and ``)``, such as ``(:X :Y :Z)``.
     It is reduced to a function call of ``op_set``,
     the receiver of which is a list expression is reduced to from the elements producers,
     the only argument of which is the arguments passed to the current function call, \\args.
-    For example, ``(:X_ :Y_ :Z_)`` is reduced to ``[:X_ :Y_ :Z_] = \args``.
+    For example, ``(:X :Y :Z)`` is reduced to ``[:X :Y :Z] = \args``.
 
     There cannot be any line feed characters between the opening parenthesis ``(``
     and the previous token.
     If there is, the part from the opening parenthesis ``(`` to the closing parenthesis ``)`` are
     regarded as an independent :ref:`parentheses expression <language-syntax-paren>`.
 
-2.  ``(``, ``*``, an :token:`expression` and ``)``, such as ``(* :Args_)``.
+2.  ``(``, ``*``, an :token:`expression` and ``)``, such as ``(* :Args)``.
     It is reduced to a function call of ``op_set``, the receiver of which is the expression,
     the only argument of which is the arguments passed to the current function call, \\args.
-    For example, ``(* :Args_)`` is reduced to ``:Args_ = \args``.
+    For example, ``(* :Args)`` is reduced to ``:Args = \args``.
 
     There cannot be any line feed characters between the opening parenthesis ``(``
     and the previous token.
 
 ::
 
-    :fun1 = { > :Self_ (:X_ :Y_ :Z_)
+    :fun1 = { > :Self (:X :Y :Z)
         'result'
     }
 
     :fun2 = {
-        :Self_ = \recv
-        [:X_ :Y_ :Z_] = \args
+        :Self = \recv
+        [:X :Y :Z] = \args
         'result'
     }
 
 
 ::
 
-    :fun = { (:X_ :Y_ = 100 :Z_ = 200)
-        printline([X_ Y_ Z_])
+    :fun = { (:X :Y = 100 :Z = 200)
+        printline([X Y Z])
     }
 
     fun('x' 'y' 'z')  # => ['x' 'y' 'z']
     fun('x' 'y')      # => ['x' 'y' 200]
     fun('x')          # => ['x' 100 200]
-    fun               # => No variable 'X_' in <env:#of='(stdin)':hash=11401772>...
+    fun               # => No variable 'X' in <env:#of='(stdin)':hash=11401772>...
 
 You can store whole arguments in a variable using ``(* ...)`` syntax.
 
 ::
 
-    :fun = { (* :Args_)
-        printline(Args_)
+    :fun = { (* :Args)
+        printline(Args)
     }
 
     fun(10 20 30)  # => [10 20 30]
 and produces it as the result of the variable dereference expression.
 
 In this example, owners are not explicitly specified for variable dereference expressions
-of variables named (1) ``Num_`` and (2) ``fun``,
+of variables named (1) ``Num`` and (2) ``fun``,
 therefore the variables of \\env are dereferenced.
 
 ::
 
-    :Num_ = 42
+    :Num = 42
     # (1)
-    printline(Num_)   # => 42
+    printline(Num)   # => 42
 
     :fun = { do_something }
     # (2)
     printline($fun)  # => { do_something }
 
 In this example,
-variables named (1) ``Num_`` and (2) ``fun`` owned by the value stored in ``Owner_``
+variables named (1) ``Num`` and (2) ``fun`` owned by the value stored in ``Owner``
 are dereferenced.
 
 ::
 
-    :Owner_ = value
+    :Owner = value
 
-    Owner_.:Num_ = 42
+    Owner.:Num = 42
     # (1)
-    printline(Owner_.Num_)   # => 42
+    printline(Owner.Num)   # => 42
 
-    Owner_.:fun = { do_something }
+    Owner.:fun = { do_something }
     # (2)
-    printline(Owner_.$fun)   # => { do_something }
+    printline(Owner.$fun)   # => { do_something }
 
 Variable reference expressions
 ==============================
 as the result of the variable reference expression.
 
 In this example,
-references of variables named (1) ``Num_`` and (2) ``fun`` owned by \\env are produced.
+references of variables named (1) ``Num`` and (2) ``fun`` owned by \\env are produced.
 
 ::
 
     # (1)
-    :Num_ = 42
-    printline(Num_)   # => 42
+    :Num = 42
+    printline(Num)   # => 42
 
     # (2)
     :fun = { do_something }
     printline($fun)  # => { do_something }
 
 In this example,
-references of variables named (1) ``Num_`` and (2) ``fun`` owned by the value stored in ``Owner_``
+references of variables named (1) ``Num`` and (2) ``fun`` owned by the value stored in ``Owner``
 are produced.
 
 ::
 
-    :Owner_ = value
+    :Owner = value
 
     # (1)
-    Owner_.:Num_ = 42
-    printline(Owner_.Num_)   # => 42
+    Owner.:Num = 42
+    printline(Owner.Num)   # => 42
 
     # (2)
-    Owner_.:fun = { do_something }
-    printline(Owner_.$fun)   # => { do_something }
+    Owner.:fun = { do_something }
+    printline(Owner.$fun)   # => { do_something }
 
 .. _language-syntax-call:
 
 The runtime evaluates the receiver and the actual arguments in the order they occured in the program,
 and :ref:`calls a function by the verb symbol <language-core-call-by-symbol>`.
 
-In this example, ``fun`` function is called with the receiver stored in ``Recv_`` variable,
+In this example, ``fun`` function is called with the receiver stored in ``Recv`` variable,
 and the strings "ping" and "pong" as the arguments.
 
 ::
 
-    :Recv_ = value
-    Recv_.:show = { 'Recv_' }
-    Recv_.:fun = {
+    :Recv = value
+    Recv.:show = { 'Recv' }
+    Recv.:fun = {
         printline('Receiver: ' + \recv + '  Arguments: ' + \args)
     }
 
-    Recv_.fun('ping' 'pong')   # => Receiver: Recv_  Arguments: ['ping' 'pong']
+    Recv.fun('ping' 'pong')   # => Receiver: Recv  Arguments: ['ping' 'pong']
 
 In this example, the receiver is omitted therefore the current local environment is used as the receiver.
 
 
 ::
 
-    :Num_ = 42
-    printline(Num_)  # => 42
+    :Num = 42
+    printline(Num)  # => 42
 
-    :Num_ *= 2
-    printline(Num_)  # => 84
+    :Num *= 2
+    printline(Num)  # => 84
 
-    [:X_ :Y_ :Z_] = ['voxxx' 'twift' 'peng']
-    printline([X_ Y_ Z_])  # => ['voxxx' 'twift' 'peng']
+    [:X :Y :Z] = ['voxxx' 'twift' 'peng']
+    printline([X Y Z])  # => ['voxxx' 'twift' 'peng']
 
 Note that right-hand-side values of ``||=`` and ``&&=`` are body chunks of functions in reduced forms.
 Therefore, values of pseudo variables such as \\env, \\args and \\0
 ::
 
     :fun = {
-        :Bool_ = false
-        :Bool_ ||= \0
-        printline(Bool_)
+        :Bool = false
+        :Bool ||= \0
+        printline(Bool)
     }
     fun(true)  # => Wrong index 0 for 0..<0
 
-The reason is that ``:Bool_ ||= \0`` is reduced to ``:Bool_.op_logor_set { \0 }``
+The reason is that ``:Bool ||= \0`` is reduced to ``:Bool.op_logor_set { \0 }``
 and thus \\0 means the first argument of the function ``{ \0 }`` here,
 not of ``fun``.
 
 
 ::
 
-    :fun = { (:Arg_)
-        :Bool_ = false
-        :Bool_ ||= Arg_
-        printline(Bool_)
+    :fun = { (:Arg)
+        :Bool = false
+        :Bool ||= Arg
+        printline(Bool)
     }
     fun(true)  # => true
 
 
 ::
 
-    :positive_even? = { (:Num_)
-        Num_ > 0 && Num_ % 2 == 0
+    :positive_even? = { (:Num)
+        Num > 0 && Num % 2 == 0
     }
     printline(positive_even?(10))  # => true
 
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.