Reflection/List methods: Difference between revisions

{{omit from|Modula-2}}

{{omit from|Rust}}

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

opEquals

factory</pre>

 

=={{header|Elena}}==

import system'dynamic;

import extensions;

var o := new MyClass();

{

console.printLine("o.",p)

}

{{out}}

<pre>

o.myMethod1[1]

o.myMethod2[2]

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

 

of each exported method.<br>

privateMethod is not exported because the first character is lowercase.

 

import (

}

fmt.Println()

{{out}}

<pre>

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

</pre>

 

=={{header|J}}==

NB. define a stack class

coclass 'Stack'

COCREATOR items

 

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

print "Hello World"

end

end

 

{{out}}

<pre>assert

 

=={{header|Nanoquery}}==

class Methods

def static method1()

for method in dir(new(Methods))

println method

 

{{out}}

=={{header|Nim}}==

Nim separates data and functions, but with method call syntax, any function that has that object as its first parameter can be used like a method:

proc bar(f:Foo) = echo "bar"

var f:Foo

this also means object 'methods' can be defined across multiple source files

 

and

* have our type, or a related type (var Foo, ptr Foo, ref Foo) as first parameter

{.experimental: "caseStmtMacros".}

macro listMethods(modulepath:static string, typename): untyped =

.._]: procs.add($name)

result = newLit(procs)

type Bar = object

proc a*(b: Bar) = discard

template c*(b: var Bar, c: float) = discard

iterator d*(b: ptr Bar):int = discard

proc second_param*(a: int, b: Bar) = discard #will not match

proc unexported(a: Bar) = discard #will not match

template thisfile:string =

instantiationInfo().filename

echo thisfile.listMethods(Bar)

#works for any module:

#const lib = "/path/to/nim/lib/pure/collections/tables.nim"

{{out}}<pre>@["a", "b", "c", "d", "e"]

@["[]=", "[]", "[]", "hasKey", "contains", "hasKeyOrPut", "getOrDefault", "getOrDefault", "mgetOrPut", "len", "add", "del", "pop", "take", "clear", "$", "withValue", "withValue", "pairs", "mpairs", "keys", "values", "mvalues", "allValues"]</pre>

 

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

#import <objc/runtime.h>

 

free(methods);

return 0;

{{out}}

<pre>

Note that the overloaded comparison operator also shows up in the list of methods.

 

 

use overload ('<=>' => \&compare);

 

my $a = Nums->new(42);

{{out}}

<pre>double

 

Another alternative is the module <code>Class::MOP</code>, which implements a meta-object protocol for the Perl. It alters nothing about Perl's object system; it is just a tool for manipulation and introspection. Note that this output includes methods inherited methods (<tt>DOES, VERSION, can, isa</tt>)

my $meta = Class::MOP::Class->initialize( ref $a );

{{out}}

<pre>compare

===emulated===

Even before the introduction of classes (see below), but this sort of thing was fairly easy to emulate.

{{out}}

<pre>

Needs 0.8.1+

Note that content from and parameters to get_struct_fields() may change between releases.

{{out}}

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

Each is represented as a <tt>Method</tt> object that contains a bunch of info:

 

method foo ($x) { }

method bar ($x, $y) { }

for $object.^methods {

say join ", ", .name, .arity, .count, .signature.gist

 

{{out}}

 

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