It is possible to have a method in this manner:
[obj mergeObjs:obj1,obj2,obj3,nil];
Or have a method in this manner:
[obj mergeObjs:obj1,obj2...obj(n),nil usingBlocks:blk1,blk2,blk3....blk(m),nil];
where n may or may not be equal to m.
Basically multiple variable argument lists in a single method declaration. ?
This is not a potential answer:
[obj merge:[NSArray arrayWithObjects:[NSArray arrayWithObjects:...,nil],[NSArray arrayWithObjects:...,nil]...,nil]];
Thanks in advance.
Here is the link i found for Single Variable Argument Lists:
http://developer.apple.com/library/mac/#qa/qa1405/_index.html
How to create variable argument methods in Objective-C
You can't achieve this with a variable length argument list, but have you considered just passing two arrays?
[obj mergeObjs:(NSArray*)objs usingBlocks:(NSArray*)blocks];
Modern versions of clang (the Objective C compiler used by recent Xcode releases) even support NSArray literals
[instance mergeObjs:#[obj1, obj2, obj3] usingBlocks:#[^{}, ...]];
(Of course, making sure to copy your blocks appropriately for insertion into an NSArray).
No. Message dispatch boils down to a call to objc_msgSend() (or one of its variants). That follows the C calling convention and there's no way to express the multiple variable argument lists in that convention.
Concluding based on the responses & a serious loss of hair -
It it not possible to have 2 variable argument lists in a method declaration.
The purpose of having mulit-Variable-argument-list was to provide more readability in my context.
Will make do with Arrays... Sigh!!.
Related
classdef Dog
end
d=Dog(); can size(d) be controlled? Is there some property to set or method to overload?
Ultimately I have like d.data = [1, 2, 3] and want length(d) == 3. I'm aware I can make d.length(). As an aside, is there a list of MATLAB "magic methods", i.e. functions that control interaction with classes, like subsref?
In MATLAB, don't think of class method as similar to class methods in other languages. Really, what they are is overloaded versions of a function.
size(d) is the same as d.size() (which is the same as d.size, parentheses are not needed to call a function), if d is an object of a custom class and size is overloaded for that class.
So, you can define function size in the methods section of your classdef, to overload size for your class. You can also create a size.m file within a #Dog/ directory to accomplish the same thing.
For example, if you create a file #char/size.m with a function definition inside, you will have overloaded size for char arrays.
The above is true for any function. Some functions, when overloaded, can cause headaches. For example be careful when overloading numel, as it could cause indexed assignment expressions to fail. size is used by the whos command to display variable information, as well as by the similar functionality in the GUI, so it is important to have it behave in the expected way.
The object behavior that you might want to change that is not obviously a function, relates to operators. Each operator is also defined by a function (including end in indexing!). See the docs for a full list.
Method types have no value. How do we evaluate a method?
Using SML as an example, I have
fun myFunc(x) = x + 5
val b = myFunc(2)
In the second expression, myFun has a type and a value, we use its type to do type checking and use its value together with its argument to evaluate value for b
But in Scala methods without a value how do we evaluate? I am pretty new to Scala so it may not be very clear.
def myFunc(x) = x + 5
val b = myFunc(2)
From val b = myFunc(2) to val b = 2 + 5, what happened in between? From where or what object do we know that myFunc(x) is x + 5?
THanks!!
The simple answer is: just because a method is not a value in the sense of "a thing that can be manipulated by you" doesn't mean that it is not a value in the sense of "a thing that can be manipulated by the author of the compiler".
Of course, a method will have an object representing it inside of the compiler. In fact, that object will probably look very similar to the object representing a function inside, say, the MLTon SML compiler or SML/NJ.
In SML, syntax is not a value, but you are not questioning how it is possible to write a function call either, aren't you? After all, in order to call a function in SML, I need to write a function call using function call syntax, so how can I do that when syntax is not a value?
Well, the answer is the same: just because syntax is not a value that the programmer can manipulate, the compiler (or more precisely the parser) obviously does know about syntax.
I can't tell you why the decision was made to have functions be values in Scala but not methods, but I can make a guess. Scala is an object-oriented language. In an object-oriented language, every value is an object, and every object has methods that are bound to that object. So, if methods are objects, they need to have methods, which are objects, which have methods, which are objects, and so on.
There are ways to deal with this, of course, but it makes the language more complex. For a similar reason, classes aren't objects (unlike, say, in Smalltalk, Python, and Ruby). Note that even in highly reflective, introspective, dynamic languages like Ruby, methods are not objects. Classes are, but not methods.
It is possible using reflection to get a proxy object that represents a method, but that object is not the method itself. And you can actually do the same in Scala as well.
And of course it is possible to turn a method into a function value by η-expansion.
I'm assuming that you're compiling to Java Virtual Machine (JVM) bytecode, such as with scalac, which is probably the most common way to use Scala. Disclaimer: I'm not an expert on the JVM, so some parts of this answer might be a bit wrong, but the general idea is right.
Essentially, a method is a set of instructions for the runtime to execute. It exists as part of the compiled code on disk (e.g. a .class file). When the JVM loads the class, it pulls the entire class file into memory, including the methods. When the JVM encounters a method call, it looks up the method and starts executing the instructions in it. If the method returns a result, the JVM makes that result available in the calling code, then does whatever you wanted to do with it there, such as assigning to a variable.
With that knowledge, we can answer some of your questions:
From val b = myFunc(2) to val b = 2 + 5, what happened in between?
This isn't quite how it works, as the JVM doesn't "expand" myFunc in place, but instead looks up myFunc and executes the instructions in it.
From where or what object do we know that myFunc(x) is x + 5?
Not from any object. While myFunc is in memory, it's in an area of memory that you can't access directly (but the JVM can).
why can't it be a value since it is a chunk of memory?
Not all memory fits into the nice abstractions of types and values.
Can anyone explain how I'm supposed to use the method 'getVersion' for CGPDFDocument in Swift?
Apple's documentation gives:
func getVersion(majorVersion: UnsafeMutablePointer<Int32>,
minorVersion: UnsafeMutablePointer<Int32>)
"On return, the values of the majorVersion and minorVersion parameters are set to the major and minor version numbers of the document respectively."
So I supply two variables as arguments of the function, and they get filled with the values on exit? Do they need to point to something in particular before the method is called? Why not just type them as integers, if that's what the returned values are?
You use it like this:
var major: Int32 = 0
var minor: Int32 = 0
document.getVersion(majorVersion: &major, minorVersion: &minor)
print("Version: \(major).\(minor)")
The function expects pointers, but if you pass in plain Int32 variables with the & operator, the Swift compiler is smart enough to call the function with pointers to the variables. This is documented in Using Swift with Cocoa and Objective-C: Interacting with C APIs.
The main reason the function works like this is probably that it's a very old C function that has been imported into Swift. C doesn't support tuples as return values; using pointers as in-out parameters is a way to have the function return more than one value. Arguably, it would have been a better design to define a custom struct for the return type so that the function could return the two values in a single type, but the original developers of this function apparently didn't think it was necessary — perhaps unsuprisingly, because this pattern is very common in C.
I had a doubt
I know that main difference between a function and procedure is
The function compulsory returns a value where as a procedure may or may not returns value.
But when we use a function of type void it returns nothing.
Can u people please clarify my doubt.
Traditionally, a procedure returning a value has been called a function (see below), however, many modern languages dispense with the term procedure altogether, preferring to use the term function for all named code blocks.
Read more at Suite101: Procedure, subroutine or function?: Programming terminology 101 - a look at the differences in approach and definition of procedures, subroutines and functions. http://www.suite101.com/content/procedure--subroutine-or-function--a8208#ixzz1GqkE7HjE
In C and its derivatives, the term "procedure" is rarely used. C has functions some of which return a value and some of which don't. I think this is an artefact of C's heritage where before the introduction of void in ANSI C, there was no way to not return a value. By default functions returned an int which you could ignore (can still) and might be some random number if no explicit return value was specified.
In the Pascal language family, the difference is explicit, functions return a value and procedures don't. A different keyword is used in each case for the definition. Visual Basic also differentiates with functions and subroutines(?).
Since we are talking about Objective-C, there are some further issues to confuse you. Functions associated with a class or object are known as "methods" (class methods and instance methods respectively).
Also, if we are being pedantic, you don't call Objective-C methods, you invoke them by sending a message to the object. The distinction is actually quite important because the message name (aka "selector") does not necessarily always refer to the same method, it can be changed at run time. This is fundamentally different to languages like Java and C++ where a particular method name for a particular class is really just a symbolic name for the address of the block of code constituting the body of the method.
Depending on the programming language, the distinction may be not so clear. Let's take a conservative language, Pascal:
procedure indeed has no return value. It is used for operations which do not have a return value, or have multiple return values. In the latter case, multiple arguments (the return-arguments or output-arguments) are passed by reference (using the var keyword) and their values are directly modified from inside the procedure. (Note that this latter case may not be considered good practice, depending on the circumstances).
function has a single return value, and usually we do not expect it to change the value of any of its arguments (which arguments may then be passed by value, or via the const keyword). Multiple return values may be returned by bundling them into a record.
C or Java does not distinguish syntactically, so a function of return type void can be thought of as a procedure. Scala distinguished between them by the presence of an equals sign between the method head and method body.
Generally, no matter how an actual language calls its construct, we would ideally expect that
A function takes arguments, doesn't modify any state (like mutating arguments, global variables, or printing info for the user to the console), and returns the result of computation.
A procedure takes arguments, performs operations which can have side-effects (writing to a database, printing to the console, maybe mutating variables), but hopefully doesn't mutate any arguments.
In practice however, depending on the situation, blends of these expectations can be observed. Sticking to these guidelines helps I think.
What is the diffrence between these two lines of code:
[cmController currentPageNo];
self.cmController.currentPageNo;
There is actually a functional difference - the second line is equivalent to:
[[self cmController] currentPageNo];
Using the -cmController property getter method to access the cmController ivar may have behaviours that make it different to accessing the ivar directly. These might include lazy initialisation or atomic thread locking, or a range of other behaviours. Unless you have a good reason to, you should (in general) use the accessor methods for properties, rather than accessing ivars directly.
So to clarify:
[cmController currentPageNo]; // 1
cmController.currentPageNo; // 2
[[self cmController] currentPageNo]; // 3
self.cmController.currentPageNo; // 4
1 and 2 are functionally identical to each other, but use different syntax. 3 and 4 are also functionally identical to each other, but use different syntax. You should use version 4, or version 3 if you have an aversion to dot-syntax.
Generally, dot notation is just syntactical sugar.
But in this case, there actually is some difference.
[cmController currentPageNo];
This will use the class's instance variable directly to get your cmController. It will then send the currentPageNo to it.
self.cmController.currentPageNo;
This, on the other hand, will use the current class's property definition to get the cmController via the class's ivar.
This means, basically, the the first is slightly more efficient than the second. Not because you used dot notation, but because you used cmController directly instead of self.cmController. [whatever currentPageNo] is the same as whatever.currentPageNo.
These lines are equivalent except for the syntax used:
[cmController currentPageNo];
cmController.currentPageNo;
On the other hand, these lines are equivalent except for the syntax used:
self.cmController.currentPageNo;
[[self cmController] currentPageNo];
I hope that's clear.
You can read about dot notation here.
There's no difference, functionally; objective C 2.0 just introduced the dot notation, giving those who aren't as into the brackets a way out.
EDIT:
As the comments pointed out, of course this is wrong. I was responding to the (unasked) question of "what's the difference between [cmController currentPageNo]; and self.cmController.currentPageNo;?"
Nick's answer gives the true answer, which is that the first line directly accesses the variable, while the second line uses the variable's getter method. The two lines also differ in that the first uses typical bracket notation, while the second does indeed use the new dot notation from objective C 2.0.