Commits

Taku Miyakawa committed 85a8388

Renames Value#value(any) to box(any)

  • Participants
  • Parent commits f503278
  • Branches issue515-rename-child-value-functions-methods

Comments (0)

Files changed (129)

src/main/java/org/kink_lang/kink/Define.java

  *     public static class PairFunctions {
  *
  *         @Define
- *         public final Value type = Value.value( "pair" );
+ *         public final Value type = Value.box( "pair" );
  *
  *         // Accessors of "_head" variable
  *         private static final GetSite HEAD = new GetSite( "_head" );
  *     }
  *
  *     public static void main( String[] args ) {
- *         Value pair = Value.value();
+ *         Value pair = Value.box();
  *         pair.define( PairFunctions.class );
- *         pair.call( new GetSite( "set_head" ) , Value.value( 100 ) );
- *         pair.call( new GetSite( "set_tail" ) , Value.value( 200 ) );
+ *         pair.call( new GetSite( "set_head" ) , Value.box( 100 ) );
+ *         pair.call( new GetSite( "set_tail" ) , Value.box( 200 ) );
  *         System.out.println( pair.call( new GetSite( "type" ) ) );  // => pair
  *         System.out.println( pair.call( new GetSite( "head" ) ) );  // => 100
  *         System.out.println( pair.call( new GetSite( "tail" ) ) );  // => 200

src/main/java/org/kink_lang/kink/Fun.java

  *             for ( Value arg : args ) {
  *                 accum += arg.asInt( "\\" + (index++) );
  *             }
- *             return Value.value( accum );
+ *             return Value.box( accum );
  *         }
  *     }
  *
  *     public static void main( String[] args ) {
  *         Fun sum = new SumFun();
- *         Value result = sum.call( Value.value( 10 ) , Value.value( 20 ) );
+ *         Value result = sum.call( Value.box( 10 ) , Value.box( 20 ) );
  *         result.call( "dump" ); // 30
  *     }
  * }

src/main/java/org/kink_lang/kink/ModuleFactory.java

  *     // will be the module name.
  *     public static class Math {
  *         @Define
- *         final Value pi = Value.value( 3.1415926535 );
+ *         final Value pi = Value.box( 3.1415926535 );
  *     }
  * }
  * </pre>
         Value moduleParent = Value.newValue();
         Value module = moduleParent.newChild();
         module.define( getDefinitionClass() );
-        moduleParent.set( SET_SHOW , Value.value( showFun( module , getName() ) ) );
+        moduleParent.set( SET_SHOW , Value.box( showFun( module , getName() ) ) );
         return module;
     }
 
     private static Fun showFun( final Value module , final String moduleName ) {
         return Fun.builder().build( receiver -> {
             if ( receiver == module ) {
-                return Value.value( moduleName );
+                return Value.box( moduleName );
             } else {
                 Value showBuilderModule = Modules.find( "SHOW_BUILDER" );
-                Value showBuilder = showBuilderModule.call( NEW , Value.value( "env" ) );
-                showBuilder.call( ADD , Value.value( "hash" ) );
+                Value showBuilder = showBuilderModule.call( NEW , Value.box( "env" ) );
+                showBuilder.call( ADD , Value.box( "hash" ) );
                 return showBuilder.tailCall( BUILD , receiver );
             }
         } );

src/main/java/org/kink_lang/kink/Modules.java

         Value envParent = Envs.env();
         Fun showFun = Fun.builder().build( actualEnv -> {
             String show = "<env:#module_name=" + Strings.show( moduleName )
-                + ":hash=" + Value.value( actualEnv.hashCode() ) + ">";
-            return Value.value( show );
+                + ":hash=" + Value.box( actualEnv.hashCode() ) + ">";
+            return Value.box( show );
         } );
-        envParent.set( SET_SHOW , Value.value( showFun ) );
+        envParent.set( SET_SHOW , Value.box( showFun ) );
         Value env = envParent.newChild();
         program.compile().call( env );
 
 
         // Private methods to the parent, for test
         Value moduleParent = Value.newValue();
-        Fun nameFun = Fun.ofConstant( Value.value( moduleName ) );
-        moduleParent.set( SET_SHOW , Value.value( nameFun ) );
+        Fun nameFun = Fun.ofConstant( Value.box( moduleName ) );
+        moduleParent.set( SET_SHOW , Value.box( nameFun ) );
         copyVars( moduleParent , env , privateVerbSymbols );
 
         // Public methods to the module

src/main/java/org/kink_lang/kink/Numbers.java

      *     A value of the normalized number.
      */
     public static Value normalize( Number number ) {
-        return Value.value( canToIntLossless( number ) ? number.intValue()
+        return Value.box( canToIntLossless( number ) ? number.intValue()
                 : canToLongLossless( number ) ? number.longValue()
                 : toBigDecimal( number ) );
     }
      */
     public static Value normalize( long number ) {
         return ( Integer.MIN_VALUE <= number && number <= Integer.MAX_VALUE
-                ? Value.value( (int) number )
-                : Value.value( number ) );
+                ? Value.box( (int) number )
+                : Value.box( number ) );
     }
 
 

src/main/java/org/kink_lang/kink/Program.java

      * <pre>
      * Program program = new Program( "double.kn" , "NUM * 2" );
      * Fun fun = program.compile();
-     * System.out.println( fun.call( Value.value( 21 ) ) );  // =&gt; 42
+     * System.out.println( fun.call( Value.box( 21 ) ) );  // =&gt; 42
      * </pre>
      *
      * @return Function compiled from {@code this} program.

src/main/java/org/kink_lang/kink/Value.java

 
 
     /**
-     * Returns a new value that boxes {@code object}.
+     * Returns a value that boxes {@code object}.
      *
      * @param object
      *     Object to box.
      * @return
      *     A new value that boxes {@code object}.
      */
-    public static Value value( Object object ) {
+    public static Value box( Object object ) {
         return ( object == null ? NullHolder.NULL : newInstanceValue( object ) );
     }
 
 
     /**
-     * Returns a new value that boxes {@code bool}.
+     * Returns a value that boxes {@code bool}.
      *
      * @param bool
      *     Boolean value to box.
      * @return
      *     A new value that boxes {@code bool}.
      */
-    public static Value value( boolean bool ) {
+    public static Value box( boolean bool ) {
         return bool ? BooleanHolder.TRUE_VALUE : BooleanHolder.FALSE_VALUE;
     }
 
 
     /**
-     * Returns a new value that boxes {@code num}.
+     * Returns a value that boxes {@code num}.
      *
      * @param num
      *     Byte number to box.
      * @return
      *     A new value that boxes {@code num}.
      */
-    public static Value value( byte num ) {
+    public static Value box( byte num ) {
         return PrimitiveHolder.getByteValue( num );
     }
 
 
     /**
-     * Returns a new value that boxes {@code ch}.
+     * Returns a value that boxes {@code ch}.
      *
      * @param ch
      *     Character to box.
      * @return
      *     A new value that boxes {@code ch}.
      */
-    public static Value value( char ch ) {
+    public static Value box( char ch ) {
         return PrimitiveHolder.getCharValue( ch );
     }
 
 
     /**
-     * Returns a new value that boxes {@code num}.
+     * Returns a value that boxes {@code num}.
      *
      * @param num
      *     Short number to box.
      * @return
      *     A new value that boxes {@code num}.
      */
-    public static Value value( short num ) {
-        return value( (Short) num );
+    public static Value box( short num ) {
+        return box( (Short) num );
     }
 
 
     /**
-     * Returns a new value that boxes {@code num}.
+     * Returns a value that boxes {@code num}.
      *
      * @param num
      *     Int number to box.
      * @return
      *     A new value that boxes {@code num}.
      */
-    public static Value value( int num ) {
+    public static Value box( int num ) {
         return PrimitiveHolder.getIntValue( num );
     }
 
      * <p>Example:</p>
      *
      * <pre>
-     * Value parent = Value.value();
+     * Value parent = Value.box();
      * Value child = new Value( parent );
      * parent.set( "template" , templateMethod );
      * parent.set( "override" , overridedMethod );
      * static Value all_eq_p( Value elements , Value target ) {
      *   Lists&lt; Value &gt; list = elements.asList( () -&gt; "\\0" );
      *   if ( list.isEmpty() ) {
-     *     return Value.value( true );
+     *     return Value.box( true );
      *   }
      *   for ( Value element : list.subList( 0 , list.size() - 1 ) ) {
      *     if ( ! element.equals( target ) ) {
-     *       return Value.value( false );
+     *       return Value.box( false );
      *     }
      *   }
      *   Value last = list.get( list.size() - 1 );
 
     /** Calls 'var_missing'. */
     private Value callVarMissing( String symbol , Area area ) {
-        Value symbolVal = Value.value( symbol );
+        Value symbolVal = Value.box( symbol );
         Value maybeAlternativeVal = call( VARMISSING , symbolVal );
         if ( ! ( maybeAlternativeVal.unbox() instanceof ValueList ) ) {
             throw invalidDatamissingResultException( symbol , area , maybeAlternativeVal );
                 listener.notifyBaseRegistered( base() );
             }
 
-            value( null ).define( NullMethods.class );
+            box( null ).define( NullMethods.class );
         }
 
 

src/main/java/org/kink_lang/kink/ValueList.java

      * Instead, access to elements shall throw a {@link KinkException}. See the example below:</p>
      *
      * <pre>
-     * ValueList valueList = new ValueList(Value.value(42));
+     * ValueList valueList = new ValueList(Value.box(42));
      * // This does not throw an exception
      * List&lt;String&gt; strings = valueList.unboxElements( String.class );
      * // List#get throws a KinkException

src/main/java/org/kink_lang/kink/internal/BaseMethods.java

 
     @Define( "instance_of?" )
     public Value instance_of_p( @Receiver Value receiver , Class< ? > klass ) {
-        return Value.value( klass.isInstance( receiver.unbox() ) );
+        return Value.box( klass.isInstance( receiver.unbox() ) );
     }
 
 
 
     @Define
     public Value var( @Receiver Value value , String symbol ) {
-        return Value.value( new Var( value , symbol ) );
+        return Value.box( new Var( value , symbol ) );
     }
 
 
         Set< Var > ownVars = value.getOwnVars();
         ValueList result = new ValueList( ownVars.size() );
         for ( Var var : ownVars ) {
-            result.getElements().add( Value.value( var ) );
+            result.getElements().add( Value.box( var ) );
         }
-        return Value.value( result );
+        return Value.box( result );
     }
 
 
         Set< Var > vars = value.getVars();
         ValueList result = new ValueList( vars.size() );
         for ( Var var : vars ) {
-            result.getElements().add( Value.value( var ) );
+            result.getElements().add( Value.box( var ) );
         }
-        return Value.value( result );
+        return Value.box( result );
     }
 
 
 
 
     private static final Value FUNVAL_RETURNING_FALSE
-        = Value.value( Fun.builder().buildVarArgs( ( receiver , args ) -> Value.value( false ) ) );
+        = Value.box( Fun.builder().buildVarArgs( ( receiver , args ) -> Value.box( false ) ) );
 
 
     static boolean isTypeTestingFunctionSymbol( String symbol ) {
         if ( ebvResult.getElements().isEmpty() ) {
             String symbol = symbolVal.asString( () -> "\\0" );
             if ( isTypeTestingFunctionSymbol( symbol ) ) {
-                return Value.value( new ValueList( FUNVAL_RETURNING_FALSE ) );
+                return Value.box( new ValueList( FUNVAL_RETURNING_FALSE ) );
             }
         }
         return ebvResultVal;
 
     @Define
     public Value extend_base_var_missing( Value symbol ) {
-        return Value.value( new ValueList() );
+        return Value.box( new ValueList() );
     }
 
 
 
     @Define( "sub_of?" )
     public Value sub_of_p( @Receiver Value receiver , Value target ) {
-        return Value.value( receiver.isSubOf( target ) );
+        return Value.box( receiver.isSubOf( target ) );
     }
 
 
     @Define( "same_object_as?" )
     public Value same_object_as_p( @Receiver Value x , Value y ) {
-        return Value.value( x.unbox() == y.unbox() );
+        return Value.box( x.unbox() == y.unbox() );
     }
 
 
     @Define
     public Value op_ne( @Receiver Value receiver , Value target ) {
-        return Value.value( ! receiver.equals( target ) );
+        return Value.box( ! receiver.equals( target ) );
     }
 
 
     @Define
     public Value into( @Receiver Value receiver , Class< ? > klass ) {
         Checker.check( klass == Object.class , () -> Messages.cannotConvert( receiver , klass ) );
-        return Value.value( new ValueWrapper( receiver ) );
+        return Value.box( new ValueWrapper( receiver ) );
     }
 
 
     @Define( "can_into?" )
     public Value can_into_p( @Receiver Value receiver , Class< ? > klass ) {
-        return Value.value( klass == Object.class );
+        return Value.box( klass == Object.class );
     }
 
 
     @Define
     public Value op_eq( @Receiver Value receiver , Value another ) {
-        return Value.value( receiver == another );
+        return Value.box( receiver == another );
     }
 
 
     @Define
     public Value hash( @Receiver Value receiver ) {
-        return Value.value( System.identityHashCode( receiver ) );
+        return Value.box( System.identityHashCode( receiver ) );
     }
 
 
     @Define
     public Value show( @Receiver Value receiver ) {
         if ( receiver == Value.base() ) {
-            return Value.value( "base" );
+            return Value.box( "base" );
         } else {
             Value hash = receiver.call( HASH );
-            return Value.value( String.format( "<value:hash=%s>" , hash ) );
+            return Value.box( String.format( "<value:hash=%s>" , hash ) );
         }
     }
 

src/main/java/org/kink_lang/kink/internal/Envs.java

             } else {
                 try {
                     Class< ? > klass = Modules.CLASS_LOADER.loadClass( specifier );
-                    env.set( new SetSite( klass.getSimpleName() ) , Value.value( klass ) );
+                    env.set( new SetSite( klass.getSimpleName() ) , Value.box( klass ) );
                 } catch ( ClassNotFoundException e ) {
                     throw new KinkException( e );
                 }
         Set< String > newImportedSymbols = new HashSet< String >( origImportedSymbols );
         newImportedSymbols.add( symbol );
         Set< String > unmodifiableSet = Collections.unmodifiableSet( newImportedSymbols );
-        env.set( SET_IMPORTED , Value.value( unmodifiableSet ) );
+        env.set( SET_IMPORTED , Value.box( unmodifiableSet ) );
     }
 
 

src/main/java/org/kink_lang/kink/internal/Identities.java

      */
     @Define
     public Value op_eq( @Receiver Value identity , Value target ) {
-        return Value.value( target.isSubOf( IDENTITY_PROTO )
+        return Value.box( target.isSubOf( IDENTITY_PROTO )
                 && identity.get( VALUE ) == target.get( VALUE ) );
     }
 
      */
     @Define
     public Value hash( @Receiver Value identity ) {
-        return Value.value( System.identityHashCode( identity.get( VALUE ) ) );
+        return Value.box( System.identityHashCode( identity.get( VALUE ) ) );
     }
 
 
     @Define
     public Value show( @Receiver Value identity ) {
         int hashCode = System.identityHashCode( identity.get( VALUE ) );
-        return Value.value( "<identity:hash=" + hashCode + ">" );
+        return Value.box( "<identity:hash=" + hashCode + ">" );
     }
 
 

src/main/java/org/kink_lang/kink/internal/NullMethods.java

 
     @Define( "can_into?" )
     public Value can_into_p( Class< ? > klass ) {
-        return Value.value( ! klass.isPrimitive() );
+        return Value.box( ! klass.isPrimitive() );
     }
 
 
 
     @Define
     public Value show() {
-        return Value.value( "null" );
+        return Value.box( "null" );
     }
 
 
     @Define
     public Value op_eq( Value another ) {
-        return Value.value( another.isSubOf( Value.value( null ) ) );
+        return Value.box( another.isSubOf( Value.box( null ) ) );
     }
 
 
     @Define
     public Value hash() {
-        return Value.value( 1857934331 );
+        return Value.box( 1857934331 );
     }
 
 

src/main/java/org/kink_lang/kink/internal/RandomNumbers.java

             int upperBoundExclusiveInt = upperBoundExclusive.intValue();
             Checker.check( upperBoundExclusiveInt > 0
                     , () -> Messages.upperBoundMustBePositive( upperBoundExclusiveInt ) );
-            return Value.value( rng.nextInt( upperBoundExclusiveInt ) );
+            return Value.box( rng.nextInt( upperBoundExclusiveInt ) );
         } else if ( Numbers.isIntegral( upperBoundExclusive ) ) {
             BigInteger upperBoundExclusiveBi = Numbers.toBigInteger( upperBoundExclusive );
             Checker.check( upperBoundExclusiveBi.signum() > 0
                     , () -> Messages.upperBoundMustBePositive( upperBoundExclusiveBi ) );
             if ( upperBoundExclusiveBi.equals( INT_MAX_PLUS_1 ) ) {
-                return Value.value( rng.nextInt() );
+                return Value.box( rng.nextInt() );
             } else {
                 return Numbers.normalize( randomBigInteger( rng , upperBoundExclusiveBi ) );
             }

src/main/java/org/kink_lang/kink/internal/box/BooleanEnhancer.java

 
         @Define
         public Value op_lognot( @Receiver Boolean bool ) {
-            return Value.value( ! bool );
+            return Value.box( ! bool );
         }
 
 
 
         @Define
         public CallResult op_logand( @Receiver Boolean receiver , Fun fun , Value... rest ) {
-            return ( receiver ? fun.tailCall() : Value.value( false ) );
+            return ( receiver ? fun.tailCall() : Value.box( false ) );
         }
 
 
         @Define
         public CallResult op_logor( @Receiver Boolean receiver , Fun fun , Value... rest ) {
-            return ( receiver ? Value.value( true ) : fun.tailCall() );
+            return ( receiver ? Value.box( true ) : fun.tailCall() );
         }
 
 
         @Define( "can_into?" )
         public Value can_into_p( @Receiver Value bl , Class< ? > klass ) {
             if ( bl.unbox() == null ) {
-                return Value.value( ! klass.isPrimitive() );
+                return Value.box( ! klass.isPrimitive() );
             } else {
-                return Value.value( klass.equals( boolean.class )
+                return Value.box( klass.equals( boolean.class )
                         || klass.isAssignableFrom( Boolean.class ) );
             }
         }
         @Define
         public Value show( @Receiver Value blVal ) {
             Boolean bl = (Boolean) blVal.unbox();
-            return Value.value( bl == null ? "null-boolean" : bl.toString() );
+            return Value.box( bl == null ? "null-boolean" : bl.toString() );
         }
 
 
         @Define( "bool??" )
         public Value bool_pp( @Receiver Value boolVal ) {
-            return Value.value( boolVal.unbox() != null );
+            return Value.box( boolVal.unbox() != null );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/CharacterEnhancer.java

         public Value can_into_p( @Receiver Value chValue , Class< ? > klass ) {
             Character ch = (Character) chValue.unbox();
             if ( ch == null ) {
-                return Value.value( ! klass.isPrimitive() );
+                return Value.box( ! klass.isPrimitive() );
             } else {
-                return Value.value( klass == char.class
+                return Value.box( klass == char.class
                         || klass.isAssignableFrom( Character.class ) );
             }
         }
         @Define
         public Value code_point( @Receiver Value chValue ) {
             Character ch = (Character) chValue.unbox();
-            return Value.value( (int) ch.charValue() );
+            return Value.box( (int) ch.charValue() );
         }
 
 
         @Define
         public Value to_str( @Receiver Value chValue ) {
             Character ch = (Character) chValue.unbox();
-            return Value.value( ch == null ? "null-string" : ch.toString() );
+            return Value.box( ch == null ? "null-string" : ch.toString() );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/ClassEnhancer.java

         if ( field != null ) {
             return new Callable< Value >() {
                 @Override public Value call() throws Exception {
-                    return Value.value( field.get( null ) );
+                    return Value.box( field.get( null ) );
                 }
             };
         }
         // Try to get a nested class
         Class< ? > nestedClass = Members.getDeclaredClassOrNull( klass , name );
         if ( nestedClass != null ) {
-            final Value classVal = Value.value( nestedClass );
+            final Value classVal = Value.box( nestedClass );
             return new Callable< Value >() {
                 @Override public Value call() {
                     return classVal;
                 ConstructorWrapper< ? > wrapper = wrappers.getConstructorWrapperNotNull( args );
                 Constructor< ? > targetConstr = wrapper.getRoutine();
                 Object[] convertedArguments = wrapper.convertArguments( args );
-                return Value.value( factory.newProxy( targetConstr , convertedArguments ) );
+                return Value.box( factory.newProxy( targetConstr , convertedArguments ) );
             } );
         }
 
         private static
         Fun interfaceProxyMaker( final Class< ? > intf , final ProxyFactory factory ) {
             return Fun.builder().build( receiver -> {
-                return Value.value( factory.newProxy() );
+                return Value.box( factory.newProxy() );
             } );
         }
 
         public static Value get_static( @Receiver Class< ? > klass , String fieldName )
                 throws Exception {
             Field field = getAccessibleDeclaredStaticField( klass , fieldName );
-            return Value.value( field.get( null ) );
+            return Value.box( field.get( null ) );
         }
 
 
         throws Exception {
             Field field = getAccessibleDeclaredStaticField( klass , fieldName );
             Object contentJava = content.call( INTO
-                    , Value.value( field.getType() ) ).unbox();
+                    , Value.box( field.getType() ) ).unbox();
             field.set( null , contentJava );
         }
 
         extend_base_var_missing( @Receiver Value klassVal , String symbol ) throws Exception {
             Class< ? > klass = (Class< ? >) klassVal.unbox();
             if ( klass == null ) {
-                return Value.value( new ValueList() );
+                return Value.box( new ValueList() );
             } else if ( Strings.isVerb( symbol ) ) {
                 ClassMethodSelector selector = ClassMethodSelector.of( klass , symbol );
-                return Value.value( selector.isEmpty()
+                return Value.box( selector.isEmpty()
                         ? new ValueList()
                         : new ValueList( selector.getMissingVerbHandlerValue() ) );
             } else {
                 Callable< Value > callable = getMissingDataCallable( klass , symbol );
-                return Value.value( callable != null
+                return Value.box( callable != null
                         ? new ValueList( callable.call() )
                         : new ValueList() );
             }
                 Signature samSignature = Sams.instance().getSamSignature( klass );
                 if ( samSignature != null ) {
                     Fun fun = args[ 0 ].asFun( () -> "\\0" );
-                    return Value.value( Sams.newSamProxy( klass , samSignature , fun ) );
+                    return Value.box( Sams.newSamProxy( klass , samSignature , fun ) );
                 }
             }
             ConstructorWrapperList constrWrappers = ConstructorWrapperList.of( klass );
             ConstructorWrapper constrWrapper
                 = constrWrappers.getConstructorWrapperNotNull( args );
             Object instance = constrWrapper.newInstance( args );
-            return Value.value( instance );
+            return Value.box( instance );
         }
 
 
         public Value new_with( @Receiver Class< ? > klass , Value... args ) throws Throwable {
             Checker.check( args.length % 2 == 0 , Messages::notEvenNumberOfArguments );
             ProxyFactory factory = newProxyFactory( klass , args );
-            return Value.value( factory.newProxy() );
+            return Value.box( factory.newProxy() );
         }
 
 
         public static Value with( @Receiver Class< ? > klass , final Value... args ) {
             Checker.check( args.length % 2 == 0 , Messages::notEvenNumberOfArguments );
             ProxyFactory factory = newProxyFactory( klass , args );
-            return Value.value( klass.isInterface()
+            return Value.box( klass.isInterface()
                     ? interfaceProxyMaker( klass , factory )
                     : classProxyMaker( klass , factory ) );
         }
 
         @Define( "sub_class_of?" )
         public static Value sub_class_of_p( @Receiver Class< ? > klass , Class< ? > target ) {
-            return Value.value( target.isAssignableFrom( klass ) );
+            return Value.box( target.isAssignableFrom( klass ) );
         }
 
 
                 Array.set( array , index , elem );
                 ++ index;
             }
-            return Value.value( array );
+            return Value.box( array );
         }
 
 
         public static Value new_array_with_size( @Receiver Class< ? > klass , Value countVal ) {
             int count = countVal.asInt( 0 , Integer.MAX_VALUE , () -> "\\0" );
             Object array = Array.newInstance( klass , count );
-            return Value.value( array );
+            return Value.box( array );
         }
 
 
         @Define( "class??" )
         public Value class_pp( @Receiver Value classVal ) {
-            return Value.value( classVal.unbox() != null );
+            return Value.box( classVal.unbox() != null );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/ClassMethodSelector.java

 
 
     /** Value of the missing verb handler. */
-    private final Value missingVerbHandlerValue = Value.value( new Fun() {
+    private final Value missingVerbHandlerValue = Value.box( new Fun() {
         @Override public Value run( Value receiver , Value[] args ) throws Throwable {
             // Selects an instance method
             Optional< MethodWrapper > optInstanceMethodWrapper
 
             // Selects a field
             if ( getField() != null && args.length == 0 ) {
-                return Value.value( getField().get( null ) );
+                return Value.box( getField().get( null ) );
             }
 
             // No matching action.

src/main/java/org/kink_lang/kink/internal/box/CollectVarargsHandler.java

             .toArray( Class< ? >[]::new );
         this.mandatoryTypeValues = Stream.of( types )
             .limit( types.length - 1 )
-            .map( Value::value )
+            .map( Value::box )
             .toArray( Value[]::new );
 
         // Varargs
         Class< ? > varargType = types[ types.length - 1 ];
         assert varargType.isArray() : "Type of varargs is not an array but " + varargType;
         this.varargComponentType = varargType.getComponentType();
-        this.varargComponentTypeValue = Value.value( this.varargComponentType );
+        this.varargComponentTypeValue = Value.box( this.varargComponentType );
     }
 
 

src/main/java/org/kink_lang/kink/internal/box/ComparableEnhancer.java

         @SuppressWarnings( "unchecked" )
         @Define
         public Value op_cmp( @Receiver Comparable one , Comparable another ) {
-            return Value.value( one.compareTo( another ) );
+            return Value.box( one.compareTo( another ) );
         }
 
 
         @SuppressWarnings( "unchecked" )
         @Define
         public Value op_lt( @Receiver Comparable one , Comparable another ) {
-            return Value.value( one.compareTo( another ) < 0 );
+            return Value.box( one.compareTo( another ) < 0 );
         }
 
 
         @SuppressWarnings( "unchecked" )
         @Define
         public Value op_le( @Receiver Comparable one , Comparable another ) {
-            return Value.value( one.compareTo( another ) <= 0 );
+            return Value.box( one.compareTo( another ) <= 0 );
         }
 
 
         @SuppressWarnings( "unchecked" )
         @Define
         public Value op_gt( @Receiver Comparable one , Comparable another ) {
-            return Value.value( one.compareTo( another ) > 0 );
+            return Value.box( one.compareTo( another ) > 0 );
         }
 
 
         @SuppressWarnings( "unchecked" )
         @Define
         public Value op_ge( @Receiver Comparable one , Comparable another ) {
-            return Value.value( one.compareTo( another ) >= 0 );
+            return Value.box( one.compareTo( another ) >= 0 );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/FunEnhancer.java

 
         @Define( "has_area?" )
         public Value has_area_p( @Receiver Fun fun ) {
-            return Value.value( fun.getArea() != null );
+            return Value.box( fun.getArea() != null );
         }
 
 
         public Value area( @Receiver Fun fun ) {
             Area area = fun.getArea();
             Checker.check( area != null , Messages::funHasNoArea );
-            return Value.value( area );
+            return Value.box( area );
         }
 
 
 
         @Define
         public Value with_no_trace( @Receiver Fun origFun ) {
-            return Value.value( origFun.withoutTraces() );
+            return Value.box( origFun.withoutTraces() );
         }
 
 
         @Define
         public static CallResult bind_recv( @Receiver final Fun origFun , final Value boundFor ) {
-            return Value.value( Fun.builder().buildVarArgs( ( receiver , args )
+            return Value.box( Fun.builder().buildVarArgs( ( receiver , args )
                         -> origFun.tailInvoke( null , null , boundFor , args ) ) );
         }
 
         public Value replace_match( @Receiver Fun fun , Value matchResult ) {
             // TODO make it a message resource
             String literal = fun.call( matchResult ).asString( () -> "replacement string" );
-            return Value.value( Matcher.quoteReplacement( literal ) );
+            return Value.box( Matcher.quoteReplacement( literal ) );
         }
 
 
         public Value show( @Receiver Value funVal ) {
             Fun fun = (Fun) funVal.unbox();
             if ( fun == null ) {
-                return Value.value( "null-fun#" + System.identityHashCode( funVal ) );
+                return Value.box( "null-fun#" + System.identityHashCode( funVal ) );
             } else if ( fun.getArea() == null ) {
-                return Value.value( fun.toString() );
+                return Value.box( fun.toString() );
             } else {
                 Area area = fun.getArea();
                 Program program = area.getProgram();
                 String text = program.getText();
                 String result = text.substring( area.getStartIndex() , area.getEndIndex() );
-                return Value.value( result );
+                return Value.box( result );
             }
         }
 
 
         @Define( "can_into?" )
         public Value can_into_p( @Receiver Value funVal , Class< ? > klass ) {
-            return Value.value( funVal.unbox() == null
+            return Value.box( funVal.unbox() == null
                     ? ! klass.isPrimitive()
                     : klass.isAssignableFrom( Fun.class ) || Sams.instance().isSamClass( klass ) );
         }
                 return funVal;
             } else {
                 if ( klass.isInstance( fun ) ) {
-                    return Value.value( fun );
+                    return Value.box( fun );
                 }
                 Signature samSignature = Sams.instance().getSamSignature( klass );
                 Checker.check( samSignature != null , () -> Messages.cannotConvertFunTo( klass ) );
-                return Value.value( Sams.newSamProxy( klass , samSignature , fun ) );
+                return Value.box( Sams.newSamProxy( klass , samSignature , fun ) );
             }
         }
 
 
         @Define( "fun??" )
         public Value fun_pp( @Receiver Value funVal ) {
-            return Value.value( funVal.unbox() != null );
+            return Value.box( funVal.unbox() != null );
         }
 
     }

src/main/java/org/kink_lang/kink/internal/box/InputStreamEnhancer.java

                 byte[] buffer = new byte[ targetSize ];
                 int readSize = stream.read( buffer );
                 if ( targetSize == readSize ) {
-                    return Value.value( buffer );
+                    return Value.box( buffer );
                 } else {
                     byte[] result = new byte[ readSize ];
                     System.arraycopy( buffer , 0 , result , 0 , readSize );
-                    return Value.value( result );
+                    return Value.box( result );
                 }
             } else {
                 byte[] buffer = new byte[ 4096 ];
                 while ( ( size = stream.read( buffer ) ) > 0 ) {
                     output.write( buffer , 0 , size );
                 }
-                return Value.value( output.toByteArray() );
+                return Value.box( output.toByteArray() );
             }
         }
 
             while ( ( size = reader.read( buffer ) ) > 0 ) {
                 builder.append( buffer , 0 , size );
             }
-            return Value.value( builder.toString() );
+            return Value.box( builder.toString() );
         }
 
 
             }
             byte[] bytes = output.toByteArray();
             String line = new String( bytes , charset );
-            return Value.value( line );
+            return Value.box( line );
         }
 
 
                 builder.setLength( 0 );
                 readLineIncludingTerminator( reader , builder );
                 if ( builder.length() == 0 ) {
-                    return Value.value( lines );
+                    return Value.box( lines );
                 } else {
-                    lines.getElements().add( Value.value( builder.toString() ) );
+                    lines.getElements().add( Value.box( builder.toString() ) );
                 }
             }
         }
                 builder.setLength( 0 );
                 readLineIncludingTerminator( reader , builder );
                 if ( builder.length() == 0 ) {
-                    return Value.value( new ValueList() );
+                    return Value.box( new ValueList() );
                 } else {
-                    return Value.value( new ValueList( Value.value( builder.toString() ) ) );
+                    return Value.box( new ValueList( Value.box( builder.toString() ) ) );
                 }
             } );
-            return Modules.find( "SEQ" ).tailCall( ONE_SHOT , Value.value( fun ) );
+            return Modules.find( "SEQ" ).tailCall( ONE_SHOT , Value.box( fun ) );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/MetaValueEnhancer.java

         @Define
         public Value show( @Receiver Value meta ) {
             Value unmeta = (Value) meta.unbox();
-            return Value.value( unmeta == null
+            return Value.box( unmeta == null
                     ? "null-metavalue"
                     : "meta(" + unmeta.toString() + ")" );
         }
 
         @Define( "meta??" )
         public Value meta_pp( @Receiver Value metaVal ) {
-            return Value.value( metaVal.unbox() != null );
+            return Value.box( metaVal.unbox() != null );
         }
 
         // checkstyle-on Javadoc

src/main/java/org/kink_lang/kink/internal/box/MethodWrapper.java

                     ValueWrapper valueWrapper = (ValueWrapper) resultObj;
                     return valueWrapper.getValue();
                 } else {
-                    return Value.value( resultObj );
+                    return Value.box( resultObj );
                 }
             }
         }.call();

src/main/java/org/kink_lang/kink/internal/box/NotCollectVarargsHandler.java

     NotCollectVarargsHandler( Class< ? > ... types ) {
         this.types = types;
         this.typeValues = Stream.of( types )
-            .map( type -> Value.value( type ) )
+            .map( type -> Value.box( type ) )
             .toArray( Value[]::new );
     }
 

src/main/java/org/kink_lang/kink/internal/box/ObjectEnhancer.java

             Object owner = ownerVal.unbox();
             String fieldName = fieldNameVal.asString( () -> "\\0" );
             Field field = getAccessibleInstanceField( owner.getClass() , fieldName );
-            return Value.value( field.get( owner ) );
+            return Value.box( field.get( owner ) );
         }
 
 
             String fieldName = fieldNameVal.asString( () -> "\\0" );
             Field field = getAccessibleInstanceField( owner.getClass() , fieldName );
             Object contentJava = content.call( INTO
-                    , Value.value( field.getType() ) ).unbox();
+                    , Value.box( field.getType() ) ).unbox();
             field.set( owner , contentJava );
         }
 
             if ( Strings.isVerb( symbol ) && receiver != null ) {
                 ObjectMethodSelector selector
                     = ObjectMethodSelector.of( receiver.getClass() , symbol );
-                return Value.value( selector.isEmpty()
+                return Value.box( selector.isEmpty()
                         ? new ValueList()
                         : new ValueList( selector.getMissingVerbHandlerValue() ) );
             } else {
-                return Value.value( new ValueList() );
+                return Value.box( new ValueList() );
             }
         }
 
 
         @Define( "can_into?" )
         public Value can_into_p( @Receiver Value receiverVal , Class< ? > klass ) {
-            return Value.value( klass.isInstance( receiverVal.unbox() ) );
+            return Value.box( klass.isInstance( receiverVal.unbox() ) );
         }
 
 
         public Value show( @Receiver Value receiverVal ) {
             Object receiver = receiverVal.unbox();
             if ( receiver == null ) {
-                return Value.value( String.format( "#%d"
+                return Value.box( String.format( "#%d"
                             , System.identityHashCode( receiverVal ) ) );
             } else {
-                return Value.value( String.format( "<%s:toString=%s>"
+                return Value.box( String.format( "<%s:toString=%s>"
                             , receiver.getClass().getName()
                             , Strings.show( receiver.toString() ) ) );
             }
             Object receiver = receiverVal.unbox();
             Object another = anotherVal.unbox();
             if ( receiver == null ) {
-                return Value.value( receiverVal == anotherVal );
+                return Value.box( receiverVal == anotherVal );
             } else {
-                return Value.value( receiver.equals( another ) );
+                return Value.box( receiver.equals( another ) );
             }
         }
 
         @Define
         public Value hash( @Receiver Value receiver ) {
             Object object = receiver.unbox();
-            return Value.value( object == null
+            return Value.box( object == null
                     ? System.identityHashCode( receiver )
                     : object.hashCode() );
         }
 
         @Define( "object??" )
         public Value object_pp( @Receiver Value objVal ) {
-            return Value.value( objVal.unbox() != null );
+            return Value.box( objVal.unbox() != null );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/ObjectMethodSelector.java

 
 
     /** Value of the missing verb handler. */
-    private final Value missingVerbHandlerValue = Value.value( new Fun() {
+    private final Value missingVerbHandlerValue = Value.box( new Fun() {
         @Override public Value run( Value receiverVal , Value[] args ) throws Throwable {
             Object receiver = receiverVal.unbox();
             Optional< MethodWrapper > optMethodWrapper = getMethodWrappers().findRoutineWrapper( args );
             if ( optMethodWrapper.isPresent() ) {
                 return optMethodWrapper.get().invoke( receiver , args );
             } else if ( getField() != null && args.length == 0 ) {
-                return Value.value( getField().get( receiver ) );
+                return Value.box( getField().get( receiver ) );
             } else {
                 throw new KinkException(
                     Messages.noMatchingJavaMethod( receiverVal , symbol , args ) );

src/main/java/org/kink_lang/kink/internal/box/ProxyMethodAdder.java

             STRINGTYPE , AREATYPE , VALUETYPE , Type.getType( Value[].class ) } );
 
 
-    /** Method of {@link Value#value(Value)}. */
-    private static final Method VALUE_METHOD
-        = new Method( "value" , VALUETYPE , new Type[] { Type.getType( Object.class ) } );
+    /** Method of {@link Value#box(Object)}. */
+    private static final Method BOX_METHOD
+        = new Method( "box" , VALUETYPE , new Type[] { Type.getType( Object.class ) } );
 
 
     /** Adds instructions to call the proxy function. */
         writer.push( (String) null );
         writer.push( (String) null );
         writer.loadThis();
-        writer.invokeStatic( VALUETYPE , VALUE_METHOD );
+        writer.invokeStatic( VALUETYPE , BOX_METHOD );
         if ( parameterTypes.length < INVOKE_METHODS.length ) {
             Method invokeMethod = INVOKE_METHODS[ parameterTypes.length ];
             for ( int index = 0 ; index < parameterTypes.length ; ++ index ) {
                 , "INTO" , Type.getType( GetSite.class ) );
         writer.push( Type.getType( this.method.getReturnType() ) );
         writer.invokeStatic( VALUETYPE
-                , Method.getMethod( "org.kink_lang.kink.Value value(Object)" ) );
+                , Method.getMethod( "org.kink_lang.kink.Value box(Object)" ) );
         writer.invokeVirtual( VALUETYPE , VALUECALL );
         writer.invokeVirtual( VALUETYPE , Method.getMethod( "java.lang.Object unbox()" ) );
         if ( this.method.getReturnType().isPrimitive() ) {
         Class< ? > argType = this.parameterTypes[ index ];
         if ( argType.equals( int.class ) ) {
             writer.invokeStatic( VALUETYPE
-                    , Method.getMethod( "org.kink_lang.kink.Value value(int)" ) );
+                    , Method.getMethod( "org.kink_lang.kink.Value box(int)" ) );
         } else if ( argType.equals( boolean.class ) ) {
             writer.invokeStatic( VALUETYPE
-                    , Method.getMethod( "org.kink_lang.kink.Value value(boolean)" ) );
+                    , Method.getMethod( "org.kink_lang.kink.Value box(boolean)" ) );
         } else if ( argType.equals( Object.class ) ) {
             Label unwrapValueWrapper = writer.newLabel();
             Label nextArg = writer.newLabel();
             writer.instanceOf( Type.getType( ValueWrapper.class ) );
             writer.ifZCmp( GeneratorAdapter.NE , unwrapValueWrapper );
             writer.invokeStatic( VALUETYPE
-                    , Method.getMethod( "org.kink_lang.kink.Value value(Object)" ) );
+                    , Method.getMethod( "org.kink_lang.kink.Value box(Object)" ) );
             writer.goTo( nextArg );
             writer.mark( unwrapValueWrapper );
             writer.checkCast( Type.getType( ValueWrapper.class ) );
                 writer.box( Type.getType( argType ) );
             }
             writer.invokeStatic( VALUETYPE
-                    , Method.getMethod( "org.kink_lang.kink.Value value(Object)" ) );
+                    , Method.getMethod( "org.kink_lang.kink.Value box(Object)" ) );
         }
     }
 

src/main/java/org/kink_lang/kink/internal/box/RandomEnhancer.java

         produce_int_seq( @Receiver final Random rng , final Number upperBoundExclusive ) {
             Fun fun = Fun.builder().build( receiver -> {
                 Value numVal = RandomNumbers.randomNumber( rng , upperBoundExclusive );
-                return Value.value( new ValueList( numVal ) );
+                return Value.box( new ValueList( numVal ) );
             } );
-            return Modules.find( "SEQ" ).tailCall( ONE_SHOT , Value.value( fun ) );
+            return Modules.find( "SEQ" ).tailCall( ONE_SHOT , Value.box( fun ) );
         }
 
 
         @Define( "random_number_generator??" )
         public Value random_number_generator_pp( @Receiver Value rngVal ) {
-            return Value.value( rngVal.unbox() != null );
+            return Value.box( rngVal.unbox() != null );
         }
 
 

src/main/java/org/kink_lang/kink/internal/box/StringEnhancer.java

      *     If 'matcher' method does not return an instance of {@linkplain Matcher}.
      */
     static Matcher matcherOfPattern( Value patternVal , CharSequence charSequence ) {
-        Value matcherVal = patternVal.call( MATCHER_GET_SITE , Value.value( charSequence ) );
+        Value matcherVal = patternVal.call( MATCHER_GET_SITE , Value.box( charSequence ) );
         Checker.check( matcherVal.unbox() instanceof Matcher
                 , () -> Messages.wrongResultOfMatcher( patternVal , matcherVal ) );
         return (Matcher) matcherVal.unbox();
 
         @Define
         public static Value count( @Receiver String str ) {
-            return Value.value( str.length() );
+            return Value.box( str.length() );
         }
 
 
         @Define
         public static Value get( @Receiver String str , Value indexVal ) {
             int index = indexVal.asIndex( str.length() , () -> "\\0" );
-            return Value.value( String.valueOf( str.charAt( index ) ) );
+            return Value.box( String.valueOf( str.charAt( index ) ) );
         }
 
 
                 , @Optional Value patternVal , @Optional Number startIndexNum ) {
             if ( patternVal == null ) {
                 Checker.check( ! str.isEmpty() , Messages::emptyString );
-                return Value.value( String.valueOf( str.charAt( 0 ) ) );
+                return Value.box( String.valueOf( str.charAt( 0 ) ) );
             } else {
                 int start = ( startIndexNum != null
                         ? Numbers.truncateIntegralAsInt( startIndexNum , 0 , str.length() )
                 CharSequence target = str.subSequence( start , str.length() );
                 Matcher matcher = matcherOfPattern( patternVal , target );
                 if ( matcher.find() ) {
-                    return Value.value( matcher.group() );
+                    return Value.box( matcher.group() );
                 } else {
                     throw new KinkException( Messages.noSubstr( patternVal ) );
                 }
                 , @Optional Value patternVal , @Optional Number endIndexNum ) {
             if ( patternVal == null ) {
                 Checker.check( ! str.isEmpty() , Messages::emptyString );
-                return Value.value( String.valueOf( str.charAt( str.length() - 1 ) ) );
+                return Value.box( String.valueOf( str.charAt( str.length() - 1 ) ) );
             } else {
                 int end = ( endIndexNum != null
                         ? Numbers.truncateIntegralAsInt( endIndexNum , 0 , str.length() )
                 while ( matcher.find() ) {
                     group = matcher.group();
                 }
-                return Value.value( group );
+                return Value.box( group );
             }
         }
 
         @Define
         public static Value op_add( @Receiver String str , Value another ) {
             String anotherStr = another.call( TO_STR ).asString( () -> Messages.resultOf( ".to_str" ) );
-            return Value.value( str + anotherStr );
+            return Value.box( str + anotherStr );
         }
 
 
         @Define
         public static Value op_mul( @Receiver String str , Number countNumber ) {
             if ( str.isEmpty() ) {
-                return Value.value( "" );
+                return Value.box( "" );
             } else {
                 long count = Numbers.truncateIntegralAsLong( countNumber , 0 , Long.MAX_VALUE );
                 Checker.check( count <= Integer.MAX_VALUE / str.length()
                 for ( int i = 0 ; i < count ; ++ i ) {
                     builder.append( str );
                 }
-                return Value.value( builder.toString() );
+                return Value.box( builder.toString() );
             }
         }
 
         public static Value to_list( @Receiver String str ) {
             ValueList list = new ValueList( str.length() );
             for ( int index = 0 ; index < str.length() ; index++ ) {
-                list.getElements().add( Value.value( str.substring( index , index + 1 ) ) );
+                list.getElements().add( Value.box( str.substring( index , index + 1 ) ) );
             }
-            return Value.value( list );
+            return Value.box( list );
         }
 
 
         public static Value chars( @Receiver String str ) {
             ValueList chars = new ValueList( str.length() );
             for ( int index = 0 ; index < str.length() ; index++ ) {
-                chars.getElements().add( Value.value( str.charAt( index ) ) );
+                chars.getElements().add( Value.box( str.charAt( index ) ) );
             }
-            return Value.value( chars );
+            return Value.box( chars );
         }
 
 
             int index = 0;
             while ( index < str.length() ) {
                 int codePoint = str.codePointAt( index );
-                codePoints.getElements().add( Value.value( codePoint ) );
+                codePoints.getElements().add( Value.box( codePoint ) );
                 index += ( codePoint <= Character.MAX_VALUE ? 1 : 2 );
             }
-            return Value.value( codePoints );
+            return Value.box( codePoints );
         }
 
 
             int prevEnd = 0;
             while ( matcher.find() ) {
                 String line = str.substring( prevEnd , matcher.end() );
-                result.getElements().add( Value.value( line ) );
+                result.getElements().add( Value.box( line ) );
                 prevEnd =  matcher.end();
             }
             if ( prevEnd != str.length() ) {
                 String lastLine = str.substring( prevEnd );
-                result.getElements().add( Value.value( lastLine ) );
+                result.getElements().add( Value.box( lastLine ) );
             }
-            return Value.value( result );
+            return Value.box( result );
         }
 
 
         @Define
         public static Value head( @Receiver String str , Number countNumber ) {
             int count = Numbers.truncateIntegralAsInt( countNumber , 0 , str.length() );
-            return Value.value( str.substring( 0 , count ) );
+            return Value.box( str.substring( 0 , count ) );
         }
 
 
         @Define
         public static Value drop_head( @Receiver String str , Number fromNumber ) {
             int from = Numbers.truncateIntegralAsInt( fromNumber , 0 , str.length() );
-            return Value.value( str.substring( from , str.length() ) );
+            return Value.box( str.substring( from , str.length() ) );
         }
 
 
         slice( @Receiver String str , Number fromNumber , Number toNumber ) {
             int from = Numbers.truncateIntegralAsInt( fromNumber , 0 , str.length() );
             int to = Numbers.truncateIntegralAsInt( toNumber , from , str.length() );
-            return Value.value( str.substring( from , to ) );
+            return Value.box( str.substring( from , to ) );
         }
 
 
         @Define
         public static Value tail( @Receiver String str , Number countNumber ) {
             int count = Numbers.truncateIntegralAsInt( countNumber , 0 , str.length() );
-            return Value.value( str.substring( str.length() - count , str.length() ) );
+            return Value.box( str.substring( str.length() - count , str.length() ) );
         }
 
 
         @Define
         public static Value drop_tail( @Receiver String str , Number countNumber ) {
             int count = Numbers.truncateIntegralAsInt( countNumber , 0 , str.length() );
-            return Value.value( str.substring( 0 , str.length() - count ) );
+            return Value.box( str.substring( 0 , str.length() - count ) );
         }
 
 
         @Define( "empty?" )
         public Value empty_p( @Receiver String str ) {
-            return Value.value( str.isEmpty() );
+            return Value.box( str.isEmpty() );
         }
 
 
         public static Value any_p( @Receiver String str
                 , @Optional Value patternVal , @Optional Number indexNumber ) {
             if ( patternVal == null ) {
-                return Value.value( ! str.isEmpty() );
+                return Value.box( ! str.isEmpty() );
             }
             int start = ( indexNumber == null
                     ? 0
                     : Numbers.truncateIntegralAsInt( indexNumber , 0 , str.length() ) );
             CharSequence target = str.subSequence( start , str.length() );
             Matcher matcher = matcherOfPattern( patternVal , target );
-            return Value.value( matcher.find() );
+            return Value.box( matcher.find() );
         }
 
 
         @Define( "starts_with?" )
         public static Value starts_with_p( @Receiver String str , String target ) {
-            return Value.value( str.startsWith( target ) );
+            return Value.box( str.startsWith( target ) );
         }
 
 
         @Define( "ends_with?" )
         public static Value ends_with_p( @Receiver String str , String target ) {
-            return Value.value( str.endsWith( target ) );
+            return Value.box( str.endsWith( target ) );
         }
 
 
         @Define( "verb?" )
         public Value verb_p( @Receiver String str ) {
-            return Value.value( Strings.isVerb( str ) );
+            return Value.box( Strings.isVerb( str ) );
         }
 
 
         @Define( "public_verb?" )
         public Value public_verb_p( @Receiver String str ) {
-            return Value.value( Strings.isPublicVerb( str ) );
+            return Value.box( Strings.isPublicVerb( str ) );
         }
 
 
         @Define( "noun?" )
         public Value noun_p( @Receiver String str ) {
-            return Value.value( Strings.isNoun( str ) );
+            return Value.box( Strings.isNoun( str ) );
         }
 
 
             CharSequence target = str.subSequence( start , str.length() );
             Matcher matcher = matcherOfPattern( patternVal , target );
             if ( matcher.find() ) {
-                return Value.value( start + matcher.start() );
+                return Value.box( start + matcher.start() );
             } else {
                 throw new KinkException( Messages.noSubstr( patternVal ) );
             }
             Matcher matcher = matcherOfPattern( patternVal , orig );
             if( matcher.find() ) {
                 StringBuffer builder = new StringBuffer();
-                Value matchResult = Value.value( matcher.toMatchResult() );
+                Value matchResult = Value.box( matcher.toMatchResult() );
                 String replacement = subProvider.call( REPLACE_MATCH , matchResult )
                     .asString( () -> Messages.resultOf( ".replace_match" ) );
                 matcher.appendReplacement( builder , replacement );
                 matcher.appendTail( builder );
-                return Value.value( builder.toString() );
+                return Value.box( builder.toString() );
             } else {
                 return origVal;
             }
             Matcher matcher = matcherOfPattern( patternVal , orig );
             StringBuffer builder = new StringBuffer();
             while ( matcher.find() ) {
-                Value matchResult = Value.value( matcher.toMatchResult() );
+                Value matchResult = Value.box( matcher.toMatchResult() );
                 String replacement = subProvider.call( REPLACE_MATCH , matchResult )
                     .asString( () -> Messages.resultOf( ".replace_match" ) );
                 matcher.appendReplacement( builder , replacement );
             }
             matcher.appendTail( builder );
-            return Value.value( builder.toString() );
+            return Value.box( builder.toString() );
         }
 
 
         @Define
         public Value op_div( @Receiver String orig , Value patternVal ) {
             if ( orig.isEmpty() ) {
-                return Value.value( new ValueList() );
+                return Value.box( new ValueList() );
             }
             Matcher matcher = matcherOfPattern( patternVal , orig );
             ValueList list = new ValueList();
             int prevEnd = 0;
             while ( matcher.find() ) {
                 String field = orig.substring( prevEnd , matcher.start() );
-                list.getElements().add( Value.value( field ) );
+                list.getElements().add( Value.box( field ) );
                 prevEnd = matcher.end();
             }
-            list.getElements().add( Value.value( orig.substring( prevEnd ) ) );
-            return Value.value( list );
+            list.getElements().add( Value.box( orig.substring( prevEnd ) ) );
+            return Value.box( list );
         }
 
 
         @Define
         public Value matcher( @Receiver String pattern , CharSequence kase ) {
             Matcher matcher = Pattern.compile( pattern , Pattern.LITERAL ).matcher( kase );
-            return Value.value( matcher );
+            return Value.box( matcher );
         }
 
 
         @Define
         public static Value replace_match( @Receiver String literal , Value matcher ) {
-            return Value.value( Matcher.quoteReplacement( literal ) );
+            return Value.box( Matcher.quoteReplacement( literal ) );
         }
 
 
                     Matcher matcher = regex.matcher( kaseStr );
                     if ( matcher.matches() ) {
                         MatchResult matchResult = matcher.toMatchResult();
-                        return body.tailCall( Value.value( matchResult ) );
+                        return body.tailCall( Value.box( matchResult ) );
                     }
                 } else {
                     if ( pat.matches( kase ) ) {
 
         @Define
         public static Value trim( @Receiver String str ) {
-            return Value.value( str.trim() );
+            return Value.box( str.trim() );
         }
 
 
         @Define
         public static Value chomp( @Receiver String str ) {
-            return Value.value( Strings.chomp( str ) );
+            return Value.box( Strings.chomp( str ) );
         }
 
 
                     : radixVal.asInt( 2 , 36 , () -> "\\0" ) );
             for ( int index = 0 ; index < str.length() ; index ++ ) {
                 if ( ! isDigit( str.charAt( index ) , radix ) ) {
-                    return Value.value( false );
+                    return Value.box( false );
                 }
             }
-            return Value.value( true );
+            return Value.box( true );
         }
 
 
         @Define
         public static Value encode( @Receiver String str , @Optional Value charsetVal ) {
             Charset charset = Strings.getCharset( charsetVal );