Respond to an unknown method call: Difference between revisions

=={{header|AutoHotkey}}==

[http://ahkscript.org/boards/viewtopic.php?f=17&t=1363&start=140#p14454 Example by LinearSpoon]

{

foo()

ex := new example

ex.foo()

=={{header|Brat}}==

example.no_method = { meth_name, *args |

}

=={{header|C sharp|C#}}==

{{works with|C sharp|4.0}}

using System.Dynamic;

ex.Bar();

}

=={{header|C++}}==

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

e.bark(); // throws exception

}

=={{header|Caché ObjectScript}}==

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.

{

}

{{out|Examples}}

<pre>

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."))

(defmethod do-something ((thing (eql 3)))

=={{header|D}}==

Similar to the Python entry, but D performs this statically.

struct Catcher {

ca.grill();

ca.ding("dong", 11);

{{out}}

<pre>This is foo

=={{header|Déjà Vu}}==

The function <code>set-default</code> is useful here:

labda:

print "One!"

obj!two

obj!three

{{out}}

<pre>One!

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") }

}

}

=={{header|Elena}}==

Using generic handler (ELENA 4.x):

class Example

o.bar(1);

o.someMethod(1,2)

{{out}}

<pre>

=={{header|Fancy}}==

class CatchThemAll {

def foo {

a we_can_do_it

a they_can_too: "eat" and: "walk"

=={{header|Fantom}}==

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

{

}

}

Output:

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"

=={{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 (

fmt.Println(e.CallMethod("Foo"))

fmt.Println(e.CallMethod("Bar"))

{{out}}

<pre>

=={{header|Groovy}}==

Groovy allows us to capture all unknown method calls using the methodMissing function

def foo() {

println 'Invoked foo'

println "Invoked missing method $name$args"

}

Testing:

o.foo()

o.bar()

{{out}}

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

return obj.UndefinedMethod!arglist # ... call it

else runerr(207,obj) # error invalid method (i.e. field)

x := foo()

y := foo2()

return

end

=={{header|Io}}==

{{trans|Python}}

foo := method(writeln("this is foo"))

bar := method(writeln("this is bar"))

example grill // prints "tried to handle unknown method grill"

example ding("dong") // prints "tried to handle unknown method ding"

=={{header|J}}==

For example, we could define

doSomething_z_=: assert&0 bind 'doSomething was not implemented'

doSomething__y ''

doSomething_adhoc1_=: 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'

(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.)

{{works with|Firefox}}

{{works with|IE}}

obj = new Proxy({},

{ get : function(target, prop)

obj.l = function() {console.log(45);};

obj.l(); ///45

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.

Before Proxy interface, firefox (only) supported a suitable trap:<br>

example.foo = function () {

alert("this is foo");

example.grill(); // alerts "tried to handle unknown method grill"

example.ding("dong"); // alerts "tried to handle unknown method ding"

=={{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

println(add(1//2, 1//2))

println(add("Hello ", "world"))

=={{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 {

val c: dynamic = C() // 'dynamic' turns off compile time checks

c.foo() // the compiler now allows this call even though foo() is undefined

{{out}}

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'

#e->dothis('here',12,'there','nowhere')

=={{header|Logtalk}}==

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).

:- end_object.

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)).

:- end_object.

=={{header|Lua}}==

This is specifically the purpose of the __index metamethod:

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

=={{header|M2000 Interpreter}}==

module checkit {

}

checkit

=={{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];

{{out}}

<pre>This is foo.

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

f.baz("hi",5)

f.qux()

{{out}}

<pre>tried to call method 'bar'

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

end.

=={{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

}

return 0;

=={{header|Oforth}}==

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.

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.

doesNotUnderstand can be redefined for a particular class :

MyClass method: doesNotUnderstand(m)

"Well, sorry, I don't understand " print m println ;

MyClass new 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)

::method unknown

use arg name, args

Output:

<pre>Unknown method FOO invoked with arguments: 1, 2, 3</pre>

=={{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

{Object bar}

{Object grill}

Output:

=={{header|Perl}}==

sub new {

bless {}

$example->grill; # prints "tried to handle unknown method Example::grill"

$example->ding("dong"); # prints "tried to handle unknown method Example::ding"

=={{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>

<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>

=={{header|PHP}}==

class Example {

function foo() {

$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)

(dm do-something> ()

Test:

-> A

: (object 'B '(+B))

-> B

: (list (send 'do-something> 'A) (send 'do-something> '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)

you are calling hello(5);

> CatchAll()->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")

example.grill() # prints “tried to handle unknown method grill”

example.ding("dong") # prints “tried to handle unknown method ding”

=={{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

(send~ o foo 1) ; => foo: 1

(send~ o whatever 1) ; Unknown method whatever: (1)

Alternatively, we can use Swindle for a CLOS-like object system, and do something similar to the Common Lisp solution:

#lang swindle

(foo "one")

;; => No method in #<generic:foo> for "one"

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2020.08.1}}

method FALLBACK ($name, *@rest) {

say "{self.WHAT.raku}: $name.tc() the @rest[], full speed ahead!";

Farragut.damn: 'torpedoes';

{{out}}

<pre>Farragut: Damn the torpedoes, full speed ahead!

<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>.

our $.value = 10;

method FALLBACK($name, |c) is rw { $.value }

say $l.any-odd-name; # 10

$l.some-other-name = 42;

=={{header|Ring}}==

load "stdlibcore.ring"

call cMethodName()

ok

{{out}}

<pre>

=={{header|Ruby}}==

def foo

puts "this is foo"

example.grill # prints “tried to handle unknown method grill”

example.ding("dong") # prints “tried to handle unknown method ding”

=={{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")

}

}

Output:

<pre>this is foo

=={{header|Sidef}}==

The special '''AUTOLOAD''' method gets called when a method isn't defined in the current class:

method foo {

say "this is foo"

example.grill; # prints “tried to handle unknown method grill”

example.ding("dong"); # prints “tried to handle unknown method ding”

=={{header|Slate}}==

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

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

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

foo [ 'foo received' displayNl ]

a bar.

a weCanDoIt.

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).

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.

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 {

}

Usage:

i = Ingorabilis.new;

i.tell; // prints "I told you so"

i.find; // prints ""I found nothing"

i.think(1, 3, 4, 7);

The latter answers:

Giving you some good arguments in the following

1

instance variables [0]

}

Catch the method call:

i = Ingorabilis.new

try { i.think } { "We are not delegating to super, because I don't want it".postln };

=={{header|Tcl}}==

{{works with|Tcl|8.6}} or {{libheader|TclOO}}

# First create a simple, conventional class and object

oo::class create Example {

example grill; # prints “tried to handle unknown method "grill"”

example ding dong; # prints “tried to handle unknown method "ding"”

=={{header|UNIX Shell}}==

{{works with|Bash}}

bash doesn't have objects with methods, but it can handle unknown commands:

status=$?

# Trap errors.

Sample usage:

$ foo

=={{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 {

}

}

{{out}}

=={{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)