Abstract:
An embodiment of the present invention consists of methods for parameter declaration in implicit way and of methods for argument usage in implicit way. An embodiment of the present invention is useful in programming languages which support at least one concept that can be interpreted as a method. This invention: raises code readability; reduces redundancy of parameter name and parameter type information making specific parts of the programming language code more compact; allows reduction of global variables making code more parallelizable and suitable for parallel computing systems.

Description:
REFERENCES CITED 
     U.S. Patent Documents 
     
         
         1. 2007/0142929 A1 June 2007 Pereira. 
       
    
     Other Sources 
     
         
         2. 2. C# language specification version 5.0, Microsoft Corporation. 
         3. Jon Skeet: C# in Depth, Third Edition, Manning (2013). 
         4. 4. Scala language documentation. 
       
    
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
       The system and methods for providing implicit parameters and implicit arguments usage are further described with a reference to the accompanying drawings in which: 
         FIG. 1 . shows method overloading example. 
         FIG. 2 . shows an example, where using conditional operator some code branches may become unnecessary. 
         FIG. 3 . shows method overloading example, which reduces unnecessary code branching problem. 
         FIG. 4 . shows optional argument (parameter default value) declaration example. 
         FIG. 5 . shows method (shown in  FIG. 4 .) calling examples. 
         FIG. 6 . shows results of method calling examples shown in  FIG. 5 . 
         FIG. 7 . shows invalid method (declared in  FIG. 4 .) calling example. 
         FIG. 8 . shows results of method (declared in  FIG. 4 .) calling example, where first and third arguments are provided and the third argument is named argument. 
         FIG. 9 . shows example of parameter passed by value, parameter passed by reference and output parameter. 
         FIG. 10 . shows Scala implicit parameter example. 
         FIG. 11 . shows invalid Scala implicit parameter example, when trying to declare multiple Scala implicit parameters of the same type. 
         FIG. 12 . shows example method declared in the C# programming language demonstrating interpretation of the different parts of method. 
         FIG. 13 . shows simple example of implicit parameter declaration. 
         FIG. 14 . shows method DoSomething2 (defined in  FIG. 13 .) rewritten without using implicit parameters. 
         FIG. 15 . shows execution example of DoSomething2 (defined in  FIG. 13 . with an alternative example defined in  FIG. 14 .). 
         FIG. 16 . shows example with several parameters defined implicitly. 
         FIG. 17 . shows method DoSomething3 (defined in  FIG. 16 .) rewritten without using implicit parameters. 
         FIG. 18 . shows execution example of method DoSomething3 (defined in  FIG. 16 . and alternative example defined in  FIG. 17 .). 
         FIG. 19 . shows how to reuse implicit parameter in the method body. 
         FIG. 20 . shows method DoSomething4 (defined in  FIG. 20 .) rewritten without using implicit parameters. 
         FIG. 21 . shows example of implicit parameter declaration as a part of method call statement-expression. 
         FIG. 22 . shows methods DoSomething5 and DoSomething6 (defined in  FIG. 21 .) rewritten without using implicit parameters. 
         FIG. 23 . shows example of anonymous implicit parameter. 
         FIG. 24 . shows method DoSomething7 (defined in  FIG. 23 .) rewritten without using implicit parameters. 
         FIG. 25 . shows usage of many anonymous implicit parameters in one method. 
         FIG. 26 . shows method DoSomething8 (defined in  FIG. 25 .) rewritten without using implicit parameters. 
         FIG. 27 . shows anonymous implicit parameter declaration as a part of method call expression. 
         FIG. 28 . shows methods DoSomething9 and DoSomething10 (defined in  FIG. 27 .) rewritten without using implicit parameters. 
         FIG. 29 . shows example of implicit parameter declaration by using canonical declaration form in assignment statement-expression. 
         FIG. 30 . shows method DoSomething11 (defined in  FIG. 29 .) rewritten without using implicit parameters. 
         FIG. 31 . shows invalid example of implicit parameter declaration in canonical form. Type of variable x cannot be detected from usage context. 
         FIG. 32 . shows canonical form of implicit parameter declaration as a part of method call statement-expression. 
         FIG. 33 . shows method DoSomething13 (defined in  FIG. 32 .) rewritten without using implicit parameters. 
         FIG. 34 . shows implicitly defined parameter in canonical form, passed by reference. 
         FIG. 35 . shows method DoSomething14 (defined in  FIG. 34 .) rewritten without using implicit parameters. 
         FIG. 36 . shows implicitly defined output parameter in canonical form. 
         FIG. 37 . shows method DoSomething15 (defined in  FIG. 36 .) rewritten without using implicit parameters. 
         FIG. 38 . shows invalid example of method declaration containing output parameter. 
         FIG. 39 . shows example, when first parameter from the list of method parameters is not used first in algorithm defined in method body. Method is defined without using implicit parameters. 
         FIG. 40 . shows method PrintName (defined in  FIG. 39 .) rewritten using implicit parameters and using method DoNothingWith to affect order of implicit parameters in a list of method parameters (method signature). 
         FIG. 41 . shows different phases used to process program source code. 
         FIG. 42 . shows method PrintName (defined in  FIG. 39 .) rewritten using implicit parameters and operator “place”. 
         FIG. 43 . shows example of implicit arguments. 
         FIG. 44 . shows methods DoSomething17, DoSomething18 and DoSomething19 (defined in  FIG. 43 .) rewritten without using implicit arguments. 
         FIG. 45 . shows how call syntax inside method DoSomething19 ( FIG. 43 .) declaration still can be improved if we change DoSomething19 parameter names paramA and paramB, using the names param1 and param2. 
         FIG. 46 . shows DoSomething22 (declared in  FIG. 45 .), but using implicit arguments in DoSomething21 call and implicit parameters in DoSomething22 declaration itself. 
         FIG. 47 . shows methods DoSomething20, DoSomething21 and DoSomething22 (defined in  FIG. 45 .) rewritten without using implicit arguments. 
         FIG. 48 . shows example of implicit arguments naming conflict. 
         FIG. 49 . shows methods DoSomething23, DoSomething24 and DoSomething25 (defined in  FIG. 48 .) rewritten without using implicit arguments. 
         FIG. 50 . shows example of resolved implicit arguments naming conflict (introduced in  FIG. 48 .). 
         FIG. 51 . shows methods DoSomething25 (defined in  FIG. 50 .) rewritten without using implicit arguments. 
         FIG. 52 . shows example of implicit argument passed by reference, implicit output argument and implicit argument with method parameter modifier params. 
         FIG. 53 . shows method DoSomething27 (defined in  FIG. 52 .) rewritten without using implicit arguments. 
         FIG. 54 . shows example how implicit parameters and arguments can be used together with generics. 
         FIG. 55 . shows method DoSomething28 (defined in  FIG. 54 .) rewritten without using implicit parameters and arguments. 
         FIG. 56 . shows method DoSomething28 (defined in  FIG. 54 . and alternative defined in  FIG. 55 .) execution examples. 
         FIG. 57 . shows example how generics can be used in method chains together with implicit parameters and implicit arguments. 
         FIG. 58 . shows methods DoSomething29, DoSomething30 and DoSomething31 (defined in  FIG. 57 .) rewritten without using implicit parameters and arguments. 
         FIG. 59 . shows object set abstraction (meta-set) declaration and usage syntax. 
         FIG. 60 . shows how compiler would interpret example demonstrated in  FIG. 59 . 
         FIG. 61 . shows example in data querying language based on Prolog without using implicit parameters and arguments. 
         FIG. 62 . shows example in data querying language based on Prolog using implicit parameters and arguments. 
     
    
    
     BACKGROUND 
     The method overloading allows creating several methods with the same name, which differ from each other in the type of the input of the method. It is simply defined as the ability of one method to perform different tasks. Compiler identifies which of the overloaded methods to execute based on a number of arguments and their data types during compilation itself. 
     Pseudo code is used in all examples provided in this work. Pseudo code is based on the general purpose language C# [2] including implicit parameter and argument extension features. 
     The method overloading examples are shown in  FIG. 1 . When designing complex programs, the code changes and some branches may become unnecessary as shown in  FIG. 2 . In such cases overloaded methods can improve code readability as shown in  FIG. 3 ., because they provide more static information during the compile-time and they typically result in a better runtime performance. 
     This works fine for a single parameter, but some problems might occur, when there are multiple options. Each extra option doubles the number of possible overloads; and if two of them are of the same type, problems can arise due to trying to declare multiple methods with the same signature. Number of possible overloads could be significantly reduced with optional arguments 1 . [1, 2, 3]  1  Sometimes arguments are called: actual parameters. 
     Optional arguments are usually used when there are several values required for an operation, where the same values are used multiple times. Optional argument declaration example is shown in  FIG. 4 , method calling examples are provided in  FIG. 5 , which produces output shown in  FIG. 6 . 
     When supplying unnamed arguments, their order should match the order of parameters in the method declaration, it is not possible to supply first and third argument omitting second argument. The code shown in  FIG. 7 . is invalid. This problem can be solved by using named arguments. [3] 
     The basic idea of named arguments is that specifying an argument value it is also possible to specify the name of the parameter, which will receive value of specified argument. The compiler then makes sure that there is a parameter of the right name and uses the value for that parameter. Even on its own, this can increase readability in some cases. In reality, named arguments are the most useful in cases, where optional arguments are also likely to appear. 
     An example with supplying first and third arguments to method DoSomething1 ( FIG. 4 ) call is the following: 
     DoSomething1 (3, optionalInteger: 3); 
     Method call produces result shown in  FIG. 8 . 
     The named arguments and optional arguments affect how the compiler resolves overloads. Optional arguments can increase the number of applicable methods (if some methods have more parameters 2  than the number of specified arguments) and named arguments can decrease the number of applicable methods (by ruling out methods that do not have the appropriate parameter names).  2  Sometimes parameters are called: formal parameters. 
     The parameter names of a method are effectively part of the API. If you change them at a later date, code can break—anything that was using a named argument to refer to one of your parameters will fail to compile if you decide to change it. 
     All previously reviewed methods are methods with the parameters and arguments passed by value. If a parameter is declared for a method without ref or out, the parameter can have a value associated with it. That value can be changed in the method, but the changed value will not be retained, when control passes back to the calling procedure. [2] 
     The ref keyword causes an argument to be passed by reference, not by value. The effect of passing by reference is that any change to the parameter in the method is reflected in the underlying argument variable in the calling method. The value of a reference parameter is always the same as the value of the underlying argument variable. [2] 
     A parameter declared with an ‘out’ modifier is an output parameter. Similar to a reference parameter, an output parameter does not create a new storage location. Instead, an output parameter represents the same storage location as the variable given as the argument in the method invocation. A variable does not need to be definitely assigned before it can be passed as an output parameter, but following an invocation where a variable was passed as an output parameter, the variable is considered definitely assigned. [2] 
     In  FIG. 9 . examples of parameter passed by value, parameter passed by reference and output parameter are demonstrated. A reference and output parameter cannot have a default value, so these parameters cannot be optional. The required arguments cannot be omitted in method calls. 
     The Scala language specification [4] (current version 2.8) supports the feature called “implicit parameters” 3 , which is similar to optional arguments. Scala implicit parameters allow declaring the last parameter list of a function to be implicit. The syntax for this works as demonstrated in  FIG. 10 . (using Scala REPL 4 ).  3  Which in this paper are called “scala implicit parameters”, because they are declared outside of the method declaration. Historically idea of parameters is related to a method. If parameters are declared outside of method, then they are not parameters of method by definition, they are variables of scope higher than scope of method instead. 4  Read-eval-print loop. 
     It is possible to call speakImplicitly as normal but, additionally, we can leave out the implicit argument list and the compiler will look for a value in the enclosing scope, which has been marked as implicit. If we try to do that and there is no such value in scope, then the compiler will return error code. 
     Implicits are type safe and they are selected based on the static type of the arguments. This means that Scala implicit parameters allow implicit parameter reuse in the different functions. However, if there are multiple Scala implicit parameters of the same type, compiler will fail to use any, because it is not able to choose between them as demonstrated in  FIG. 11 . 
     All identified problems and limitations of the C# optional arguments and Scala implicit parameters can be solved with the implicit parameters and implicit arguments. 
     SUMMARY 
     An embodiment of the present invention provides methods for implicit parameter declaration and for implicit argument usage. Implicit parameters (formal parameters) and implicit arguments (actual parameters) can be used as: passed by value; passed by reference; output parameters; parameters that take a variable number of arguments; any form of parameters which does not require changes to implicit parameter/argument declaration syntax. Implicit parameters can be used in three different syntactic forms: full form—providing parameter name and type of the parameter; canonical form—providing only name of the parameter; anonymous parameter form—providing only type of the parameter. 
     An embodiment of the present invention is useful in programming languages, which support at least one concept that can be interpreted as a method. The invention raises code readability; reduces redundancy of the parameter name and parameter type information making specific parts of the programming language code more compact; allows reduction of global variables making code more parallelizable and suitable for parallel computing systems. 
     DETAILED DESCRIPTION 
     The implicit parameters operate by taking method parameters declaration from the method head part to the method body part (see  FIG. 12 .), where implicit parameter will be declared as an expression 5 . Implicit parameter declaration syntax:  5  Something which evaluates to a value. 
     ParameterType parameterName 
     where ParameterType specifies type of the parameter and parameterName specifies name of the parameter. 
     Implicit parameter declaration syntax is similar to the local variable declaration syntax: 
     local-variable-declarator identifier; 
     where local-variable-declarator specifies type of the local variable or keyword ‘var’; and identifier specifies name of the local variable. 
     Local variables are declared as statements 6 , but implicit parameters are declared as:
         (a) expressions of statements;   (b) expressions of complex expressions.  6  Code, which does something.       

     Local variable can be declared together with the initialization expression: 
     local-variable-declarator identifier=local-variable-initializer; 
     where local-variable-initializer is variable initialization expression. 
     Simple example of implicit parameter declaration in method DoSomething2, where implicit parameter is declared as a local-variable-initializer expression is shown in  FIG. 13 . Method DoSomething2 can be rewritten by using parameters declared in the method head part as shown in  FIG. 14 . 
     Type of formal parameters can be detected automatically from parameter declaration in the method body declaration. Method call information is not needed to detect type of the formal parameters. 
     Method DoSomething2 execution example is provided in  FIG. 15 . 
     In the method body, non-implicit parameters will be included in the list of method parameters first, followed by the implicitly defined parameters. If the method contains many implicit parameters, they are ordered in a list of method parameters according to their occurrence in the method body. The example shown in  FIG. 16 . demonstrates method DoSomething3 example with several parameters defined implicitly. Method DoSomething3 can be rewritten by using parameters declared in the method head part as shown in  FIG. 17 . Method DoSomething3 calling example is given in  FIG. 18 . 
     Method DoSomething4 shown in  FIG. 19 . demonstrates how to use implicit parameter in the method body more than once. Method DoSomething4 can be rewritten by using parameters declared in the method head part as shown if  FIG. 20 . 
     Methods DoSomething5 and DoSomething6, shown in  FIG. 21 ., demonstrate implicit parameter declaration as a part of method call statement-expression 7 . Methods DoSomething5 and DoSomething6 can be rewritten by using parameters declared in the method head part as shown in  FIG. 22 .  7  If syntactic form does not return value or syntactic form returns value and returned value is not used, then method call is interpreted as a statement; otherwise method call is interpreted as an expression. 
     Similarly, it is possible to declare implicit parameters as expressions of other statements (if statement; switch statement; while statement; for statement; and other statements, which accept expression as a part of its declaration syntax). It is possible to declare implicit parameters as expressions of some complex expressions as well (part of binary expression; part of assignment expression; part of unary expression, and part of other expressions, which accept expression as a part of its declaration syntax). 
     In many of the general purpose programming languages every action is performed in methods. Program entry point also is a method. Implicit parameter usage in program entry point method will lead to the compilation errors, because it would change method signature. However, the most important point is that the implicit parameters concept is consistent (similar in all methods). 
     Anonymous Implicit Parameters 
     Sometimes method parameters in the method body are used only once and they do not have to be used repeatedly. In such cases it would be useful to have anonymous implicit parameters, which can be declared instead of some expression, using the following syntactic form: 
     ParameterType 
     where ParameterType specifies type of anonymous implicit parameter, but name of anonymous implicit parameter is not specified. It will be generated automatically by compiler. Example of anonymous implicit parameter (method DoMethod7) is shown in  FIG. 23 . Method DoSomething7 can be rewritten by using parameters declared in the method head part as shown in  FIG. 24 . 
     Method DoSomething8 (shown in  FIG. 25 .) demonstrates usage of many anonymous implicit parameters. Method DoSomething8 can be rewritten by using parameters declared in the method head part as shown in  FIG. 26 . 
     The example of methods DoSomething9 and DoSomething10 shown in  FIG. 27 . demonstrates anonymous implicit parameter declaration as a part of method call expression. Methods DoSomething9 and DoSomething10 can be rewritten by using parameters declared in the method head part as shown in  FIG. 28 . 
     There are several cases, when type has different predefined meaning and it should not be interpreted as an anonymous method parameter, when used in the method body:
         (a) in relational expressions using ‘is’ operator:
           var thisIsFalse=6 is string;   
           (b) in relational expressions using ‘as’ operator:
           var thisIsObject=6 as object;   
           (c) in typeof-expressions using ‘typed’ operator:
           var myType=typeof(int);   
           (d) in cast-expressions:
           var myObject=(object)string.Empty;   
           (e) in object-creation-expressions:
           var thisIsNewObject=new object( );   
           (f) other cases or even some future modifications are theoretically possible.       

     However, in all 6 mentioned cases type is used as a final value and syntax does not allow supplying an expression instead. In all other cases, when type is used in place of some expression, it should be clearly interpreted as an anonymous implicit parameter. 
     Canonical Form of Implicit Parameter Declaration 
     In most cases, when defining implicit parameters, their types could be detected from the usage context. In such cases implicit parameter declaration syntax can be improved by removing type declaration part from implicit parameter declaration syntax. This shortened syntax is called canonical form of implicit parameter declaration syntax and its declaration, in place of some expression, is the following: 
     parameterName; 
     where parameterName specifies name of the parameter and type of the parameter will be inferred from its usage context. 
     Valid example of implicit parameter declaration in method DoSomething11 by using canonical declaration form in assignment statement-expression is shown in  FIG. 29 ., which can be rewritten by using parameters declared in the method head part as demonstrated in  FIG. 30 . 
     Invalid example, where type of variable x cannot be detected from usage context, is shown in  FIG. 31 . 
     The method DoSomething13 shown in  FIG. 32 . demonstrates canonical form of implicit parameter declaration as a part of method call statement-expression. Method DoSomething13 can be rewritten by using parameters declared in the method head part as shown in  FIG. 33 . 
     Canonical form of implicit parameters declaration forces all unknown identifiers located in the method body to be interpreted as implicit method parameters. This is logical and consistent (equal in all methods, even in program entry point). It solves problem of how to interpret unknown identifiers and what to do with them instead of throwing compile time errors. 
     Implicit Parameters with Parameter Modifiers 
     Similarly as implicit parameters (parameters passed by value), parameters passed by reference can be declared implicitly (in the method body). To do it, parameter modifier ‘ref’ should be used in the following syntactic form instead of some expression: 
     ref type identifier 
     where ‘type’ specifies type of the parameter and ‘identifier’ specifies name of the parameter. 
     Ref parameter can be used in canonical implicit parameter syntactic form: 
     ref identifier 
     where parameter type will be inferred from usage context. 
     Ref parameter also can be used in anonymous implicit parameter syntactic form: 
     ref type 
     where parameter name will be auto-generated by compiler. 
     Example of method DoSomething14 with implicitly defined parameter in canonical form passed by reference (used together with assignment statement-expression) is shown in  FIG. 34 . Method DoSomething14 can be rewritten by using parameters declared in the method head part as shown in  FIG. 35 . 
     Output parameters can be declared implicitly (in method body) by using keyword ‘out’ restricted by the following syntactic form: 
     out type identifier=expression; 
     where ‘type’ specifies type of parameter, ‘identifier’ specifies name of parameter and ‘expression’ is value or expression returning some value. 
     Out parameter can be used in canonical implicit parameter syntactic form: 
     out identifier=expression; 
     where parameter type will be inferred from usage context. 
     Out parameter also can be used in anonymous implicit parameter syntactic form: 
     out type 
     where parameter name will be auto-generated by compiler. 
     Example of method DoSomething15 with implicitly defined output parameter in canonical form is shown in  FIG. 36 . Method DoSomething15 can be rewritten by using parameters declared in the method head part as demonstrated in  FIG. 37 . 
     Method DoSomething16 (shown in  FIG. 38 ) demonstrates invalid example of method declaration containing output parameter, because value is not assigned to output parameter. 
     Implicit output parameter syntax is preferable, because it does not need additional context information to figure out if value is assigned to output parameter within method body or not. If implicit output parameter is defined, then by definition it is also assigned to some value and the both together contributes to the improvement of code readability. 
     Implicit Parameter Order in List of Method Parameters 
     First declared implicit parameter goes first in list of method parameters, but sometimes method parameters have to be in different order than required by algorithm declared in the method body. This situation is illustrated in method PrintName example using parameters declared in the method head part as shown in  FIG. 39 . 
     Implicit parameter order in list of method parameters can be changed by using any statement, for example, method DoNothingWith (shown in  FIG. 40 ., which accepts parameter, but does nothing with it) can be used to improve method PrintName declaration ( FIG. 40 ). 
     This way it is possible to make method PrintName to accept two parameters so, that first is firstName and second—lastName and the printing algorithm remains unchanged. However, the problem is that the method DoNothingWith is useless from the business logic perspective and in the optimisation phase (performed by compiler, see  FIG. 41 .) it should be removed from program. Better approach would be to create special operator named “place” which would act like method DoNothingWith. The operator “place” allows placing implicit parameters (defined as operator “place” argument expressions) into list of method (where the operator “place” is used) parameters without adding extra functional program logic to abstract syntax tree. The main benefit of operator “place” is that it can be standard, predefined way to define parameters in one order and process them in different order without adding extra program logic items to the abstract syntax tree. This way it is possible to process operator “place” in parsing phase reducing the need to be optimized in optimization phase. 
     Operator “place” is used as statement in following syntactic form: 
     place(listOfParameters); 
     Where listOfParameters is nonempty list containing comma separated implicit parameters and parameter declaration syntax is following: 
     type identifier 
     Where ‘type’ specifies type of the parameter and ‘identifier’ specifies name of the parameter. 
     Method PrintName can be improved by using operator “place” as shown in  FIG. 42 . 
     There are some specific cases, when it is not possible to implement feature using implicit parameters without operator “place”. One of such cases is anonymous recursion, but mostly is will be possible to achieve the desired result with implicit parameters and without using operator “place”. 
     Implicit Arguments 
     It is possible to omit optional arguments in method calls, but that cannot be done with the required arguments. Optional arguments require method parameters to be declared with assignment of default values. This means that if you want to use optional arguments, you should know it, when defining method and its parameters and you should have permissions to change declaration of method you want to call. Problem can be solved by inventing implicit arguments. 
     If method required arguments are omitted, then omitted arguments are automatically added as method signature parameters to method, from which the call is done. Example (methods: DoSomething17, DoSomething18, DoSomething19) is demonstrated in  FIG. 43 . 
     Example of calling method DoSomething17 is following: 
     DoSomething17(6, 36); 
     Methods DoSomething17, DoSomething18 and DoSomething19 can be rewritten without using implicit parameters and implicit arguments as follows shown in  FIG. 44 . 
     Parameter names of method DoSomething19 differ from parameter names of DoSomething18 and DoSomething17. DoSomething18 call syntax inside DoSomething19 declaration still can be improved if we change DoSomething19 parameter names paramA and paramB, using the names param1 and param2 instead as demonstrated in  FIG. 45  (using methods DoSomething20, DoSomething21 and DoSomething22). 
     Method DoSomething22 declaration is equivalent to example using implicit arguments in DoSomething21 call and implicit parameters in DoSomething22 declaration as shown in  FIG. 46 . Methods DoSomething20, DoSomething21 and DoSomething22 can be rewritten without using implicit parameters and implicit arguments as demonstrated in  FIG. 47 . 
     Using implicit arguments parameter names becomes part of API and in some cases it can lead to errors or undesired results. Consider the example of methods DoSomething23, DoSomething24 and DoSomething25 as shown in  FIG. 48 . Method DoSomething25 will have 3 implicit parameters; two of them being with the same name ‘param2’ but with different types. Such situation is not acceptable. Methods DoSomething23, DoSomething24 and DoSomething25 can be rewritten without using implicit parameters and implicit arguments as demonstrated in  FIG. 49 . Implicit argument naming conflict can be resolved by using different implicit parameters and rewriting method DoSomething25 as shown in  FIG. 50 . Method DoSomething25 can be rewritten without using implicit parameters as demonstrated in  FIG. 51 . 
     Implicit Arguments Together with Method Parameter Modifiers 
     Method parameter modifiers can be used together with the idea of implicit arguments if method parameter modifier is required in the method declaration. Examples of such method parameter modifiers are: ref (for reference parameters), out (for output parameters), params (for method parameter that takes a variable number of arguments). Example of implicit argument passed by reference, implicit output argument and implicit argument with method parameter modifier ‘params’ are shown in  FIG. 52 . (method DoSomething26 demonstrates parameter declaration and method DoSomething27 demonstrates implicit argument usage). Method DoSomething27 can be rewritten without using implicit parameters as demonstrated in  FIG. 53 . 
     Generics Together with Implicit Parameters and Implicit Arguments 
     Implicit parameters and arguments can be used together with generics and they do not affect general idea of implicit parameters and arguments. Simple example (method DoSomething28) using generic implicit parameter is shown in  FIG. 54 . Method DoSomething28 can be rewritten by using parameters declared in the method head part as demonstrated in  FIG. 55 . Method DoSomething28 execution examples are provided in  FIG. 56 . 
     In a similar way, generics can be used in method chains together with implicit parameters and implicit arguments as shown in  FIG. 57 ., where methods DoSomething29, DoSomething30 and DoSomething31 are provided. Methods DoSomething29, DoSomething30 and DoSomething31 can be rewritten without using implicit parameters and arguments as shown in  FIG. 58 . 
     Implicit Parameters and Arguments in any Concept that can be Interpreted as Method 
     Implicit parameters and arguments can be used in any concept which can be interpreted as method, for example: rule, query, and other concepts, even if they are used in different logics, for example, rule in predicate logics. This means that implicit parameters and arguments can be used not only in logics working with equality concept, but also in logics working with fewer strong forms than equality, for example: implication, “is implied by” operation and even with “not yet known” forms:
         1) “implication”, example a         b   2) “is implied by”, example: a         b   3) “some future operator form”, example: a someOperator b       

     Example of Data Querying Language Based on Prolog without Using Implicit Parameters and Arguments 
     Invoice (has properties Warehouse, DealDate, . . . ) and Warehouse are user defined types, but DateTime is system type representing date. Comma in rule definitions represents AND operator, semicolon represents end of statement, symbol ‘:-’ represents operator ‘is implied by’, and symbols ‘==’, ‘&gt;=’ and ‘&lt;’ represent comparison operators, which act as constraint builders for meta-sets. Meta-sets are abstractions of object sets, they should be interpreted as small queries which together form larger queries. Meta-sets (meta-set variables) are needed for the unification process to work correctly, so meta-sets should not be treated as implicit parameters or arguments (they are always required; theoretically they could be made implicit, but it would hurt code readability). When meta-set is used in scope of rule (method), real name of meta-set variable will be declared name of meta-set variable+randomly generated part (this process is done in background by parser and real name of meta-sets used in each rule is not known to programmer). 
     For example, the code shown in  FIG. 59 ., could be interpreted by parser in a way demonstrated in  FIG. 60 . This way it is possible to achieve concise syntax and, most important, to create a ground for unification to work correctly. The idea of implicit parameters and arguments is independent from the unification. For this reason this article does not cover meta-set unification in details. 
     Syntactic form: someVariable.SomeProperty is used to access property SomeProperty of specified object someVariable. Language semantics can be viewed as process of query building. Logic programming engine works with abstractions of object sets (combining together different meta-sets with different constraints), so the result of the process will be meta-set (abstraction), but from the meta-set query to database can be generated to retrieve real objects. Query declarations are needed to generate code from our language in any general purpose programming language. 
     Example in data querying language based on Prolog without using implicit parameters and arguments are provided in  FIG. 61 . The code uses global variables, which makes this code difficult to use in parallel systems. Besides, parameter (global variable) names and types are used in too many places. Code redundancy is a real problem in the domain specific languages, where languages consist of concepts which can be interpreted as methods. Usually these concepts contain lot of parts that can be interpreted as method parameters. 
     Example of Data Querying Language Based on Prolog Using Implicit Parameters and Arguments 
     Example in data querying language based on Prolog using implicit parameters and arguments is provided in  FIG. 62 . This approach allows thinking in terms of rules (more declarative approach) instead of method declaration and execution. At the same time, it preserves all benefits that can be gained, when rules are interpreted as methods. 
     In the above mentioned code example only canonical form of implicit parameters is used. Other forms of implicit parameters would be the same as described in the chapters introducing implicit parameters and arguments.