Commits

Taku Miyakawa committed ed5cb9f

Renames variables for the new Nomenclature

  • Participants
  • Parent commits 3625a5b

Comments (0)

Files changed (140)

File src/build/deleteassertion.kn

 use('java.lang.reflect.Modifier')
 
 :delegatingtrait = {
-    MethodVisitor.getDeclaredMethods.list.select { (:Method_)
-        Modifier.isPublic(Method_.getModifiers) && Method_.getName.startswith?('visit')
-    } .concatmap { (:Method_)
-        :Fun_ = { > :Self_ (* :Args_)
-            (Self_.label == null).then {
-                Self_.mwriter.var(Method_.getName).call(*** Args_)
+    MethodVisitor.getDeclaredMethods.list.select { (:Method)
+        Modifier.isPublic(Method.getModifiers) && Method.getName.startswith?('visit')
+    } .concatmap { (:Method)
+        :Fun = { > :Self (* :Args)
+            (Self.label == null).then {
+                Self.mwriter.var(Method.getName).call(*** Args)
             }
         }
-        [Method_.getName Fun_]
+        [Method.getName Fun]
     }
 }
 
 :adaptertrait = {
     delegatingtrait.tee {
-        \0.append(['visitFieldInsn' { > :Self_ (:Opcode_ :Owner_ :Name_ :Desc_)
+        \0.append(['visitFieldInsn' { > :Self (:Opcode :Owner :Name :Desc)
             switch(
-                { Name_ == '$assertionsDisabled' && Opcode_ == Opcodes.GETSTATIC } {
-                    Self_.setprop('assertjump?' true)
+                { Name == '$assertionsDisabled' && Opcode == Opcodes.GETSTATIC } {
+                    Self.setprop('assertjump?' true)
                 }
-                { Self_.label == null } {
-                    Self_.mwriter.visitFieldInsn(Opcode_ Owner_ Name_ Desc_)
+                { Self.label == null } {
+                    Self.mwriter.visitFieldInsn(Opcode Owner Name Desc)
                 }
             )
         }])
-        \0.append(['visitJumpInsn' { > :Self_ (:Opcode_ :Label_)
+        \0.append(['visitJumpInsn' { > :Self (:Opcode :Label)
             switch(
-                { Self_.assertjump? && Self_.label == null } {
-                    Self_.setprop('label' Label_)
-                    Self_.setprop('assertjump?' false)
+                { Self.assertjump? && Self.label == null } {
+                    Self.setprop('label' Label)
+                    Self.setprop('assertjump?' false)
                 }
-                { Self_.label == null } {
-                    Self_.mwriter.visitJumpInsn(Opcode_ Label_)
+                { Self.label == null } {
+                    Self.mwriter.visitJumpInsn(Opcode Label)
                 }
             )
         }])
-        \0.append(['visitLabel' { > :Self_ (:Label_)
-            (Self_.label == Label_).then {
-                Self_.setprop('label' null)
+        \0.append(['visitLabel' { > :Self (:Label)
+            (Self.label == Label).then {
+                Self.setprop('label' null)
             }
-            Self_.mwriter.visitLabel(Label_)
+            Self.mwriter.visitLabel(Label)
         }])
     }
 }
 
-:Constructor_ = MethodVisitor.with(*** adaptertrait)
+:Constructor = MethodVisitor.with(*** adaptertrait)
 
-:newadapter = { (:Mwriter_)
-    Constructor_.call(Opcodes.ASM4).tee {
-        \0.setfield('mv' Mwriter_)
+:newadapter = { (:Mwriter)
+    Constructor.call(Opcodes.ASM4).tee {
+        \0.setfield('mv' Mwriter)
         \0.setprop('assertjump?' false)
         \0.setprop('label' null)
-        \0.setprop('mwriter' Mwriter_)
+        \0.setprop('mwriter' Mwriter)
     }
 }
 
-:handle = { (:Src_ :Dest_)
-    printline(expand('Dir #Src_ -> #Dest_'))
-    Src_.childpaths.loop { (:Src_child)
-        :Dest_child = Dest_ + (Src_child - Src_)
+:handle = { (:Src :Dest)
+    printline(expand('Dir #Src -> #Dest'))
+    Src.childpaths.loop { (:Src_child)
+        :Dest_child = Dest + (Src_child - Src)
         switch(
             { Src_child.directory? } {
                 handle(Src_child Dest_child)
             }
             { Src_child.name.endswith?('.class') } {
                 printline(expand('Class #Src_child => #Dest_child'))
-                :Reader_ = ClassReader.new(Src_child.bytes)
-                :Writer_ = ClassWriter.new(Reader_ ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES)
-                :Adapter_ = ClassVisitor.with(
-                    'visitMethod' { (:Access_ :Name_ :Desc_ :Signature_ :Exceptions_)
-                        :Mwriter_ = Writer_.visitMethod(Access_ Name_ Desc_ Signature_ Exceptions_)
-                        newadapter(Mwriter_)
+                :Reader = ClassReader.new(Src_child.bytes)
+                :Writer = ClassWriter.new(Reader ClassWriter.COMPUTE_MAXS + ClassWriter.COMPUTE_FRAMES)
+                :Adapter = ClassVisitor.with(
+                    'visitMethod' { (:Access :Name :Desc :Signature :Exceptions)
+                        :Mwriter = Writer.visitMethod(Access Name Desc Signature Exceptions)
+                        newadapter(Mwriter)
                     }
-                ).call(Opcodes.ASM4 Writer_)
-                Reader_.accept(Adapter_ ClassReader.SKIP_FRAMES)
+                ).call(Opcodes.ASM4 Writer)
+                Reader.accept(Adapter ClassReader.SKIP_FRAMES)
                 Dest_child.parentpath.mkdirp
-                Dest_child.writebytes(Writer_.toByteArray)
+                Dest_child.writebytes(Writer.toByteArray)
             }
         )
     }
 }
 
 # kink deleteassertion.kn src dest
-[:Srcroot_ :Destroot_] = ARGV
-handle(path(Srcroot_) path(Destroot_))
+[:Srcroot :Destroot] = ARGV
+handle(path(Srcroot) path(Destroot))

File src/main/kink/COMMAND.kn

 use('java.nio.charset.Charset')
 use('java.lang.String')
 
-:command = { (* :Args_)
-    :Process_builder = ProcessBuilder.new(Args_)
+:command = { (* :Args)
+    :Process_builder = ProcessBuilder.new(Args)
     Process_builder.inheritIO
     _command_from_pb(Process_builder)
 }
 }
 
 :Command_trait = [
-    'directory' { > :Command_ (:Dir_)
-        Command_.Process_builder.directory(path(Dir_.toString))
+    'directory' { > :Command (:Dir)
+        Command.Process_builder.directory(path(Dir.toString))
     }
-    'join' { > :Command_ ()
-        :Process_ = Command_.Process_builder.start
-        Command_._spawn_in(Process_)
-        Command_._spawn_out(Process_)
-        Command_._spawn_err(Process_)
-        Command_._join_in
-        Command_._join_out
-        Command_._join_err
-        :Status_ = Process_.waitFor
-        Command_.:join = constfun(Status_)
-        Status_
+    'join' { > :Command ()
+        :Process = Command.Process_builder.start
+        Command._spawn_in(Process)
+        Command._spawn_out(Process)
+        Command._spawn_err(Process)
+        Command._join_in
+        Command._join_out
+        Command._join_err
+        :Status = Process.waitFor
+        Command.:join = constfun(Status)
+        Status
     }
-    'text' { > :Command_ (:Coding_ = Charset.defaultCharset)
-        :Text_ = ()
-        Command_.handle_out { (:Stream_)
-            :Text_.solid = Stream_.text(Coding_)
+    'text' { > :Command (:Coding = Charset.defaultCharset)
+        :Text = ()
+        Command.handle_out { (:Stream)
+            :Text.solid = Stream.text(Coding)
         }
-        Command_.join
-        Text_
+        Command.join
+        Text
     }
-    'bytes' { > :Command_ ()
-        :Bytes_ = ()
-        Command_.handle_out { (:Stream_) :Bytes_.solid = Stream_.bytes }
-        Command_.join
-        Bytes_
+    'bytes' { > :Command ()
+        :Bytes = ()
+        Command.handle_out { (:Stream) :Bytes.solid = Stream.bytes }
+        Command.join
+        Bytes
     }
-    'give_text' { > :Command_ (:Text_)
-        Command_.handle_in { (:Stream_) Stream_.print(Text_) }
+    'give_text' { > :Command (:Text)
+        Command.handle_in { (:Stream) Stream.print(Text) }
     }
-    'give_bytes' { > :Command_ (:Bytes_)
-        Command_.handle_in { (:Stream_) Stream_.write(Bytes_) }
+    'give_bytes' { > :Command (:Bytes)
+        Command.handle_in { (:Stream) Stream.write(Bytes) }
     }
-    'merge_error' { > :Command_ ()
-        Command_.Process_builder.redirectErrorStream(true)
+    'merge_error' { > :Command ()
+        Command.Process_builder.redirectErrorStream(true)
     }
-    'handle_in' { > :Command_ (:_block)
-        Command_.Process_builder.redirectInput(Redirect.PIPE)
-        Command_.:_spawn_in = { (:Process_)
-            :Thread_ = Thread.new {
-                using(Process_.getOutputStream $_block)
+    'handle_in' { > :Command (:_block)
+        Command.Process_builder.redirectInput(Redirect.PIPE)
+        Command.:_spawn_in = { (:Process)
+            :Thread = Thread.new {
+                using(Process.getOutputStream $_block)
             }
-            Command_.:_join_in = { Thread_.join }
-            Thread_.start
+            Command.:_join_in = { Thread.join }
+            Thread.start
         }
     }
-    'handle_out' { > :Command_ (:_block)
-        Command_.Process_builder.redirectOutput(Redirect.PIPE)
-        Command_.:_spawn_out = { (:Process_)
-            :Thread_ = Thread.new {
-                using(Process_.getInputStream $_block)
+    'handle_out' { > :Command (:_block)
+        Command.Process_builder.redirectOutput(Redirect.PIPE)
+        Command.:_spawn_out = { (:Process)
+            :Thread = Thread.new {
+                using(Process.getInputStream $_block)
             }
-            Command_.:_join_out = { Thread_.join }
-            Thread_.start
+            Command.:_join_out = { Thread.join }
+            Thread.start
         }
     }
-    'handle_error' { > :Command_ (:_block)
-        Command_.Process_builder.redirectError(Redirect.PIPE)
-        Command_.:_spawn_err = { (:Process_)
-            :Thread_ = Thread.new {
-                using(Process_.getErrorStream $_block)
+    'handle_error' { > :Command (:_block)
+        Command.Process_builder.redirectError(Redirect.PIPE)
+        Command.:_spawn_err = { (:Process)
+            :Thread = Thread.new {
+                using(Process.getErrorStream $_block)
             }
-            Command_.:_join_err = { Thread_.join }
-            Thread_.start
+            Command.:_join_err = { Thread.join }
+            Thread.start
         }
     }
     '_spawn_in' {}
     '_join_in' {}
     '_join_out' {}
     '_join_err' {}
-    'command??' { > :Command_
-        Command_.:Process_builder.exists?
+    'command??' { > :Command
+        Command.:Process_builder.exists?
     }
 ]
 

File src/main/kink/COMMON_PATTERN.kn

 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-## Complement of Pattern_
-:not = { (:Pattern_)
+## Complement of Pattern
+:not = { (:Pattern)
     value(
-        'op_match' { (:Case_) ! (Case_ =~ Pattern_) }
-        'show' { expand('not(#{Pattern_.show})') }
+        'op_match' { (:Case) ! (Case =~ Pattern) }
+        'show' { expand('not(#{Pattern.show})') }
     )
 }
 
 ## Union of the patterns
-:or = { (* :Patterns_)
+:or = { (* :Patterns)
     value(
-        'op_match' { (:Case_) Patterns_.any? { Case_ =~ \0 } }
+        'op_match' { (:Case) Patterns.any? { Case =~ \0 } }
         'show' {
-            :Contents_ = Patterns_.map { ' ' + \0.show + ' ' } .join
-            expand('or(#Contents_)')
+            :Contents = Patterns.map { ' ' + \0.show + ' ' } .join
+            expand('or(#Contents)')
         }
     )
 }
 
 ## Intersection of the patterns
-:and = { (* :Patterns_)
+:and = { (* :Patterns)
     value(
-        'op_match' { (:Case_) Patterns_.all? { Case_ =~ \0 } }
+        'op_match' { (:Case) Patterns.all? { Case =~ \0 } }
         'show' {
-            :Contents_ = Patterns_.map { ' ' + \0.show + ' ' } .join
-            expand('and(#Contents_)')
+            :Contents = Patterns.map { ' ' + \0.show + ' ' } .join
+            expand('and(#Contents)')
         }
     )
 }
 
 ## Pattern that tests equality to the expected value
-:eq = { (:Expected_)
+:eq = { (:Expected)
     value(
-        'op_match' { (:Case_) Case_ == Expected_ }
-        'show' { () expand('eq(#{Expected_.show})') }
+        'op_match' { (:Case) Case == Expected }
+        'show' { () expand('eq(#{Expected.show})') }
     )
 }
 
 ## Pattern that checks non-equality to the not-expected value
 :ne = { (:Not_expected)
     value(
-        'op_match' { (:Case_) Case_ != Not_expected }
+        'op_match' { (:Case) Case != Not_expected }
         'show' { () expand('ne(#{Not_expected.show})') }
     )
 }
 
 ## Pattern that checks the argument is less than the above value
-:lt = { (:Above_)
+:lt = { (:Above)
     value(
-        'op_match' { (:Arg_) Arg_ < Above_ }
-        'show' { () expand('lt(#{Above_.show})') }
+        'op_match' { (:Arg) Arg < Above }
+        'show' { () expand('lt(#{Above.show})') }
     )
 }
 
 ## Pattern that checks the argument is less than or equal to the max value
-:le = { (:Max_)
+:le = { (:Max)
     value(
-        'op_match' { (:Arg_) Arg_ <= Max_ }
-        'show' { () expand('le(#{Max_.show})') }
+        'op_match' { (:Arg) Arg <= Max }
+        'show' { () expand('le(#{Max.show})') }
     )
 }
 
 ## Pattern that checks the argument is greater than to the below value
-:gt = { (:Below_)
+:gt = { (:Below)
     value(
-        'op_match' { (:Arg_) Arg_ > Below_ }
-        'show' { () expand('gt(#{Below_.show})') }
+        'op_match' { (:Arg) Arg > Below }
+        'show' { () expand('gt(#{Below.show})') }
     )
 }
 
 ## Pattern that checks the argument is greater than to the below value
-:ge = { (:Min_)
+:ge = { (:Min)
     value(
-        'op_match' { (:Arg_) Arg_ >= Min_ }
-        'show' { () expand('ge(#{Min_.show})') }
+        'op_match' { (:Arg) Arg >= Min }
+        'show' { () expand('ge(#{Min.show})') }
     )
 }
 
 ## Pattern that the argument is an instance of the class (default:java.lang.Object)
-:object = { (:Class_)
-    :Class_.exists?.then {
+:object = { (:Class)
+    :Class.exists?.then {
         value(
-            'op_match' { (:Arg_) Arg_.instanceof?(Class_) }
-            'show' { () expand('object(class(#{Class_.getName.show}))') }
+            'op_match' { (:Arg) Arg.instanceof?(Class) }
+            'show' { () expand('object(class(#{Class.getName.show}))') }
         )
     } {
         value(
-            'op_match' { (:Arg_) Arg_.object?? }
+            'op_match' { (:Arg) Arg.object?? }
             'show' { () 'object' }
         )
     }
 }
 
 ## Pattern that the argument is identical to the expected value
-:identical = { (:Expected_)
+:identical = { (:Expected)
     value(
-        'op_match' { (:Arg_) Arg_.identity == Expected_.identity }
-        'show' { () expand('identical(#{Expected_.show})') }
+        'op_match' { (:Arg) Arg.identity == Expected.identity }
+        'show' { () expand('identical(#{Expected.show})') }
     )
 }
 
 ## Pattern that the argument is sub of the argument value
-:sub = { (:Target_)
+:sub = { (:Target)
     value(
-        'op_match' { (:Arg_) Arg_.sub?(Target_) }
-        'show' { () expand('sub(#{Target_.show})') }
+        'op_match' { (:Arg) Arg.sub?(Target) }
+        'show' { () expand('sub(#{Target.show})') }
     )
 }
 
-:sameobject = { (:Expected_)
+:sameobject = { (:Expected)
     value(
-        'op_match' { (:Arg_) Arg_.sameinstance?(Expected_) }
-        'show' { () expand('sameobject(#{Expected_.show})') }
+        'op_match' { (:Arg) Arg.sameinstance?(Expected) }
+        'show' { () expand('sameobject(#{Expected.show})') }
     )
 }

File src/main/kink/COMPARE.kn

 #   a positive number if \0 > \1.
 :comparetrait = { (:_compare)
     [
-        'op_cmp' { > :One_ (:Another_) _compare(One_ Another_) }
-        'op_lt' { > :One_ (:Another_) _compare(One_ Another_) < 0 }
-        'op_le' { > :One_ (:Another_) _compare(One_ Another_) <= 0 }
-        'op_gt' { > :One_ (:Another_) _compare(One_ Another_) > 0 }
-        'op_ge' { > :One_ (:Another_) _compare(One_ Another_) >= 0 }
+        'op_cmp' { > :One (:Another) _compare(One Another) }
+        'op_lt' { > :One (:Another) _compare(One Another) < 0 }
+        'op_le' { > :One (:Another) _compare(One Another) <= 0 }
+        'op_gt' { > :One (:Another) _compare(One Another) > 0 }
+        'op_ge' { > :One (:Another) _compare(One Another) >= 0 }
     ]
 }
 
 #
 # Usage:
 #   use('COMPARE')
-#   :List_ = [20 42 95 26 27]
-#   :Sorted_ = List_.sort(COMPARE.by { \0 % 10 })
-#   printline(Sorted_) # => [20 42 95 26 27]
+#   :List = [20 42 95 26 27]
+#   :Sorted = List.sort(COMPARE.by { \0 % 10 })
+#   printline(Sorted) # => [20 42 95 26 27]
 :by = { (:_sortkey)
     { _sortkey(\0) <=> _sortkey(\1) }
 }
 #
 # Usage:
 #   use('COMPARE')
-#   :List_ = [20 42 95 26 27]
-#   :Sorted_ = List_.sort(COMPARE.reverse)
-#   printline(Sorted_) # => [95 42 27 26 20]
+#   :List = [20 42 95 26 27]
+#   :Sorted = List.sort(COMPARE.reverse)
+#   printline(Sorted) # => [95 42 27 26 20]
 #
 # Usage:
 #   use('COMPARE')
-#   :List_ = [20 42 95 26 27]
-#   :Sorted_ = List_.sort(COMPARE.reverse(COMPARE.by { \0 % 10 }))
-#   printline(Sorted_) # => [27 26 95 42 20]
+#   :List = [20 42 95 26 27]
+#   :Sorted = List.sort(COMPARE.reverse(COMPARE.by { \0 % 10 }))
+#   printline(Sorted) # => [27 26 95 42 20]
 :reverse = { (:_compare)
     :_compare.exists?.then {
         { _compare(\1 \0) }

File src/main/kink/KINK_VERSION.kn

 :_read_version = {
     use('USING.using')
     use('org.kink_lang.kink.Value')
-    :String_ = using(Value.getClassLoader.getResourceAsStream('org/kink_lang/kink/version.txt')) {
+    :String = using(Value.getClassLoader.getResourceAsStream('org/kink_lang/kink/version.txt')) {
         \0.text.trim
     }
-    :Numbers_ = (String_ / '.').map { \0.int }
-    [String_ Numbers_]
+    :Numbers = (String / '.').map { \0.int }
+    [String Numbers]
 }
 
-[:String_ :Numbers_] = _read_version
+[:String :Numbers] = _read_version
 
 # Version string of the interpreter.
-:version = constfun(String_)
+:version = constfun(String)
 
 # Version numbers of the interpreter.
-:numbers = constfun(Numbers_)
+:numbers = constfun(Numbers)

File src/main/kink/LIST.kn

 # THE SOFTWARE.
 
 ## Zips lists
-:zip = { (* :Lists_)
-    Lists_.any?.then {
-        _min_count(Lists_).times.list.map { (:Index_) Lists_.map { \0.get(Index_) } }
+:zip = { (* :Lists)
+    Lists.any?.then {
+        _min_count(Lists).times.list.map { (:Index) Lists.map { \0.get(Index) } }
     } {
         []
     }
 }
 
 # Minimum count of lists
-:_min_count = { (:Lists_)
-    Lists_.map { \0.count } .min
+:_min_count = { (:Lists)
+    Lists.map { \0.count } .min
 }
 
 ## Unfold a list
-:unfold = { (:Init_ :Continue_pattern :_transform :_next)
-    :Result_ = []
-    :_loop.do(Init_) { (:Accum_)
-        (Accum_ =~ Continue_pattern).then {
-            Result_.push(_transform(Accum_))
-            _loop(_next(Accum_))
+:unfold = { (:Init :Continue_pattern :_transform :_next)
+    :Result = []
+    :_loop.do(Init) { (:Accum)
+        (Accum =~ Continue_pattern).then {
+            Result.push(_transform(Accum))
+            _loop(_next(Accum))
         }
     }
-    Result_
+    Result
 }
 
 ## Expand a list
 :extend = { (:_try_pop)
-    :List_ = []
+    :List = []
     :_loop.do {
         _try_pop.switch(
             [] {}
-            [:Elem_] {
-                List_.push(Elem_)
+            [:Elem] {
+                List.push(Elem)
                 _loop
             }
         )
     }
-    List_
+    List
 }

File src/main/kink/MAP.kn

 use('JAVA.null')
 use('META.meta')
 
-:map = { (* :Args_)
+:map = { (* :Args)
     :Java_map = ConcurrentHashMap.new
-    Args_.unconcat(2).loop { ([:Key_ :Value_])
-        Java_map.put(meta(Key_) meta(Value_))
+    Args.unconcat(2).loop { ([:Key :Value])
+        Java_map.put(meta(Key) meta(Value))
     }
     Map_proto.child(
         'Java_map' Java_map
     )
 }
 
-:_key_not_found = { (:Key_)
-    throw(expand('Key not found: #{Key_.show}'))
+:_key_not_found = { (:Key)
+    throw(expand('Key not found: #{Key.show}'))
 }
 
 :Map_proto = value(
     'Java_map' ConcurrentHashMap.new
     'Tl_showing' ThreadLocal.new
-    'any?' { > :Map_ ()
-        !Map_.Java_map.isEmpty
+    'any?' { > :Map ()
+        !Map.Java_map.isEmpty
     }
-    'empty?' { > :Map_ ()
-        Map_.Java_map.isEmpty
+    'empty?' { > :Map ()
+        Map.Java_map.isEmpty
     }
-    'count' { > :Map_ () Map_.Java_map.size }
-    'get' { > :Map_ (:Key_ :_no_element = {_key_not_found(Key_)}  :_element_found = {\0} )
-        Map_.Java_map.get(meta(Key_)).switch(
+    'count' { > :Map () Map.Java_map.size }
+    'get' { > :Map (:Key :_no_element = {_key_not_found(Key)}  :_element_found = {\0} )
+        Map.Java_map.get(meta(Key)).switch(
             (null) { _no_element }
-            :Value_ { _element_found( Value_.unmeta ) }
+            :Value { _element_found( Value.unmeta ) }
         )
     }
-    'haskey?' { > :Map_ (:Key_)
-        Map_.Java_map.containsKey(meta(Key_))
+    'haskey?' { > :Map (:Key)
+        Map.Java_map.containsKey(meta(Key))
     }
-    'has?' { > :Map_ (:Value_)
-        Map_.Java_map.values.contains(meta(Value_))
+    'has?' { > :Map (:Value)
+        Map.Java_map.values.contains(meta(Value))
     }
-    'set' { > :Map_ (:Key_ :Value_)
-        Map_.Java_map.put(meta(Key_) meta(Value_))
-        Map_
+    'set' { > :Map (:Key :Value)
+        Map.Java_map.put(meta(Key) meta(Value))
+        Map
     }
-    'setifabsent' { > :Map_ (:Key_ :Value_ :_not_set = {Map_} :_set = {Map_})
-        Map_.Java_map.putIfAbsent(meta(Key_) meta(Value_)).switch(
+    'setifabsent' { > :Map (:Key :Value :_not_set = {Map} :_set = {Map})
+        Map.Java_map.putIfAbsent(meta(Key) meta(Value)).switch(
             (null) { _set }
-            :Old_ { _not_set(Old_.unmeta) }
+            :Old { _not_set(Old.unmeta) }
         )
     }
-    'setifpresent' { > :Map_ (:Key_ :Value_ :_not_set = {Map_} :_set = {Map_})
-        Map_.Java_map.replace(meta(Key_) meta(Value_)).switch(
+    'setifpresent' { > :Map (:Key :Value :_not_set = {Map} :_set = {Map})
+        Map.Java_map.replace(meta(Key) meta(Value)).switch(
             (null) { _not_set }
-            :Old_ { _set(Old_.unmeta) }
+            :Old { _set(Old.unmeta) }
         )
     }
-    'setifequal' { > :Map_ (:Key_ :Old_ :New_ :_not_set = {Map_} :_set = {Map_})
-        Map_.Java_map.replace(meta(Key_) meta(Old_) meta(New_)).then($_set $_not_set)
+    'setifequal' { > :Map (:Key :Old :New :_not_set = {Map} :_set = {Map})
+        Map.Java_map.replace(meta(Key) meta(Old) meta(New)).then($_set $_not_set)
     }
-    'pop' { > :Map_ (:Key_ :_not_popped = {_key_not_found(Key_)}  :_popped = {\0})
-        Map_.Java_map.remove(meta(Key_)).switch(
+    'pop' { > :Map (:Key :_not_popped = {_key_not_found(Key)}  :_popped = {\0})
+        Map.Java_map.remove(meta(Key)).switch(
             (null) { _not_popped }
-            :Value_ { _popped(Value_.unmeta) }
+            :Value { _popped(Value.unmeta) }
         )
     }
-    'append' { > :Map_ (:Another_ :_select = {\2})
-        Another_.pairs.loop { ([:Key_ :Value_])
-            :Put_ = Map_.Java_map.containsKey(meta(Key_)).then {
-                _select(Key_ Map_.Java_map.get(meta(Key_)).unmeta Value_)
+    'append' { > :Map (:Another :_select = {\2})
+        Another.pairs.loop { ([:Key :Value])
+            :Put = Map.Java_map.containsKey(meta(Key)).then {
+                _select(Key Map.Java_map.get(meta(Key)).unmeta Value)
             } {
-                Value_
+                Value
             }
-            Map_.Java_map.put(meta(Key_) meta(Put_))
+            Map.Java_map.put(meta(Key) meta(Put))
         }
-        Map_
+        Map
     }
-    'op_add' { > :Map_ (:Another_)
-        Map_.clone.tee {
-            \0.append(Another_)
+    'op_add' { > :Map (:Another)
+        Map.clone.tee {
+            \0.append(Another)
         }
     }
-    'clear' { > :Map_ ()
-        Map_.Java_map.clear
-        Map_
+    'clear' { > :Map ()
+        Map.Java_map.clear
+        Map
     }
-    'clone' { > :Map_ ()
-        :Newmap_ = map
-        Map_.pairs.loop { ([:Key_ :Value_])
-            Newmap_.set(Key_ Value_)
+    'clone' { > :Map ()
+        :Newmap = map
+        Map.pairs.loop { ([:Key :Value])
+            Newmap.set(Key Value)
         }
-        Newmap_
+        Newmap
     }
-    'keyseq' { > :Map_ ()
-        Map_.Java_map.keySet.seq.map { \0.unmeta }
+    'keyseq' { > :Map ()
+        Map.Java_map.keySet.seq.map { \0.unmeta }
     }
-    'keys' { > :Map_ ()
-        Map_.keyseq.list
+    'keys' { > :Map ()
+        Map.keyseq.list
     }
-    'seq' { > :Map_ ()
-        Map_.Java_map.values.seq.map { \0.unmeta }
+    'seq' { > :Map ()
+        Map.Java_map.values.seq.map { \0.unmeta }
     }
-    'list' { > :Map_ ()
-        Map_.seq.list
+    'list' { > :Map ()
+        Map.seq.list
     }
-    'pairseq' { > :Map_ ()
-        Map_.Java_map.entrySet.seq.map { [\0.getKey.unmeta \0.getValue.unmeta] }
+    'pairseq' { > :Map ()
+        Map.Java_map.entrySet.seq.map { [\0.getKey.unmeta \0.getValue.unmeta] }
     }
-    'pairs' { > :Map_ ()
-        Map_.Java_map.entrySet.seq.map { [\0.getKey.unmeta \0.getValue.unmeta] } .list
+    'pairs' { > :Map ()
+        Map.Java_map.entrySet.seq.map { [\0.getKey.unmeta \0.getValue.unmeta] } .list
     }
-    'hash' { > :Map_ ()
-        Map_.pairs.fold(0) { \0 + \1.hash }
+    'hash' { > :Map ()
+        Map.pairs.fold(0) { \0 + \1.hash }
     }
-    'op_eq' { > :Map_ (:Another_)
-        Another_.map??
-        && Map_.count == Another_.count
-        && Another_.pairs.all? { ([:Key_ :Value_])
-            Map_.haskey?(Key_) && Map_.get(Key_) == Value_
+    'op_eq' { > :Map (:Another)
+        Another.map??
+        && Map.count == Another.count
+        && Another.pairs.all? { ([:Key :Value])
+            Map.haskey?(Key) && Map.get(Key) == Value
         }
     }
-    'show' { > :Map_ ()
-        Map_.Tl_showing.get.switch(
+    'show' { > :Map ()
+        Map.Tl_showing.get.switch(
             (null) {
-                scopeguarding { (:Scope_)
-                    Map_.Tl_showing.set(true)
-                    Scope_.onexit { Map_.Tl_showing.remove }
-                    :Contents_ = Map_.pairs.map { ([:Key_ :Value_])
-                        expand('#{Key_.show} #{Value_.show}')
+                scopeguarding { (:Scope)
+                    Map.Tl_showing.set(true)
+                    Scope.onexit { Map.Tl_showing.remove }
+                    :Contents = Map.pairs.map { ([:Key :Value])
+                        expand('#{Key.show} #{Value.show}')
                     } .join('  ')
-                    expand('map(#Contents_)')
+                    expand('map(#Contents)')
                 }
             }
             (any) {

File src/main/kink/PARSE_COMMAND.kn

 # No-argument option
 :_noarg = { (:handle)
     value(
-        'handle_long_with_eq' { (:Parser_ :Name_ :Arg_)
-            Parser_._raise(expand('#Name_ takes no arguments'))
+        'handle_long_with_eq' { (:Parser :Name :Arg)
+            Parser._raise(expand('#Name takes no arguments'))
         }
-        'handle_long_without_eq' { > :Option_ (:Parser_ :First_ :Command_)
+        'handle_long_without_eq' { > :Option (:Parser :First :Command)
             handle
         }
-        'handle_short' { > :Option_ (:Parser_ :Name_ :Chars_ :Command_)
+        'handle_short' { > :Option (:Parser :Name :Chars :Command)
             handle
         }
     )
 # Require-argument option
 :_reqarg = { (:handle)
     value(
-        'handle_long_with_eq' { > :Option_ (:Parser_ :Name_ :Arg_)
-            handle(Arg_)
+        'handle_long_with_eq' { > :Option (:Parser :Name :Arg)
+            handle(Arg)
         }
-        'handle_long_without_eq' { > :Option_ (:Parser_ :Name_ :Command_)
-            (! Command_.any?).then {
-                Parser_._raise(expand('#Name_ takes an argument'))
+        'handle_long_without_eq' { > :Option (:Parser :Name :Command)
+            (! Command.any?).then {
+                Parser._raise(expand('#Name takes an argument'))
             }
-            :Arg_ = Command_.pop(0)
-            handle(Arg_)
+            :Arg = Command.pop(0)
+            handle(Arg)
         }
-        'handle_short' { > :Option_ (:Parser_ :Name_ :Chars_ :Command_)
+        'handle_short' { > :Option (:Parser :Name :Chars :Command)
             switch(
-                { Chars_.any? } { handle(Chars_.join) }
-                { Command_.any? } { handle(Command_.pop(0)) }
-                (any) { Parser_._raise(expand('#Name_ takes an argument')) }
+                { Chars.any? } { handle(Chars.join) }
+                { Command.any? } { handle(Command.pop(0)) }
+                (any) { Parser._raise(expand('#Name takes an argument')) }
             )
-            Chars_.clear
+            Chars.clear
         }
     )
 }
 # Optional-argument option
 :_optarg = { (:handle)
     value(
-        'handle_long_with_eq' { > :Option_ (:Parser_ :Name_ :Arg_)
-            handle(Arg_)
+        'handle_long_with_eq' { > :Option (:Parser :Name :Arg)
+            handle(Arg)
         }
-        'handle_long_without_eq' { > :Option_ (:Parser_ :Name_ :Command_)
+        'handle_long_without_eq' { > :Option (:Parser :Name :Command)
             handle
         }
-        'handle_short' { > :Option_ (:Parser_ :Name_ :Chars_ :Command_)
-            handle(*** Chars_.any?.then { [Chars_.join] } { [] })
-            Chars_.clear
+        'handle_short' { > :Option (:Parser :Name :Chars :Command)
+            handle(*** Chars.any?.then { [Chars.join] } { [] })
+            Chars.clear
         }
     )
 }
 
-# Returns a pattern which matches to the pair whoes name is exactly Name_
-:_exact_name = { (:Name_)
-    { ([:N_ any]) N_ == Name_ }
+# Returns a pattern which matches to the pair whoes name is exactly Name
+:_exact_name = { (:Name)
+    { ([:N any]) N == Name }
 }
 
-# Returns a pattern which matches to the pair whoes name starts with Start_
-:_part_name = { (:Start_)
-    { ([:N_ any]) N_.startswith?(Start_) }
+# Returns a pattern which matches to the pair whoes name starts with Start
+:_part_name = { (:Start)
+    { ([:N any]) N.startswith?(Start) }
 }
 
 # Prototype of parsers
 :Parser_proto = value(
-    'strictorder' { > :Parser_ ()
-        Parser_.:_strictorder? = constfun(true)
-        Parser_
+    'strictorder' { > :Parser ()
+        Parser.:_strictorder? = constfun(true)
+        Parser
     }
-    'onerror' { > :Parser_ (:_handleerror)
-        Parser_.:_handleerror = $_handleerror
-        Parser_
+    'onerror' { > :Parser (:_handleerror)
+        Parser.:_handleerror = $_handleerror
+        Parser
     }
-    'noarg' { > :Parser_ (* :Args_)
-        Parser_._addoption(Args_ $_noarg)
-        Parser_
+    'noarg' { > :Parser (* :Args)
+        Parser._addoption(Args $_noarg)
+        Parser
     }
-    'reqarg' { > :Parser_ (* :Args_)
-        Parser_._addoption(Args_ $_reqarg)
-        Parser_
+    'reqarg' { > :Parser (* :Args)
+        Parser._addoption(Args $_reqarg)
+        Parser
     }
-    'optarg' { > :Parser_ (* :Args_)
-        Parser_._addoption(Args_ $_optarg)
-        Parser_
+    'optarg' { > :Parser (* :Args)
+        Parser._addoption(Args $_optarg)
+        Parser
     }
 
     # Handles an error message
     '_handleerror' {}
 
     # Raises error
-    '_raise' { > :Parser_ (:Message_)
-        Parser_._handleerror(Message_)
-        throw(Message_)
+    '_raise' { > :Parser (:Message)
+        Parser._handleerror(Message)
+        throw(Message)
     }
 
     # True if the parse is strictorder
     '_options' constfun([])
 
     # Adds an option to the configuration
-    '_addoption' { > :Parser_ (:Args_ :newoption)
-        :handle = Args_.last
-        :Option_ = newoption($handle)
-        Args_.droptail(1).loop { (:Name_)
-            Parser_._options.push([Name_ Option_])
+    '_addoption' { > :Parser (:Args :newoption)
+        :handle = Args.last
+        :Option = newoption($handle)
+        Args.droptail(1).loop { (:Name)
+            Parser._options.push([Name Option])
         }
     }
 
     # Parses the command line list with the configuration
-    'parse' { > :Parser_ (:Command_)
-        :Command_clone = Command_.clone
-        :Result_ = []
+    'parse' { > :Parser (:Command)
+        :Command_clone = Command.clone
+        :Result = []
         { Command_clone.any? }.loop {
-            Parser_._process_first(Command_clone Result_)
+            Parser._process_first(Command_clone Result)
         }
-        Result_
+        Result
     }
 
     # Processes the first chunk of the command line list
-    '_process_first' { > :Parser_ (:Command_ :Result_)
-        :First_ = Command_.pop(0)
-        First_.switch(
+    '_process_first' { > :Parser (:Command :Result)
+        :First = Command.pop(0)
+        First.switch(
             '--' {
-                Result_.append(Command_)
-                Command_.clear
+                Result.append(Command)
+                Command.clear
             }
-            { First_.startswith?('--') && First_.any?('=') } {
-                :Eq_index = First_.index('=')
-                :Name_ = First_.head(Eq_index)
-                :Arg_ = First_.drophead(Eq_index + 1)
-                :Option_ = Parser_._find_long(Name_)
-                Option_.handle_long_with_eq(Parser_ Name_ Arg_)
+            { First.startswith?('--') && First.any?('=') } {
+                :Eq_index = First.index('=')
+                :Name = First.head(Eq_index)
+                :Arg = First.drophead(Eq_index + 1)
+                :Option = Parser._find_long(Name)
+                Option.handle_long_with_eq(Parser Name Arg)
             }
-            { First_.startswith?('--') } {
-                :Option_ = Parser_._find_long(First_)
-                Option_.handle_long_without_eq(Parser_ First_ Command_)
+            { First.startswith?('--') } {
+                :Option = Parser._find_long(First)
+                Option.handle_long_without_eq(Parser First Command)
             }
-            { First_.startswith?('-') && First_ != '-' } {
-                Parser_._parse_short(First_.drophead(1).list Command_)
+            { First.startswith?('-') && First != '-' } {
+                Parser._parse_short(First.drophead(1).list Command)
             }
             (any) {
-                Result_.push(First_)
-                Parser_._strictorder?.then {
-                    Result_.append(Command_)
-                    Command_.clear
+                Result.push(First)
+                Parser._strictorder?.then {
+                    Result.append(Command)
+                    Command.clear
                 }
             }
         )
     }
 
     # Finds a long option
-    '_find_long' { > :Parser_ (:Name_)
-        Parser_._options.any?(_exact_name(Name_)).then {
-            Parser_._options.first(_exact_name(Name_)).last
+    '_find_long' { > :Parser (:Name)
+        Parser._options.any?(_exact_name(Name)).then {
+            Parser._options.first(_exact_name(Name)).last
         } {
-            Parser_._options.select(_part_name(Name_)).switch(
-                [] { Parser_._raise(expand('Unknown option #Name_')) }
-                [:Pair_] { Pair_.last }
-                :Candidates_ {
-                    :Options_ = Candidates_.map { \0.first } .join(' ')
-                    Parser_._raise(expand('Ambiguous option #Name_, found #Options_'))
+            Parser._options.select(_part_name(Name)).switch(
+                [] { Parser._raise(expand('Unknown option #Name')) }
+                [:Pair] { Pair.last }
+                :Candidates {
+                    :Options = Candidates.map { \0.first } .join(' ')
+                    Parser._raise(expand('Ambiguous option #Name, found #Options'))
                 }
             )
         }
     }
 
     # Finds a short option
-    '_find_short' { > :Parser_ (:Name_)
-        Parser_._options.any?(_exact_name(Name_)).then {
-            Parser_._options.first(_exact_name(Name_)).last
+    '_find_short' { > :Parser (:Name)
+        Parser._options.any?(_exact_name(Name)).then {
+            Parser._options.first(_exact_name(Name)).last
         } {
-            Parser_._raise(expand('Unknown option #Name_'))
+            Parser._raise(expand('Unknown option #Name'))
         }
     }
 
     # Handles short options
-    '_parse_short' { > :Parser_ (:Chars_ :Command_)
-        { Chars_.any? }.loop {
-            :Name_ = '-' + Chars_.pop(0)
-            :Option_ = Parser_._find_short(Name_)
-            Option_.handle_short(Parser_ Name_ Chars_ Command_)
+    '_parse_short' { > :Parser (:Chars :Command)
+        { Chars.any? }.loop {
+            :Name = '-' + Chars.pop(0)
+            :Option = Parser._find_short(Name)
+            Option.handle_short(Parser Name Chars Command)
         }
     }
 )

File src/main/kink/REPL.kn

 # THE SOFTWARE.
 
 :Env_proto = module('CORE').child(
-    'show' { > :Env_ ()
+    'show' { > :Env ()
         use('SHOW')
-        SHOW.builder('env').add('<belonging>' 'repl'.show).build(Env_)
+        SHOW.builder('env').add('<belonging>' 'repl'.show).build(Env)
     }
 )
 
 # Prototype of REPLs
 :Repl_proto = value(
-    'Script_' ''
+    'Script' ''
     'Program_num' 1
-    'Prefix_' 'kink'
-    '_line_num' { > :Repl_ ()
-        Repl_.Script_.lines.count + 1
+    'Prefix' 'kink'
+    '_line_num' { > :Repl ()
+        Repl.Script.lines.count + 1
     }
-    'Env_' Env_proto.child
-    '_program_name' { > :Repl_ ()
-        Repl_.Prefix_ + _pad_zero(Repl_.Program_num 3)
+    'Env' Env_proto.child
+    '_program_name' { > :Repl ()
+        Repl.Prefix + _pad_zero(Repl.Program_num 3)
     }
-    '_prompt' { > :Repl_ ()
-        Repl_._line_num.switch(
-            1 { Repl_._program_name + ':01> ' }
-            (any) { Repl_._program_name + ':' + _pad_zero(Repl_._line_num 2) + '\ ' }
+    '_prompt' { > :Repl ()
+        Repl._line_num.switch(
+            1 { Repl._program_name + ':01> ' }
+            (any) { Repl._program_name + ':' + _pad_zero(Repl._line_num 2) + '\ ' }
         )
     }
-    '_clear' { > :Repl_ ()
-        Repl_.:Program_num += 1
-        Repl_.:Script_ = ''
+    '_clear' { > :Repl ()
+        Repl.:Program_num += 1
+        Repl.:Script = ''
     }
-    '_input' { > :Repl_ (:Line_)
-        Repl_.:Script_ += Line_ + "\n"
-        :Program_ = Repl_.Script_.program(Repl_._program_name)
+    '_input' { > :Repl (:Line)
+        Repl.:Script += Line + "\n"
+        :Program = Repl.Script.program(Repl._program_name)
         switch(
-            { Program_.valid? } {
-                _execute(Program_ Repl_.Env_).tee { Repl_._clear }
+            { Program.valid? } {
+                _execute(Program Repl.Env).tee { Repl._clear }
             }
-            { Program_.errorarea.endofprogram? } { ['continue' []] }
+            { Program.errorarea.endofprogram? } { ['continue' []] }
             (any) {
-                Repl_._clear
-                ['syntaxerror' [expand('#{Program_.errordesc}')]]
+                Repl._clear
+                ['syntaxerror' [expand('#{Program.errordesc}')]]
             }
         )
     }
-    'run' { > :Repl_ (:print = $print :printline = $printline :readline = { stdin.line })
-        print(Repl_._prompt)
+    'run' { > :Repl (:print = $print :printline = $printline :readline = { stdin.line })
+        print(Repl._prompt)
         readline.switch(
             '' {
-                (Repl_._line_num != 1).then {
-                    Repl_._clear
+                (Repl._line_num != 1).then {
+                    Repl._clear
                     printline('')
-                    Repl_.run($print $printline $readline)
+                    Repl.run($print $printline $readline)
                 } {
                     # If the line# is 1, ends the repl
                     printline('')
                 }
             }
-            :Line_ {
-                Repl_._input(Line_.chomp).switch(
-                    [{ \0.endswith?('error') } :Records_] {
-                        (['!'] + Records_).map { '  ' + \0 } .loop($printline)
+            :Line {
+                Repl._input(Line.chomp).switch(
+                    [{ \0.endswith?('error') } :Records] {
+                        (['!'] + Records).map { '  ' + \0 } .loop($printline)
                     }
-                    [any :Records_] {
-                        Records_.loop($printline)
+                    [any :Records] {
+                        Records.loop($printline)
                     }
                 )
-                Repl_.run($print $printline $readline)
+                Repl.run($print $printline $readline)
             }
         )
     }
 )
 
-# Pads 0s to the string representation of Number_ if necessary
-:_pad_zero = { (:Num_ :Min_count)
-    :Num_str = Num_.show
+# Pads 0s to the string representation of Number if necessary
+:_pad_zero = { (:Num :Min_count)
+    :Num_str = Num.show
     '0' * (Min_count - Num_str.count) + Num_str
 }
 
 # Executes the program
-:_execute = { (:Program_ :Env_)
-    :run_source = Program_.compile.notrace
+:_execute = { (:Program :Env)
+    :run_source = Program.compile.notrace
     :run_and_show = {
-        :Result_ = run_source(Env_)
-        Env_.:last = constfun(Result_)
-        :Records_ = switch(
-            { Result_ == base } { [] }
-            { Result_.var?? && Result_.exists? } {
-                ['=> ' + Result_.show + ' = ' + Result_.get.show]
+        :Result = run_source(Env)
+        Env.:last = constfun(Result)
+        :Records = switch(
+            { Result == base } { [] }
+            { Result.var?? && Result.exists? } {
+                ['=> ' + Result.show + ' = ' + Result.get.show]
             }
-            (any) { ['=> ' + Result_.show] }
+            (any) { ['=> ' + Result.show] }
         )
-        ['success' Records_]
+        ['success' Records]
     }
     $run_and_show.try.switch(
-        [true :Result_] { Result_ }
-        [false :Exception_] {
-            Env_.:lasterror = constfun(Exception_)
-            ['runtimeerror' Exception_.report]
+        [true :Result] { Result }
+        [false :Exception] {
+            Env.:lasterror = constfun(Exception)
+            ['runtimeerror' Exception.report]
         }
     )
 }
 
-## Returns a new Repl_
-:repl = { (:Prefix_ = 'kink')
+## Returns a new Repl
+:repl = { (:Prefix = 'kink')
     Repl_proto.child(
-        'Env_' Env_proto.child
-        'Prefix_' Prefix_
+        'Env' Env_proto.child
+        'Prefix' Prefix
     )
 }

File src/main/kink/SCOPE_GUARD.kn

 # THE SOFTWARE.
 
 :scopeguarding = { (:_block)
-    :Sg_ = Scope_guard_proto.child
-    { _block(Sg_) } .try.switch(
-        [true :Result_] {
-            Sg_.:result = constfun(Result_)
-            _after_success(Sg_ Sg_.Actions_)
+    :Sg = Scope_guard_proto.child
+    { _block(Sg) } .try.switch(
+        [true :Result] {
+            Sg.:result = constfun(Result)
+            _after_success(Sg Sg.Actions)
         }
-        [false :Exception_] {
-            Sg_.:exception = constfun(Exception_)
-            _after_failure(Sg_ Sg_.Actions_)
+        [false :Exception] {
+            Sg.:exception = constfun(Exception)
+            _after_failure(Sg Sg.Actions)
         }
     )
 }
 
-:_after_failure = { (:Sg_ :Actions_)
-    Actions_.any?.then {
-        { Actions_.first.actfailure } .try.switch(
+:_after_failure = { (:Sg :Actions)
+    Actions.any?.then {
+        { Actions.first.actfailure } .try.switch(
             [false :New_exception] {
-                Sg_.exception.addSuppressed(New_exception)
+                Sg.exception.addSuppressed(New_exception)
             }
         )
-        _after_failure(Sg_ Actions_.drophead(1))
+        _after_failure(Sg Actions.drophead(1))
     } {
-        Sg_.exception.throw
+        Sg.exception.throw
     }
 }
 
-:_after_success = { (:Sg_ :Actions_)
-    Actions_.any?.then {
-        { Actions_.first.actsuccess } .try.switch(
-            [true :Result_] {
-                _after_success(Sg_ Actions_.drophead(1))
+:_after_success = { (:Sg :Actions)
+    Actions.any?.then {
+        { Actions.first.actsuccess } .try.switch(
+            [true :Result] {
+                _after_success(Sg Actions.drophead(1))
             }
-            [false :Exception_] {
-                Sg_.:exception = constfun(Exception_)
-                _after_failure(Sg_ Actions_.drophead(1))
+            [false :Exception] {
+                Sg.:exception = constfun(Exception)
+                _after_failure(Sg Actions.drophead(1))
             }
         )
     } {
-        Sg_.result
+        Sg.result
     }
 }
 
 :Scope_guard_proto = value(
-    'Actions_' []
-    'onexit' { > :Sg_ (:_block)
-        Sg_.:Actions_ = [_exit_action($_block)] + Sg_.Actions_
+    'Actions' []
+    'onexit' { > :Sg (:_block)
+        Sg.:Actions = [_exit_action($_block)] + Sg.Actions
     }
-    'onsuccess' { > :Sg_ (:_block)
-        Sg_.:Actions_ = [_success_action($_block)] + Sg_.Actions_
+    'onsuccess' { > :Sg (:_block)
+        Sg.:Actions = [_success_action($_block)] + Sg.Actions
     }
-    'onfailure' { > :Sg_ (:_block)
-        Sg_.:Actions_ = [_failure_action($_block)] + Sg_.Actions_
+    'onfailure' { > :Sg (:_block)
+        Sg.:Actions = [_failure_action($_block)] + Sg.Actions
     }
-    'autoclose' { > :Sg_ (:Closeable_)
-        Sg_.onexit { Closeable_.close }
-        Closeable_
+    'autoclose' { > :Sg (:Closeable)
+        Sg.onexit { Closeable.close }
+        Closeable
     }
 )
 

File src/main/kink/SEQ.kn

     '_has_elem?' { false }
     '_next_seq' { throw('No next seq') }
     '_first_elem' { throw('No element') }
-    'loop' { > :Seq_ (:block)
-        Seq_._has_elem?.then {
-            block(Seq_._first_elem)
-            Seq_._next_seq.loop($block)
+    'loop' { > :Seq (:block)
+        Seq._has_elem?.then {
+            block(Seq._first_elem)
+            Seq._next_seq.loop($block)
         }
     }
-    'map' {  > :Seq_ (:_transform)
+    'map' {  > :Seq (:_transform)
         seq(
-            { Seq_._has_elem?  }
-            { _transform(Seq_._first_elem) }
-            { Seq_._next_seq.map($_transform) }
+            { Seq._has_elem?  }
+            { _transform(Seq._first_elem) }
+            { Seq._next_seq.map($_transform) }
         )
     }
     'concatmap' { > :Orig_seq (:_transform)
         _concatmap_seq(Orig_seq $_transform [] 0)
     }
-    'fold' { > :Seq_ (:Accum_ :compute)
+    'fold' { > :Seq (:Accum :compute)
         :compute.exists?.then {
-            Seq_._has_elem?.then {
-                :First_ = Seq_._first_elem
-                Seq_._next_seq.fold(compute(Accum_ First_) $compute)
+            Seq._has_elem?.then {
+                :First = Seq._first_elem
+                Seq._next_seq.fold(compute(Accum First) $compute)
             } {
-                Accum_
+                Accum
             }
         } {
-            :compute = Accum_
-            :First_ = Seq_._first_elem
-            Seq_._next_seq.fold(First_ $compute)
+            :compute = Accum
+            :First = Seq._first_elem
+            Seq._next_seq.fold(First $compute)
         }
     }
-    'list' { > :Seq_ ()
-        [].tee { (:List_)
-            Seq_.loop { List_.push(\0) }
+    'list' { > :Seq ()
+        [].tee { (:List)
+            Seq.loop { List.push(\0) }
         }
     }
-    'dropwhile' { > :Orig_seq (:Case_)
+    'dropwhile' { > :Orig_seq (:Case)
         lazyseq {
-            _force_dropwhile(Orig_seq Case_)
+            _force_dropwhile(Orig_seq Case)
         }
     }
-    'while' { > :Orig_seq (:Case_)
+    'while' { > :Orig_seq (:Case)
         seq(
-            { Orig_seq._has_elem? && Orig_seq._first_elem =~ Case_ }
+            { Orig_seq._has_elem? && Orig_seq._first_elem =~ Case }
             { Orig_seq._first_elem }
-            { Orig_seq._next_seq.while(Case_) }
+            { Orig_seq._next_seq.while(Case) }
         )
     }
-    'select' { > :Seq_ (:Case_)
-        :Seq_ = Seq_.dropwhile(not(Case_))
+    'select' { > :Seq (:Case)
+        :Seq = Seq.dropwhile(not(Case))
         seq(
-            { Seq_._has_elem? }
-            { Seq_._first_elem }
-            { Seq_._next_seq.select(Case_) }
+            { Seq._has_elem? }
+            { Seq._first_elem }
+            { Seq._next_seq.select(Case) }
         )
     }
-    'op_add' { > :First_ (:Second_)
-        Plus_proto.child('Head_' First_ 'Others_' [Second_])
+    'op_add' { > :First (:Second)
+        Plus_proto.child('Head' First 'Others' [Second])
     }
-    'empty?' { > :Seq_ ()
-        ! Seq_._has_elem?
+    'empty?' { > :Seq ()
+        ! Seq._has_elem?
     }
-    'all?' { > :Seq_ (:Case_)
-        ! Seq_._has_elem? || Seq_._first_elem =~ Case_ && Seq_._next_seq.all?(Case_)
+    'all?' { > :Seq (:Case)
+        ! Seq._has_elem? || Seq._first_elem =~ Case && Seq._next_seq.all?(Case)
     }
-    'any?' { > :Seq_ (:Case_ = any)
-        Seq_._has_elem? && (Seq_._first_elem =~ Case_ || Seq_._next_seq.any?(Case_))
+    'any?' { > :Seq (:Case = any)
+        Seq._has_elem? && (Seq._first_elem =~ Case || Seq._next_seq.any?(Case))
     }
-    'has?' { > :Seq_ (:Elem_)
-        Seq_._has_elem? && (Elem_ == Seq_._first_elem || Seq_._next_seq.has?(Elem_))
+    'has?' { > :Seq (:Elem)
+        Seq._has_elem? && (Elem == Seq._first_elem || Seq._next_seq.has?(Elem))
     }
-    'index' { > :Seq_ (:Case_)
-        :index.do(Seq_ 0) { (:It_ :Index_)
-            (It_._first_elem =~ Case_).then { Index_ } { index(It_._next_seq Index_ + 1) }
+    'index' { > :Seq (:Case)
+        :index.do(Seq 0) { (:It :Index)
+            (It._first_elem =~ Case).then { Index } { index(It._next_seq Index + 1) }
         }
     }
-    'count' { > :Seq_ (:Case_ = any)
-        Seq_.fold(0) { (:Count_ :Elem_)
-            Count_ + (Elem_ =~ Case_).then { 1 } { 0 }
+    'count' { > :Seq (:Case = any)
+        Seq.fold(0) { (:Count :Elem)
+            Count + (Elem =~ Case).then { 1 } { 0 }
         }
     }
-    'head' { > :Orig_seq (:To_)
+    'head' { > :Orig_seq (:To)
         seq(
-            { Orig_seq._has_elem? && 0 < To_ }
+            { Orig_seq._has_elem? && 0 < To }
             { Orig_seq._first_elem }
-            { Orig_seq._next_seq.head(To_ - 1) }
+            { Orig_seq._next_seq.head(To - 1) }
         )
     }
-    'drophead' { > :Seq_ (:Count_)
-        _cutseq(Seq_ Count_)
+    'drophead' { > :Seq (:Count)
+        _cutseq(Seq Count)
     }
-    'slice' { > :Seq_ (:From_ :To_)
-        _cutseq(Seq_ From_).head(To_ - From_)
+    'slice' { > :Seq (:From :To)
+        _cutseq(Seq From).head(To - From)
     }
-    'get' { > :Seq_ (:Index_)
-        (Index_ < 0).then { throw(expand('Wrong index #Index_, expected 0..')) }
-        (Index_ == 0).then { Seq_._first_elem } { Seq_._next_seq.get(Index_ - 1) }
+    'get' { > :Seq (:Index)
+        (Index < 0).then { throw(expand('Wrong index #Index, expected 0..')) }
+        (Index == 0).then { Seq._first_elem } { Seq._next_seq.get(Index - 1) }
     }
-    'first' { > :Seq_ (:Case_ = any)
-        :First_elem = Seq_._first_elem
-        (First_elem =~ Case_).then { First_elem } { Seq_._next_seq.first(Case_) }
+    'first' { > :Seq (:Case = any)
+        :First_elem = Seq._first_elem
+        (First_elem =~ Case).then { First_elem } { Seq._next_seq.first(Case) }
     }
-    'last' { > :Seq_ (:Case_ = any)
-        :Dropped_ = Seq_.dropwhile(not(Case_))
-        Dropped_._next_seq.fold(Dropped_._first_elem) { (:Last_ :Elem_)
-            (Elem_ =~ Case_).then { Elem_ } { Last_ }
+    'last' { > :Seq (:Case = any)
+        :Dropped = Seq.dropwhile(not(Case))
+        Dropped._next_seq.fold(Dropped._first_elem) { (:Last :Elem)
+            (Elem =~ Case).then { Elem } { Last }
         }
     }
-    'max' { > :Seq_ (:select = {\0})
-        Seq_.fold { (:Max_ :Elem_)
-            (select(Max_) < select(Elem_)).then { Elem_ } { Max_ }
+    'max' { > :Seq (:select = {\0})
+        Seq.fold { (:Max :Elem)
+            (select(Max) < select(Elem)).then { Elem } { Max }
         }
     }
-    'min' { > :Seq_ (:select = {\0})
-        Seq_.fold { (:Min_ :Elem_)
-            (select(Min_) > select(Elem_)).then { Elem_ } { Min_ }
+    'min' { > :Seq (:select = {\0})
+        Seq.fold { (:Min :Elem)
+            (select(Min) > select(Elem)).then { Elem } { Min }
         }
     }
-    'sum' { > :Seq_ ()
-        Seq_.fold(0) { \0 + \1 }
+    'sum' { > :Seq ()
+        Seq.fold(0) { \0 + \1 }
     }
-    'average' { > :Seq_ ()
-        [:Count_ :Sum_] = Seq_.fold([0 0]) { ([:Count_ :Sum_] :Elem_)
-            [(Count_ + 1) (Sum_ + Elem_)]
+    'average' { > :Seq ()
+        [:Count :Sum] = Seq.fold([0 0]) { ([:Count :Sum] :Elem)
+            [(Count + 1) (Sum + Elem)]
         }
-        Sum_ / Count_
+        Sum / Count
     }
-    'unconcat' { > :Seq_ (:Size_)
+    'unconcat' { > :Seq (:Size)
         seq(
-            { Seq_._has_elem? }
-            { Seq_.head(Size_) }
-            { Seq_.drophead(Size_).unconcat(Size_) }
+            { Seq._has_elem? }
+            { Seq.head(Size) }
+            { Seq.drophead(Size).unconcat(Size) }
         )
     }
-    'join' { > :Seq_ (:Delimiter_ = '')
-        :Builder_ = StringBuilder.new
-        Seq_.fold('') { (:Prefix_ :Elem_)
-            Builder_.append(Prefix_)
-            Builder_.append(Elem_.str)
-            Delimiter_
+    'join' { > :Seq (:Delimiter = '')
+        :Builder = StringBuilder.new
+        Seq.fold('') { (:Prefix :Elem)
+            Builder.append(Prefix)
+            Builder.append(Elem.str)
+            Delimiter
         }
-        Builder_.toString
+        Builder.toString
     }
     'show' { 'seq(...)' }
     'seq??' { true }
 
 :seq = { (:_has_elem? :_first_elem :_next_seq)
     Seq_proto.child(
-        '_has_elem?' { > :Seq_
-            _has_elem?(Seq_)
+        '_has_elem?' { > :Seq
+            _has_elem?(Seq)
         }
-        '_first_elem' { > :Seq_
-            _first_elem(Seq_)
+        '_first_elem' { > :Seq
+            _first_elem(Seq)
         }
-        '_next_seq' { > :Seq_
-            _next_seq(Seq_)
+        '_next_seq' { > :Seq
+            _next_seq(Seq)
         }
     )
 }
 
 :valueseq = { \args.seq }
 
-:_force_dropwhile = { (:Seq_ :Case_)
-    (Seq_._has_elem? && Seq_._first_elem =~ Case_).then {
-        _force_dropwhile(Seq_._next_seq Case_)
+:_force_dropwhile = { (:Seq :Case)
+    (Seq._has_elem? && Seq._first_elem =~ Case).then {
+        _force_dropwhile(Seq._next_seq Case)
     } {
-        Seq_
+        Seq
     }
 }
 
-:_cutseq = { (:Seq_ :Count_)
-    (Seq_._has_elem? && 0 < Count_).then {
-        _cutseq(Seq_._next_seq Count_ - 1)
+:_cutseq = { (:Seq :Count)
+    (Seq._has_elem? && 0 < Count).then {
+        _cutseq(Seq._next_seq Count - 1)
     } {
-        Seq_
+        Seq
     }
 }
 
-:_concatmap_seq = { (:Seq_ :_transform :Tuple_ :Index_)
-    (Index_ < Tuple_.count).then {
+:_concatmap_seq = { (:Seq :_transform :Tuple :Index)
+    (Index < Tuple.count).then {
         seq(
             { true }
-            { Tuple_.get(Index_) }
-            { _concatmap_seq(Seq_ $_transform Tuple_ Index_ + 1) }
+            { Tuple.get(Index) }
+            { _concatmap_seq(Seq $_transform Tuple Index + 1) }
         )
     } {
-        lazyseq { _force_concatmap(Seq_ $_transform) }
+        lazyseq { _force_concatmap(Seq $_transform) }
     }
 }
 
-:_force_concatmap = { (:Seq_ :_transform)
-    Seq_._has_elem?.then {
-        :Next_tuple = _transform(Seq_._first_elem)
-        :Next_seq = Seq_._next_seq
+:_force_concatmap = { (:Seq :_transform)
+    Seq._has_elem?.then {
+        :Next_tuple = _transform(Seq._first_elem)
+        :Next_seq = Seq._next_seq
         (Next_tuple == []).then {
             _force_concatmap(Next_seq $_transform)
         } {
 }
 
 :lazyseq = { (:_compute)
-    :Computed_var = :Computed_
+    :Computed_var = :Computed
     :_force = {
         Computed_var.default { _compute }
-        Computed_
+        Computed
     }
     seq(
         { _force.any? }
     )
 }
 
-:zipseq = { (* :Seqs_)
+:zipseq = { (* :Seqs)
     seq(
-        { Seqs_.all? { \0.any? } }
-        { Seqs_.map { \0.first } }
-        { zipseq(*** Seqs_.map { \0.drophead(1) }) }
+        { Seqs.all? { \0.any? } }
+        { Seqs.map { \0.first } }
+        { zipseq(*** Seqs.map { \0.drophead(1) }) }
     )
 }
 
-:unfoldseq = { (:Init_ :Remains_case :_transform :_increment)
+:unfoldseq = { (:Init :Remains_case :_transform :_increment)
     seq(
-        { Init_ =~ Remains_case }
-        { _transform(Init_) }
-        { unfoldseq(_increment(Init_) Remains_case $_transform $_increment) }
+        { Init =~ Remains_case }
+        { _transform(Init) }
+        { unfoldseq(_increment(Init) Remains_case $_transform $_increment) }
     )
 }
 
 :oneshotseq = { (:_try_element)
-    :_invalidate = { (:Seq_)
-        Seq_.:_next_seq = {
+    :_invalidate = { (:Seq)
+        Seq.:_next_seq = {
             throw('_next_seq should not be called twice for an one-shot sequence')
         }
     }
-    :_force = { (:Seq_)
-        (Seq_.State_ == 'Init').then {
-            :Maybe_ = _try_element
-            Maybe_.any?.then {
-                Seq_.setvars(
-                    'State_' 'NotEmpty'
-                    'First_' Maybe_.first
+    :_force = { (:Seq)
+        (Seq.State == 'Init').then {
+            :Maybe = _try_element
+            Maybe.any?.then {
+                Seq.setvars(
+                    'State' 'NotEmpty'
+                    'First' Maybe.first
                 )
             } {
-                Seq_.:State_ = 'Empty'
+                Seq.:State = 'Empty'
             }
         }
     }
-    :Parent_ = Seq_proto.child(
-        '_has_elem?' { > :Seq_
-            _force(Seq_)
-            Seq_.State_ != 'Empty'
+    :Parent = Seq_proto.child(
+        '_has_elem?' { > :Seq
+            _force(Seq)
+            Seq.State != 'Empty'
         }
-        '_first_elem' { > :Seq_
-            _force(Seq_)
-            Seq_.First_
+        '_first_elem' { > :Seq
+            _force(Seq)
+            Seq.First
         }
-        '_next_seq' { > :Seq_
-             _force(Seq_)
-             _invalidate(Seq_)
-             Parent_.child
+        '_next_seq' { > :Seq
+             _force(Seq)
+             _invalidate(Seq)
+             Parent.child
         }
-        'State_' 'Init'
-        'First_' base
+        'State' 'Init'
+        'First' base
     )
-    Parent_.child
+    Parent.child
 }
 
 :Plus_proto = seq(
-    { (:Seq_)
-        Seq_.Head_.any? || Seq_.Others_.any? { \0.any? }
+    { (:Seq)
+        Seq.Head.any? || Seq.Others.any? { \0.any? }
     }
-    { (:Seq_)
-        Seq_.Head_.any?.then { Seq_.Head_.first } { Seq_.Others_.first { \0.any? } .first }
+    { (:Seq)
+        Seq.Head.any?.then { Seq.Head.first } { Seq.Others.first { \0.any? } .first }
     }
-    { (:Seq_)
-        Seq_.Head_.any?.then {
-            Plus_proto.child('Head_' Seq_.Head_.drophead(1) 'Others_' Seq_.Others_)
+    { (:Seq)
+        Seq.Head.any?.then {
+            Plus_proto.child('Head' Seq.Head.drophead(1) 'Others' Seq.Others)
         } {
-            :Equivalent_ = (Seq_.Others_.count == 1).then {
-                Seq_.Others_.first
+            :Equivalent = (Seq.Others.count == 1).then {
+                Seq.Others.first
             } {
-                Plus_proto.child('Head_' Seq_.Others_.first 'Others_' Seq_.Others_.drophead(1))
+                Plus_proto.child('Head' Seq.Others.first 'Others' Seq.Others.drophead(1))
             }
-            Equivalent_.drophead(1)
+            Equivalent.drophead(1)
         }
     }
 ).setvars(
-    'op_add' { > :Seq_ (:Another_)
-        Plus_proto.child('Head_' Seq_.Head_ 'Others_' Seq_.Others_ + [Another_])
+    'op_add' { > :Seq (:Another)
+        Plus_proto.child('Head' Seq.Head 'Others' Seq.Others + [Another])
     }
 )
 
 # cross
-:cross = { (* :Lists_)
-    Lists_.any?.then {
-        :Heads_ = Lists_.first
-        cross(*** Lists_.drophead(1)).concatmap { (:Tail_)
-            Heads_.map { [\0] + Tail_}
+:cross = { (* :Lists)
+    Lists.any?.then {
+        :Heads = Lists.first
+        cross(*** Lists.drophead(1)).concatmap { (:Tail)
+            Heads.map { [\0] + Tail}
         }
     } {
         valueseq([])
 }
 
 # cycle
-:cycle = { (* :Elements_)
-    _cycle(Elements_ 0)
+:cycle = { (* :Elements)
+    _cycle(Elements 0)
 }
 
-:_cycle = { (:List_ :Index_)
-    (List_ == []).then {
+:_cycle = { (:List :Index)
+    (List == []).then {
         listseq([] 0 0)
     } {
         seq(
             { true }
-            { List_.get(Index_) }
-            { _cycle(List_ (Index_ + 1) % List_.count) }
+            { List.get(Index) }
+            { _cycle(List (Index + 1) % List.count) }
         )
     }
 }
 
 ## Permutation sequence
-:permutation = { (:List_ :Count_)
+:permutation = { (:List :Count)
     switch(
-        { Count_ <= List_.count } {
-            :Powers_ = Count_.times.list.reverse.map { List_.count ** \0 }
-            0.to(List_.count ** Count_ - 1).map { (:Num_)
-                Powers_.map { (:Power_) -> List_.get(Num_ // Power_ % List_.count) }
+        { Count <= List.count } {
+            :Powers = Count.times.list.reverse.map { List.count ** \0 }
+            0.to(List.count ** Count - 1).map { (:Num)
+                Powers.map { (:Power) -> List.get(Num // Power % List.count) }
             }
         }
         (any) { valueseq() }
 }
 
 ## Combination sequence
-:combination = { (:List_ :Count_)
-    _combination(List_ 0 Count_)
+:combination = { (:List :Count)
+    _combination(List 0 Count)
 }
 
-:_combination = { (:List_ :Index_ :Count_)
-    Count_.switch(
+:_combination = { (:List :Index :Count)
+    Count.switch(
         0 { valueseq([]) }
-        (List_.count - Index_) { valueseq(List_.drophead(Index_)) }
-        (gt(List_.count - Index_)) { valueseq() }
+        (List.count - Index) { valueseq(List.drophead(Index)) }
+        (gt(List.count - Index)) { valueseq() }
         (any) {
             lazyseq {
-                :Elem_ = List_.get(Index_)
-                :Next_index = Index_ + 1
-                :With_current = _combination(List_ Next_index (Count_ - 1)).map { [Elem_] + \0 }
-                :Without_current = _combination(List_ Next_index Count_)
+                :Elem = List.get(Index)
+                :Next_index = Index + 1
+                :With_current = _combination(List Next_index (Count - 1)).map { [Elem] + \0 }
+                :Without_current = _combination(List Next_index Count)
                 With_current + Without_current
             }
         }

File src/main/kink/SET.kn

 
 use('MAP')
 
-:set = { (* :Args_)
-    :Map_ = MAP.map
-    Args_.loop {
-        Map_.set(\0 true)
+:set = { (* :Args)
+    :Map = MAP.map
+    Args.loop {
+        Map.set(\0 true)
     }
-    _new_set(Map_)
+    _new_set(Map)
 }
 
-:_new_set = { (:Map_)