Reflection/List methods: Difference between revisions

[[Category:Programming Tasks]] [[Category:Object oriented]]

 

 

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

using System.Reflection;

 

}

{{out}}

<pre>

=={{header|Clojure}}==

 

; Including listing private methods in the clojure.set namespace:

=> (keys (ns-interns 'clojure.set))

; Only public:

=> (keys (ns-publics 'clojure.set))

 

=={{header|D}}==

D allows you to perform compile-time reflection for code generation, such as printing a list of the functions in a struct or class.

bool b;

 

printMethods!S;

printMethods!C;

 

{{out}}

factory</pre>

 

 

class MyClass

{

}

{{out}}

<pre>

</pre>

 

=={{header|Factor}}==

In Factor, methods are contained in generic words rather than objects, while methods specialize on a class. Therefore, the programmer must decide whether they want the list of methods in a generic word, or the list of methods that specialize on a class. Luckily, the <tt>methods</tt> word can do either depending on what type you give it (a word or a class). The returned sequence contains first-class word values suitable for executing.

 

"The list of methods contained in the generic word + :" print

 

"The list of methods specializing on the fixnum class:" print

{{out}}

<pre>

M\ fixnum u>=

}

</pre>

 

[https://golang.org/ref/spec#Method_expressions method expression] and

[https://golang.org/ref/spec#Method_values method value]

 

import (

}

fmt.Println()

{{out}}

<pre>

Sub func(image.Point, image.Point) image.Point func(image.Point) image.Point

</pre>

 

=={{header|Java}}==

 

public class ListMethods {

}

}

{{out}}

<pre>

In JavaScript, methods are properties that are functions, so methods are retrieved by [[Reflection/List properties|getting properties]] and filtering. There are multiple ways of getting property names, each of which include different subsets of an object's properties, such as enumerable or inherited properties.

 

function Super(name) {

this.name = name;

Object.entries(sub)

.filter(function(p) {return typeof p[1] == 'function';})

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

{{out}}

=={{header|Kotlin}}==

Note that kotlin-reflect.jar needs to be included in the classpath for this program.

 

import kotlin.reflect.full.functions

val fs = c.functions

for (f in fs) println("${f.name}, ${f.visibility}")

 

{{out}}

 

=={{header|Lingo}}==

 

on foo (me)

on bar (me)

put "bar"

 

put obj.handlers()

-- [#foo, #bar]

 

call(#bar, obj)

 

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

#import <objc/runtime.h>

 

free(methods);

return 0;

{{out}}

<pre>

</pre>

 

 

 

 

 

{{out}}

 

=={{header|Phix}}==

{{out}}

<pre>

{"exists"}

</pre>

 

=={{header|PHP}}==

class Foo {

function bar(int $x) {

echo $method_info;

}

{{out}}

<pre>

}

</pre>

 

=={{header|Python}}==

In Python, methods are properties that are functions, so methods are retrieved by [[Reflection/List properties|getting properties]] and filtering, using (e.g.) <code>[https://docs.python.org/3.5/library/functions.html#dir dir()]</code> and a list comprehension. Python's <code>[https://docs.python.org/3.5/library/inspect.html#module-inspect inspect]</code> module offers a simple way to get a list of an object's methods, though it won't include wrapped, C-native methods (type 'method-wrapper', type 'wrapper_descriptor', or class 'wrapper_descriptor', depending on version). Dynamic methods can be listed by overriding <code>[https://docs.python.org/3/reference/datamodel.html#object.__dir__ __dir__]</code> in the class.

 

 

# Sample classes for inspection

# names using inspect

map(lambda t: t[0], inspect.getmembers(sub, predicate=inspect.ismethod))

 

=={{header|Ring}}==

# Project : Reflection/List methods

 

func f4

see "hello from f4" + nl

Output:

<pre>

Dynamic methods can be listed by overriding these methods. Ancestor methods can be filtered out by subtracting a list of methods from the ancestor.

 

class Super

CLASSNAME = 'super'

#=> [:superOwn, :subOwn, :incr]

p sub.singleton_methods

 

=={{header|Scala}}==

===Java Interoperability===

{{Out}}Best seen running in your browser by [https://scastie.scala-lang.org/5mLHFfBeQCuGpc9Q7PXxgw Scastie (remote JVM)].

 

private val obj = new {

clazz.getDeclaredMethods.foreach(m => println(s"${m}}"))

 

 

=={{header|Sidef}}==

The super-method ''Object.methods()'' returns an Hash with method names as keys and ''LazyMethod'' objects as values. Each ''LazyMethod'' can be called with zero or more arguments, internally invoking the method on the object on which ''.methods'' was called.

method foo { }

method bar(arg) { say "bar(#{arg})" }

 

var meth = obj.methods.item(:bar) # `LazyMethod` representation for `obj.bar()`

 

=={{header|Tcl}}==

In TclOO, the <tt>info</tt> command can inspect the complete state of an object or a class, including private and methods:

 

 

For <i>many</i> more examples, see https://wiki.tcl.tk/40640 and the linked manuals for <tt>info class</tt> and <tt>info object</tt>. Plugins for <b>tkcon</b> and <b>twDebugInspector</b> (also found on the wiki) use this to create interactive object inspectors similar to [[Smalltalk]]'s.

 

=={{header|zkl}}==

Every object has a "methods" method, which returns a list of method names [for that object]. If you want to get a method from a string, you can use reflection.

methods.println();

{{out}}

<pre>