Send an unknown method call: Difference between revisions

{{task|Object oriented}}

 

Invoke an object method where the name of the method to be invoked can be generated at run time.

 

* [[Respond to an unknown method call]].

* [[Runtime evaluation]]

 

=={{header|AutoHotkey}}==

This object has 3 methods, and asks the user to name one to call. Instead of using Func(), one could use a class definition.

InputBox, methodToCall, , Which method should I call?

obj[methodToCall].()

MsgBox Method C

}

 

=={{header|Bracmat}}==

( oracle

= (predicate="is made of green cheese")

& (SourceOfKnowledge..str$(generate !trueorlie))$!something

);

{{out|Example}}

<pre>{?} !task

 

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

 

class Example

}

}

{{out}}

foo(5) = 47

$METHOD executes a named instance method for a specified instance of a designated class.

 

{

 

}

 

{{out|Examples}}

<pre>

This is bar

</pre>

 

=={{header|Common Lisp}}==

Unknown methods are called just like any other function. Find the method-naming symbol using INTERN then call it with FUNCALL.

 

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

local :method :add

 

{{out}}

<pre>3</pre>

This example goes well with the object named <code>example</code> in [[Respond to an unknown method call#E]].

 

E.call(example, name, [])

 

{

}

 

 

=={{header|Forth}}==

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

 

 

 

=={{header|Go}}==

 

import (

// interpret first return value as int

fmt.Println(r[0].Int()) // => 42

 

=={{header|Groovy}}==

def foo(value) {

"Invoked with '$value'"

def arg = "test value"

 

 

==Icon and {{header|Unicon}}==

x := foo() # create object

x.m1() # static call of m1 method

method m1(x)

end

 

For more information on this see [[Respond_to_an_unknown_method_call#Icon_and_Unicon|Respond to an unknown method call]].

=={{header|Io}}==

Example foo := method(x, 42+x)

 

name := "foo"

 

=={{header|J}}==

There are other methods as well, e.g., '''<tt>@.</tt>''','''<tt>`:</tt>''', and '''<tt>^:</tt>''', though these are designed to consume gerunds (pre-parsed ASTs) rather than strings (though, of course, a pre-processor can always be provided to convert strings into ASTs before feeding them to these operators).

 

prod =: */

count =: #

3

nameToDispatch (128!:2) 1 2 3

 

=={{header|Java}}==

Using reflection

 

class Example {

System.out.println(result); // prints "47"

}

 

=={{header|JavaScript}}==

String literal "foo" may be replaced by any expression resulting in a string

example.foo = function(x) {

return 42 + x;

 

name = "foo";

=={{header|Lasso}}==

public foo() => {

return 'foo was called'

local(obj = mytype, methodname = tag('foo'), methodname2 = tag('bar'))

#obj->\#methodname->invoke

{{out}}

<pre>foo was called

this time is was bar</pre>

 

=={{header|Logtalk}}==

For this task, we first define a simple object with a single method:

 

:- public(bar/1).

bar(42).

 

:- object(query_foo).

 

write(Message), nl.

 

| ?- query_foo::query.

Message: bar(X).

Reply: bar(42)

=={{header|Lua}}==

Don't forget to pass the object for methods!

function example:foo (x) return 42 + x end

 

local name = "foo"

 

Creates a dialog box where one can type a function (Sin, Cos, Tan ...) and then a second dialog box for a value.

{{out}}

Input: 3.1415

 

=={{header|MATLAB}} / {{header|Octave}}==

 

 

funName = 'foo'; % generate function name

feval (funNAME, ...) % evaluation function with optional parameters

funName = 'a=atan(pi)'; % generate function name

eval (funName, 'printf(''Error\n'')')

 

=={{header|Objective-C}}==

 

@interface Example : NSObject

}

return 0;

The <code>performSelector: ...</code> methods can only be used with methods with 0 - 2 object arguments, and an object or <code>void</code> return type. For all other calls, one can create an <code>NSInvocation</code> object and invoke it, or directly call one of the <code>objc_msgSend</code> family of runtime functions.

 

 

A method object can be retrieved from its name using asMethod.

Others :

 

A generic way to search a word into the dictionary in to use find method :

 

=={{header|PARI/GP}}==

 

=={{header|Perl}}==

sub new {

bless {}

package main;

my $name = "foo";

 

 

=={{header|PHP}}==

class Example {

function foo($x) {

// alternately:

echo call_user_func(array($example, $name), 5), "\n";

 

=={{header|PicoLisp}}==

This can be done with the '[http://software-lab.de/doc/refS.html#send send]' function.

 

=={{header|Pike}}==

with [] instead of -> a string can be used to name a method:

object now = Calendar.now();

 

=={{header|Python}}==

String literal "foo" may be replaced by any expression resulting in a string

def foo(self, x):

return 42 + x

 

name = "foo"

 

=={{header|Qi}}==

(define foo -> 5)

 

 

(execute-function "foo")

 

=={{header|Racket}}==

#lang racket

(define greeter

(define unknown 'hello)

(dynamic-send greeter unknown "World")

 

=={{header|Ruby}}==

You may replace :foo, :bar or "bar" with any expression that returns a Symbol or String.

 

def foo

42

Example.new.send( :bar, 1, 2 ) { |x,y| x+y } # => 3

args = [1, 2]

 

Object#send can also call protected and private methods, skipping the usual access checks. Ruby 1.9 adds Object#public_send, which only calls public methods.

 

{{works with|Ruby|1.9}}

private

def privacy; "secret"; end

e.public_send :publicity # => "hi"

e.public_send :privacy # raises NoMethodError

 

=={{header|Scala}}==

def foo(x: Int): Int = 42 + x

}

assert(meth.invoke(example, 5.asInstanceOf[AnyRef]) == 47.asInstanceOf[AnyRef], "Not confirm expectation.")

println(s"Successfully completed without errors. [total ${scala.compat.Platform.currentTime - executionStart} ms]")

 

=={{header|Sidef}}==

method foo(x) {

}

}

 

 

=={{header|Smalltalk}}==

 

Example extend [

symbol := 'foo:' asSymbol. " same as symbol := #foo: "

 

The <code>perform:with:with:</code> family of methods exist for methods with 0 - 2 (3 in [[GNU Smalltalk]]) arguments. For methods with more arguments, use <code>perform:withArguments:</code>, which takes an array of arguments.

 

=={{header|Tcl}}==

Method names are really just strings, i.e., ordinary values that can be produced by any mechanism:

oo::class create Example {

method foo {} {return 42}

for {set i 1} {$i <= 4} {incr i} {

$eg $i ...

{{out|The above produces this output}}

42

foe...

fum...

 

=={{header|zkl}}==

 

{{omit from|Axe}}

{{omit from|BASIC}}

{{omit from|C|No such thing as object method}}

{{omit from|GUISS}}

{{omit from|ZX Spectrum Basic}}