Send an unknown method call: Difference between revisions

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

 

=={{header|Clojure}}==

(import '[java.util Date])

(import '[clojure.lang Reflector])

;; then we run the code using eval

(eval `(. date1 ~(symbol method) date2))

 

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

ELENA 4.1 :

class Example

console.printLine(methodSignature,"(",5,") = ",result)

{{out}}

<pre>

=={{header|Factor}}==

Factor's object model is such that objects themselves don't contain methods — generic words do. So there is nothing different about invoking an unknown method than invoking an unknown word in general.

IN: rosetta-code.unknown-method-call

 

! must specify vocab to look up a word

"rosetta-code.unknown-method-call"

 

=={{header|Forth}}==

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

x p: 42 \ send the print message ( p: ) to x to verify the contents

 

 

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

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

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|Julia}}==

{{works with|Julia|0.6}}

 

"foo" => x -> 42 + x,

"bar" => x -> 42 * x)

 

@show functions["foo"](3)

 

{{out}}

=={{header|Kotlin}}==

When you try to compile the following program, it will appear to the compiler that the local variable 'c' is assigned but never used and a warning will be issued accordingly. You can get rid of this warning by compiling using the -nowarn flag.

 

class C {

val f = "c.foo"

js(f)() // invokes c.foo dynamically

 

{{out}}

 

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

 

=={{header|Lingo}}==

-- ...

method = #foo

arg1 = 23

 

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

=={{header|Lua}}==

Don't forget to pass the object for methods!

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

 

local name = "foo"

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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

{{out}}

<pre>Input: Sin

 

 

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|Phix}}==

Not specifically anything to do with objects, but you can construct routine names at runtime:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">procedure</span> <span style="color: #000000;">Hello</span><span style="color: #0000FF;">()</span>

<span style="color: #7060A8;">call_proc</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #000000;">erm</span><span style="color: #0000FF;">),{})</span>

 

=={{header|PHP}}==

class Example {

function foo($x) {

// alternately:

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

 

=={{header|Picat}}==

For functions use <code>apply/n</code> and for predicates <code>call/n</code>. The name of the function/predicate must be an atom and strings must be converted to atom, e.g. with <code>to_atom/1</code>.

println("Function: Use apply/n"),

Fun = "fib",

% A predicate

pyth(X,Y,Z) =>

 

{{out}}

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

A random method using a random number:

$method = ([Math] | Get-Member -MemberType Method -Static | Where-Object {$_.Definition.Split(',').Count -eq 1} | Get-Random).Name

$number = (1..9 | Get-Random) / 10

 

$output | Format-List

{{Out}}

<pre>

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

(formerly Perl 6)

Just for the fun of it, we'll mix in an anonymous role into an integer instead of defining a class.

my $name = 'add-me';

The double quotes are required, by the way; without them the variable would be interpreted as a hard ref to a method.

 

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

42 + x

 

say obj.(name)(5) # prints: 47

 

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

 

The first case is used for interfacing with legacy Objective-C libraries. Objective-C is heavily dynamic with Smalltalk-style message passing. So Swift must be able to participate in this.

 

 

class MyUglyClass: NSObject {

let someObject: NSObject = MyUglyClass()

 

 

{{out}}

One of Swift's goals is to able to effectively bridge to dynamic languages such as Python and JavaScript. In order to facilitate more natural APIs, Swift provides the <code>@dynamicCallable</code> and <code>@dynamicMemberLookup</code> attributes which allow for runtime handling of method calls.

 

protocol FunDynamics {

var parent: MyDynamicThing { get }

.subtract(adding: 10, subtracting: 14)

 

 

{{out}}

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

 

=={{header|Wren}}==

class Test {

for (method in ["foo", "bar"]) {

Meta.eval("test.%(method)()")

 

{{out}}

 

=={{header|zkl}}==

 

{{omit from|Ada}}