Respond to an unknown method call: Difference between revisions
m
syntax highlighting fixup automation
m (→{{header|J}}) |
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
||
Line 15:
=={{header|AutoHotkey}}==
[http://ahkscript.org/boards/viewtopic.php?f=17&t=1363&start=140#p14454 Example by LinearSpoon]
<
{
foo()
Line 41:
ex := new example
ex.foo()
ex.bar(1,2)</
=={{header|Brat}}==
<
example.no_method = { meth_name, *args |
Line 50:
}
example.this_does_not_exist "at all" #Prints "this_does_not_exist was called with these arguments: [at all]"</
=={{header|C sharp|C#}}==
{{works with|C sharp|4.0}}
<
using System.Dynamic;
Line 78:
ex.Bar();
}
}</
=={{header|C++}}==
Line 86:
To avoid the pure virtual call, we can put some default function implementation into the abstract class which handles the situation (e.g. throws a custom exception or whatnot).
<
public:
virtual void bark() // concrete virtual, not pure
Line 103:
e.bark(); // throws exception
}
</syntaxhighlight>
=={{header|Caché ObjectScript}}==
Line 109:
Caché classes can include support for what is called dynamic dispatch. If dynamic dispatch is in use and a program references a property or method that is not part of the class definition, then a method (called a dispatch method) is called that attempts to resolve the undefined method or property. For example, dynamic dispatch can return a value for a property that is not defined or it can invoke a method for a method that is not implemented. The dispatch destination is dynamic in that it does not appear in the class descriptor and is not resolved until runtime.
<
{
Line 141:
}
}</
{{out|Examples}}
<pre>
Line 155:
In Common Lisp, if a generic function is invoked on arguments for which there is no applicable specialized method, the method <code>no-applicable-method</code> is called with the generic function and the arguments.
<
(:documentation "Do something to thing."))
Line 162:
(defmethod do-something ((thing (eql 3)))
(format nil "Do something to ~w." thing))</
Evaluating<
<
"No method for #<STANDARD-GENERIC-FUNCTION DO-SOMETHING 214FC042> on (4).")</
=={{header|D}}==
Similar to the Python entry, but D performs this statically.
<
struct Catcher {
Line 195:
ca.grill();
ca.ding("dong", 11);
}</
{{out}}
<pre>This is foo
Line 204:
=={{header|Déjà Vu}}==
The function <code>set-default</code> is useful here:
<
labda:
print "One!"
Line 221:
obj!two
obj!three
</syntaxhighlight>
{{out}}
<pre>One!
Line 233:
Practically, the object definition syntax provides a ''matcher'' clause to handle unrecognized messages. This example has the same behavior as the Python example.
<
to foo() { println("this is foo") }
to bar() { println("this is bar") }
Line 242:
}
}
}</
=={{header|Elena}}==
Using generic handler (ELENA 4.x):
<
class Example
Line 274:
o.bar(1);
o.someMethod(1,2)
}</
{{out}}
<pre>
Line 283:
=={{header|Fancy}}==
<
class CatchThemAll {
def foo {
Line 304:
a we_can_do_it
a they_can_too: "eat" and: "walk"
</syntaxhighlight>
=={{header|Fantom}}==
Line 310:
In Fantom, you can call methods statically or dynamically. Static calls to methods will be checked at compile time. Dynamic method calls (indicated by an <code>instance->method</code> syntax) are run through a "[http://fantom.org/doc/sys/Obj.html#trap trap]" method at run time. This method looks up the given method name, and throws an exception if the method/field is not known. This exception can be caught, and processed specially:
<
class A
{
Line 343:
}
}
</syntaxhighlight>
Output:
Line 358:
Needs the FMS-SI (single inheritance) library code located here:
http://soton.mpeforth.com/flag/fms/index.html
<
include FMS-SILib.f
var x \ instantiate a class var object named x
x add: \ => "aborted: message not understood"
</syntaxhighlight>
=={{header|Go}}==
This uses reflection as in [[Send an unknown method call#Go]], but goes one more step to put the reflection code in a method. This allows an unknown method call to be handled by this method of the receiving object.
<
import (
Line 395:
fmt.Println(e.CallMethod("Foo"))
fmt.Println(e.CallMethod("Bar"))
}</
{{out}}
<pre>
Line 405:
=={{header|Groovy}}==
Groovy allows us to capture all unknown method calls using the methodMissing function
<
def foo() {
println 'Invoked foo'
Line 412:
println "Invoked missing method $name$args"
}
}</
Testing:
<
o.foo()
o.bar()
o.bar(1, 2, 'Test')</
{{out}}
Line 436:
The example below is based upon the last case. The procedure 'DynMethod' would be used in place of normal method invocation. A special method 'UndefinedMethod' can be defined to handle unknown methods. The procedure 'DynMethod' requires knowledge of the internals of the code emitted to support objects.
<
local m
Line 451:
return obj.UndefinedMethod!arglist # ... call it
else runerr(207,obj) # error invalid method (i.e. field)
end</
<
x := foo()
y := foo2()
Line 483:
return
end
end</
=={{header|Io}}==
{{trans|Python}}
<
foo := method(writeln("this is foo"))
bar := method(writeln("this is bar"))
Line 505:
example grill // prints "tried to handle unknown method grill"
example ding("dong") // prints "tried to handle unknown method ding"
// prints "it had arguments: list("dong")"</
=={{header|J}}==
Line 512:
For example, we could define
<
doSomething_z_=: assert&0 bind 'doSomething was not implemented'
doSomething__y ''
Line 518:
doSomething_adhoc1_=: smoutput bind 'hello world'
dSomethingElse_adhoc2_=: smoutput bind 'hello world'</
With those definitions in a fresh session (where <code>adhoc2</code> has not been given a definition for <code>doSomething</code>), we get the following behavior:
<
hello world
example<'adhoc2'
|doSomething was not implemented: assert</
(Note that need to have a cover verb (or adverb or conjunction) for the method call if you want to abstract it or dynamically intercept previously undefined methods.)
Line 536:
{{works with|Firefox}}
{{works with|IE}}
<
obj = new Proxy({},
{ get : function(target, prop)
Line 551:
obj.l = function() {console.log(45);};
obj.l(); ///45
</syntaxhighlight>
Where {} is the object to wrap in the proxy, but it could be a reference to another object, and the second argument to proxy´s constructor are the handlers that supersede the behavior of the target ({}), the 'get' function gets executed '''every time''' a property from target ({}) is needed, in this case, only if the property didn´t existed before, it returns the dynamically generated function.
Line 558:
Before Proxy interface, firefox (only) supported a suitable trap:<br>
<
example.foo = function () {
alert("this is foo");
Line 575:
example.grill(); // alerts "tried to handle unknown method grill"
example.ding("dong"); // alerts "tried to handle unknown method ding"
// alerts "it had arguments: dong</
=={{header|Julia}}==
Julia will throw a MethodError exception if its multiple dispatch cannot find a proper function for a given set of arguments. This exception can be caught and resolved within a generically typed function that is not specific as to the object type of its arguments.
<
function add(a, b)
try
Line 593:
println(add(1//2, 1//2))
println(add("Hello ", "world"))
</syntaxhighlight>
=={{header|Kotlin}}==
Kotlin JS does not currently target ECMAScript 2015 and so the Proxy object cannot be used for this task. The only way it can currently be accomplished is to use the Mozilla extension __noSuchMethod__ property which works with Firefox 43 but is no longer supported by more up to date versions:
<
class C {
Line 610:
val c: dynamic = C() // 'dynamic' turns off compile time checks
c.foo() // the compiler now allows this call even though foo() is undefined
}</
{{out}}
Line 621:
If this is not included in the type, an error will result that may terminate processing unless otherwise handled.
<
public foo() => {
return 'this is foo\r'
Line 647:
#e->dothis('here',12,'there','nowhere')
// outputs 'tried to handle unknown method called "dothis" with args: "here,12,there,nowhere"'</
=={{header|Logtalk}}==
Line 653:
There are two ways to handle unknown messages. From the sender side, we can catch the exception that is generated when an object doesn't understand a message:
<
:- object(foo).
Line 665:
:- end_object.
</syntaxhighlight>
From the receiver side, an object can implement the built-in protocol "forwarding", defining the handler for messages that it doesn't understand (e.g. by forwarding or delegating it to another object):
<
:- object(foo,
implements(forwarding)).
Line 678:
:- end_object.
</syntaxhighlight>
=={{header|Lua}}==
Line 684:
This is specifically the purpose of the __index metamethod:
<syntaxhighlight lang="lua">
local object={print=print}
setmetatable(object,{__index=function(t,k)return function() print("You called the method",k)end end})
object.print("Hi") -->Hi
object.hello() -->You called the method hello
</syntaxhighlight>
=={{header|M2000 Interpreter}}==
Line 705:
<syntaxhighlight lang="m2000 interpreter">
module checkit {
Line 846:
}
checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
By default, when evaluating a symbol's <code>DownValues</code>, Mathematica picks the most specific.
<
obj[bar] = "This is bar.";
obj[f_Symbol] := "What is " <> SymbolName[f] <> "?";
Print[obj@foo];
Print[obj@bar];
Print[obj@baz];</
{{out}}
<pre>This is foo.
Line 864:
Nim statically checks that all methods exist, so this is generally not applicable.
However, it's possible to fake this behaviour using an experimental Nim feature
<
from strutils import join
Line 883:
f.baz("hi",5)
f.qux()
f.qux("nope")</
{{out}}
<pre>tried to call method 'bar'
Line 897:
To avoid the possibility of an abstract method call, one common solution is to leave an empty implementation for the virtual method instead of making it abstract. This is what an abstract method call looks like:
<
type
Tanimal = class
Line 916:
end.
</syntaxhighlight>
=={{header|Objective-C}}==
<code>-forwardInvocation:</code> is usually used to "forward" the message on to another object to handle.
<
// The methods need to be declared somewhere
Line 982:
}
return 0;
}</
=={{header|Oforth}}==
Line 990:
Method call is resolved at runtime : oforth looks at the top of the stack (that will become the method receiver) and searchs for a valid implementation of the method called (into receiver class or its parents). If no implementation is found for this method, doesNotUnderstand method is called instead.
<
[1:interpreter] ExRuntime : 1 does not understand method <#first></
<
[1:interpreter] ExRuntime : 1 does not understand method <#first></
Oforth has not concept such as "unknow method" : if a method exists, it can be called (even if the object on top of stack does not understand it). If not, no call is possible.
<
[1:interpreter] ExRuntime : null does not understand method <#perform></
doesNotUnderstand can be redefined for a particular class :
<
MyClass method: doesNotUnderstand(m)
"Well, sorry, I don't understand " print m println ;
MyClass new first
Well, sorry, I don't understand #first</
=={{header|ooRexx}}==
To respond to unknown method calls, classes can implement an <code>unknown</code> method. This method is passed the name of the method and an array of the arguments that were used on the call.
<
u~foo(1, 2, 3)
Line 1,018:
::method unknown
use arg name, args
say "Unknown method" name "invoked with arguments:" args~tostring('l',', ')</
Output:
<pre>Unknown method FOO invoked with arguments: 1, 2, 3</pre>
Line 1,024:
=={{header|Oz}}==
To respond to unknown method calls, classes can implement the <code>otherwise</code> method. As its sole argument, this method gets the received message, i.e. a record with the name of the unknown method as its label and the arguments as the record features.
<
class Example
meth init skip end
Line 1,046:
{Object bar}
{Object grill}
{Object ding(dong)}</
Output:
Line 1,058:
=={{header|Perl}}==
<
sub new {
bless {}
Line 1,087:
$example->grill; # prints "tried to handle unknown method Example::grill"
$example->ding("dong"); # prints "tried to handle unknown method Example::ding"
# and "it had arguments: dong"</
=={{header|Phix}}==
Phix is not object orientated, but this sort of thing is very easy to emulate.
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">enum</span> <span style="color: #000000;">METHODS</span>
Line 1,123:
<span style="color: #0000FF;">?</span><span style="color: #000000;">invoke</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"exists"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">invoke</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"non_existent_method"</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 1,131:
=={{header|PHP}}==
<
class Example {
function foo() {
Line 1,153:
$example->ding("dong"); // prints "tried to handle unknown method ding"
// prints "it had arguments: dong
?></
=={{header|PicoLisp}}==
The function '[http://software-lab.de/doc/refT.html#try try]' is used to send a message to an object for which it is not known whether it inherits a method for that message or not. As opposed to the syntacically equivalent '[http://software-lab.de/doc/refS.html#send send]' function, 'try' does not give an error, but returns NIL. We might redefine 'send' to get an effect analog to CLOS.
<
(or
(pass try Msg Obj)
Line 1,168:
(dm do-something> ()
(pack "Do something to " This) )</
Test:
<
-> A
: (object 'B '(+B))
-> B
: (list (send 'do-something> 'A) (send 'do-something> 'B))
-> ("Do something to A" "No method for do-something> on B")</
=={{header|Pike}}==
{{incorrect|Pike|the <code>-></code> operator responds to all method calls, not just the unknown ones. the example needs to be amended to show how known methods are accessed }}
Pike allows to overload the <code>-></code> operator used to access object members:
<
{
mixed `->(string name)
Line 1,191:
you are calling hello(5);
> CatchAll()->something(99);
you are calling something(99);</
=={{header|Python}}==
Python objects can implement a <code>__getattr__()</code> method to handle accesses of unknown attributes (methods are just attributes that are callable; so this function handles both methods and non-method fields). Here we assume that if you access an unknown attribute, you want a method, so we return a function that can be called.
<
def foo(self):
print("this is foo")
Line 1,213:
example.grill() # prints “tried to handle unknown method grill”
example.ding("dong") # prints “tried to handle unknown method ding”
# prints “it had arguments: ('dong',)”</
=={{header|Racket}}==
Racket's usual object system can't deal with unknown methods, but we can capture the relevant exception and deal with it:
<
#lang racket
Line 1,243:
(send~ o foo 1) ; => foo: 1
(send~ o whatever 1) ; Unknown method whatever: (1)
</syntaxhighlight>
Alternatively, we can use Swindle for a CLOS-like object system, and do something similar to the Common Lisp solution:
<
#lang swindle
Line 1,259:
(foo "one")
;; => No method in #<generic:foo> for "one"
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2020.08.1}}
<syntaxhighlight lang="raku"
method FALLBACK ($name, *@rest) {
say "{self.WHAT.raku}: $name.tc() the @rest[], full speed ahead!";
Line 1,273:
Farragut.damn: 'torpedoes';
Sparrow.hoist: <Jolly Roger mateys>;</
{{out}}
<pre>Farragut: Damn the torpedoes, full speed ahead!
Line 1,280:
<tt>[https://docs.raku.org/language/typesystem#index-entry-FALLBACK_(method) FALLBACK]</tt> will be called for any method that is not defined. Since any class inherits from <tt>Any</tt>, there will be plenty of already defined methods. Those which are not defined can also be used as L-Values by the magic of <tt>[https://docs.raku.org/type/Attribute#index-entry-trait_is_rw_(Attribute)-trait_is_rw is rw]</tt>.
<syntaxhighlight lang="raku"
our $.value = 10;
method FALLBACK($name, |c) is rw { $.value }
Line 1,288:
say $l.any-odd-name; # 10
$l.some-other-name = 42;
say $l.i-dont-know; # 42</
=={{header|Ring}}==
<
load "stdlibcore.ring"
Line 1,312:
call cMethodName()
ok
</syntaxhighlight>
{{out}}
<pre>
Line 1,323:
=={{header|Ruby}}==
<
def foo
puts "this is foo"
Line 1,344:
example.grill # prints “tried to handle unknown method grill”
example.ding("dong") # prints “tried to handle unknown method ding”
# prints “it had arguments: ["dong"]”</
=={{header|Scala}}==
{{works with|Scala|2.9}}
As of scala 2.9, scalac must receive the -Xexperimental optional for Dynamic to receive this treatment.
<
{
def foo()=println("this is foo")
Line 1,369:
}
}
</syntaxhighlight>
Output:
<pre>this is foo
Line 1,379:
=={{header|Sidef}}==
The special '''AUTOLOAD''' method gets called when a method isn't defined in the current class:
<
method foo {
say "this is foo"
Line 1,400:
example.grill; # prints “tried to handle unknown method grill”
example.ding("dong"); # prints “tried to handle unknown method ding”
# prints “it had arguments: dong”</
=={{header|Slate}}==
Line 1,406:
Here is an example of unknown methods being used to call shell commands (this is already defined in the base image):
<
_@shell didNotUnderstand: message at: position
Line 1,429:
ifFalse: [args do: [| :arg | command ; ' ' ; arg]]]]] writingAs: String)
ifNil: [resend] ifNotNilDo: [| :cmd | [Platform run: cmd]]]
].</
Here is an example of it being used:
<
kernel.new.little.64.1244260494374694.image slate2.image
net.image slate.image
True
slate[2]></
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
foo [ 'foo received' displayNl ]
Line 1,459:
a bar.
a weCanDoIt.
a theyCanToo: 'eat' and: 'walk'.</
There are two ways to catch unimplemented messages:
* on the receiver side, by redefining the "doesNotUnderstand:" method in the receiver class hierarchy, as shown above.
* on the sender side, by catching the MessageNotUnderstood exception, as follows:
<
bla := someObject fooBar.
foo := bla.
] on: MessageNotUnderstood do:[:ex |
ex return: 'fortyTwo'
]</
this will leave 'fortyTwo' on bla AND foo (because the handler proceeds).
This sender-side handling is useful if you don't want to or if you are not allowed to change the receiver's class hierarchy (which is not a technical, but solely a political/conventional limitation, because in Smalltalk no class is closed, and extensions can be added to any class simply by loading or dynamically adding methods - even to the base system or third party packages).
Line 1,475:
Of course, this handler now catches any other unimplemented messages as well, thus if foobar was implemented, but itself sends another bad message, we'd catch that as well.
We can check for this in the handler, by checking for which message got us there:
<
bla := someObject fooBar.
foo := bla.
Line 1,485:
ex reject
]
]</
the reject will re-reaise the exception, and lead us to an outer handler, or the debugger, if there is none.
{{works with|Smalltalk/X}}
There is a utility method for exactly the above (it catches only #fooBar to the original receiver):
<
=={{header|SuperCollider}}==
<
tell {
Line 1,511:
}
</syntaxhighlight>
Usage:
<syntaxhighlight lang="supercollider">
i = Ingorabilis.new;
i.tell; // prints "I told you so"
i.find; // prints ""I found nothing"
i.think(1, 3, 4, 7);
</syntaxhighlight>
The latter answers:
<
Giving you some good arguments in the following
1
Line 1,534:
instance variables [0]
}
<...></
Catch the method call:
<syntaxhighlight lang="supercollider">
i = Ingorabilis.new
try { i.think } { "We are not delegating to super, because I don't want it".postln };
</syntaxhighlight>
=={{header|Tcl}}==
{{works with|Tcl|8.6}} or {{libheader|TclOO}}
<
# First create a simple, conventional class and object
oo::class create Example {
Line 1,570:
example grill; # prints “tried to handle unknown method "grill"”
example ding dong; # prints “tried to handle unknown method "ding"”
# prints “it had arguments: dong”</
=={{header|UNIX Shell}}==
{{works with|Bash}}
bash doesn't have objects with methods, but it can handle unknown commands:
<
status=$?
Line 1,591:
# Trap errors.
trap 'handle_error' ERR</
Sample usage:
$ foo
Line 1,599:
=={{header|Wren}}==
Unlike some other dynamically typed languages, it is not possible to create new methods at runtime in Wren. Attempting to call an unknown method would therefore normally result in a fatal error. However, we can catch such an error and redirect it for user interaction as shown below.
<
class Test {
Line 1,634:
}
}
System.print("OK, continuing.")</
{{out}}
Line 1,658:
=={{header|zkl}}==
If something can not be resolved (in a class) the function __notFound is called. It can redirect to another object.
<
fcn bar{vm.arglist.println("***")}
}</
<pre>
C.foo //-->"foo not in Class(C)", returns Fcn(bar)
|