Delegates: Difference between revisions

=={{header|Ada}}==

All that is needed in order to implement this is a common base type. The delegator holds a pointer to an "untyped" object from the base class. Querying if the target implements the delegate interface is done using run-time type identification.

procedure Delegation is

A.Delegate := Has_Thing'Access; -- Set a thing

Put_Line (A.Operation);

Sample output:

<pre>

=={{header|Aikido}}==

class Delegator {

public generic delegate = none

println (d1.operation())

=={{header|Aime}}==

thing(void)

{

return 0;

=={{header|ALGOL 68}}==

As Algol 68 doesn't have classes, we supply a non-OO approximation, similar to the C version.

# The delegate mode - the delegate is a STRUCT with a single field #

)

{{out}}<pre>

No delegate : default implementation

What is your proposal to solve that in the code?

10 REM DELEGATION CODE AND EXAMPLE . ATARI BASIC 2020 A. KRESS andreas.kress@hood-group.com

14 REM

130 DELEGATE=80:REM DELEGATE IS

140 GOSUB 20:REM INIT DELEGATOR

{{out}}<pre>

RUN

=={{header|C}}==

As best you can do, without support for classes.

#include <stdlib.h>

#include <string.h>

Delegator_Operation( theDelegator, 3, del2));

return 0;

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

interface IOperable

}

}

Output:

<pre>Default implementation.

Delegates in the C# or D style are available in C++ through std::tr1::function class template. These delegates don't exactly match this problem statement though, as they only support a single method call (which is operator()), and so don't support querying for support of particular methods.

#include <tr1/memory>

#include <string>

*/

}

=={{header|Clojure}}==

(thing [_]))

(defrecord Delegate []

Thing

{{out}}

=={{header|CoffeeScript}}==

{{trans|Python}}

class Delegator

operation: ->

testDelegator()

output

> coffee foo.coffee

default implementation

default implementation

Delegate Implementation

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

In CLOS, methods exist apart from classes, and are specialized based on the types of their arguments. This example defines two classes (delegator and delegate), and a thing generic method which is specialized in three ways: (1) for 'any' argument, providing a default method; (2) for delegators, where thing is recursively applied to the delegator's delegate (if there is one); and (3) for delegates.

(:documentation "Thing the object."))

(assert (string= "no delegate" (thing d1)))

(assert (string= "default implementation" (thing d2)))

=={{header|D}}==

''Delegate'' object and pass a real delegate directly to '''Delegator'''.

string delegate() hasDelegate;

writeln(dr.operation());

writeln(dr.setDg(thing).operation());

{{out}}

<pre>Default implementation

===Version using Tango===

{{libheader|tango}}

class Delegator

Stdout ( dr.setDg(thing).operation ).newline;

return 0;

=={{header|Dart}}==

I didn't find a way to check for existing methods, so the version with Object doesn't work yet. The code is adapted from the Java version, but using var instead of an Interface

var delegate;

a.delegate = d;

Expect.equals("delegate implementation",a.operation());

=={{header|Delphi}}==

Translation of the Java example found at [http://en.wikipedia.org/wiki/Delegation_pattern Wikipedia].

interface

end;

{$APPTYPE CONSOLE}

PrinterObj.Free;

end;

=={{header|E}}==

/** construct without an explicit delegate */

to run() {

> })

> delegator.operation()

=={{header|Elena}}==

Using multi methods:

import system'routines;

console.printLine(delegator.operate())

}

Generic solution:

import system'routines;

console.printLine(delegator.operate())

}

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

let defaultOperation() = "default implementation"

let mutable del = null

d.Delegate <- new Delegate()

=={{header|Forth}}==

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

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

:class delegate

slave master !:

master operation \ => delegate implementation

=={{header|Go}}==

import "fmt"

a.delegate = d

fmt.Println(a.operation()) // prints "delegate implementation"

=={{header|Io}}==

{{trans|Python}}

delegate ::= nil

operation := method(

a setDelegate(Delegate clone)

{{out}}

<pre>default implementation

Life becomes slightly cleaner if we delegate to ourselves in the absence of some other delegate.

operation=:3 :'thing__delegate ::thing y'

thing=: 'default implementation'"_

NB. set context in case this script was used interactively, instead of being loaded

Example use:

operation__obj''

default implementation

└─┘

operation__obj''

=={{header|Java}}==

This implementation uses an interface called Thingable to specify the type of delegates that respond to thing(). The downside is that any delegate you want to use has to explicitly declare to implement the interface. The upside is that the type system guarantees that when the delegate is non-null, it must implement the "thing" method.

String thing();

}

assert a.operation().equals("anonymous delegate implementation");

}

{{works with|Java|8+}}

@FunctionalInterface

public interface Thingable {

public String thing();

import java.util.Optional;

;

}

@FunctionalInterface

return () -> thingable;

}

public final class Delegate implements Thingable {

return "delegate implementation";

}

// Example usage

assert d5.operation().equals("lambda expression implementation");

}

=={{header|JavaScript}}==

{{trans|Python}}

this.delegate = null ;

this.operation = function(){

a.delegate = new Delegate() ;

document.write(a.operation() + "\n") ;

=={{header|Julia}}==

'''Module''':

export Delegator, Delegate

thing(::Delegate) = "delegate implementation"

'''Main''':

a = Delegator(nothing)

@show Delegates.operation(a)

@show Delegates.operation(b)

{{out}}

The first two scenarios are not therefore strictly possible though the second can be simulated by passing a 'responds' parameter to the delegate class constructor.

interface Thingable {

val dd2 = Delegator(d2)

println(dd2.operation())

{{out}}

{{trans|Python}}

self delegate := Nil.

self clone := {

;; Delegate which implements `thing`

foo delegate := Delegate.

=={{header|Logtalk}}==

We use prototypes instead of classes for simplicity.

% and implementation for delegator objects

a_delegator::operation(String3),

String3 == 'delegate implementation'

=={{header|Lua}}==

return {

operation = function(self)

assert(d:operation() == "delegate implementation")

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

Module Checkit {

\\ there are some kinds of objects in M2000, one of them is the Group, the user object

Checkit

{{out}}

<pre>

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

If[StringQ[del@operate], del@operate, "default implementation"];

del1 = Null;

del2@banana = "phone";

del3@operate = "delegate implementation";

{{out}}

<pre>default implementation

=={{header|NGS}}==

type Delegator

echo(a.operation())

{{out}}

<pre>default implementation

=={{header|Nim}}==

# Base delegate.

let d2 = initDelegator(Delegate2())

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

method : virtual : public : Thing() ~ String;

}

}

}

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

{{works with|Cocoa}}

{{works with|GNUstep}}

@interface Delegator : NSObject {

return 0;

Objective-C 2.0, modern runtime, Automatic Reference Counting, Autosynthesize (LLVM 4.0+)

{{works with|Cocoa}}

// Formal protocol for the delegate

}

return 0;

=={{header|Oforth}}==

Object Class new: Delegate2

Delegator method: operation

@delegate respondTo(#thing) ifTrue: [ @delegate thing return ]

Usage :

Default implementation

Delegator new(Delegate2 new) operation

=={{header|ooRexx}}==

delegator = .delegator~new -- no delegate

say delegator~operation

nomethod:

return "default implementation"

=={{header|OxygenBasic}}==

class DelegateA 'not implmenting thing()

'==============

print dgr.thing 'result "not using Delegate"

print dg.thing 'result "Delegate Implementation"

=={{header|Oz}}==

{{trans|Python}}

class Delegator from BaseObject

attr

{A set({New Delegate noop})}

=={{header|Pascal}}==

=={{header|Perl}}==

{{trans|Python}}

package Delegator;

$a->{delegate} = Delegate->new;

$a->operation eq 'delegate implementation' or die;

Using Moose.

use 5.010_000;

$delegator->operation eq 'delegate implementation' or die;

=={{header|Phix}}==

I will admit that the whole concept of "no delegate/with one that does not implement" makes no sense whatsoever to me.<br>

While I've shown this using a single rid, you could of course hold an entire sequence of them or even better a dictionary and use named lookups for rids in that.

function operation(object o)

?operation(x)

?operation(y)

{{out}}

</pre>

Obviously, you can explictly test for rid=NULL as shown, or remove that test and catch exceptions, ie:

try -- (since rid=NULL check commented out)

?operation(y)

?"oops, no implementation"

end try

=={{header|PHP}}==

{{trans|Python}}

function __construct() {

$this->delegate = NULL ;

$a->delegate = new Delegate() ;

=={{header|PicoLisp}}==

# delegate

# With delegate that implements 'thing>'

(put A 'delegate (new '(+Delegate) "delegate implementation"))

Output:

<pre>"default implementation"

=={{header|Pop11}}==

define :class Delegator;

slot delegate = false;

;;; delegating to a freshly created Delegate

newDelegate() -> delegate(a);

=={{header|Python}}==

def __init__(self):

self.delegate = None

# With delegate that implements "thing"

a.delegate = Delegate()

=={{header|Racket}}==

follows the requirement of the task better.

;; Delegates. Tim Brown 2014-10-16

(send delegator-2 operation) => "delegate implementation"

(send (new delegator% [delegate thinging-delegate]) operation) => "delegate implementation"))

All the tests pass. Believe me.

=={{header|Raku}}==

(formerly Perl 6)

class Delegate {

$d.delegate = Delegate.new;

=={{header|Ruby}}==

{{trans|Python}}

attr_accessor :delegate

def operation

a.delegate = Delegate.new

puts a.operation # prints "delegate implementation"

Using Forwardable lib

class Delegator; extend Forwardable

a = Delegator.new

puts a.delegated # prints "Delegate"

=={{header|Rust}}==

Requiring delegates to implement Thingable:

fn thing(&self) -> &str;

}

let d: Delegator<Delegate> = Delegator(Some(Delegate {}));

println!("{}", d.thing());

{{Out}}

<pre>Default implmementation

Using nightly-only specialization feature:

trait Thingable {

let d: Delegator<Delegate> = Delegator(Some(Delegate {}));

println!("{}", d.thing());

{{Out}}

<pre>Default implementation

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/cCYD9tQ/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/2TWYJifpTuOVhrAfWP51oA Scastie (remote JVM)].

def thing: String

}

assert(a.operation == "anonymous delegate implementation")

=={{header|Sidef}}==

class Delegate {

say "NonDelegate: #{d.operation}"

d.delegate = Delegate()

{{out}}

empty: default implementation

{{works with|Smalltalk/X}}

Definition of the thingy:

subclass:#Thingy

instanceVariableNames:''

thing

Definition of the delegator:

subclass:#Delegator

instanceVariableNames:'delegate'

operation

^ delegate

Sample use:

d := Delegator new.

d operation.

d delegate:(Thingy new).

d operation.

=={{header|Swift}}==

Allowing the delegate to be any type and taking advantage of dynamism of method lookup:

protocol Thingable { // prior to Swift 1.2, needs to be declared @objc

let d = Delegate()

a.delegate = d

Alternately, requiring the delegate to conform to a given protocol:

func thing() -> String

}

let d = Delegate()

a.delegate = d

=={{header|Tcl}}==

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

Uses [[Assertions#Tcl]]

oo::class create Delegate {

assert {[a operation] ne "default implementation"}

To code the <code>operation</code> method without relying on catching an exception, but strictly by using introspection:

if { [info exists delegate] &&

[info object isa object $delegate] &&

set result "default implementation"

}

=={{header|Vorpal}}==

Delegate objects can be an array of delegates or as a single delegate.

a.f = method(){

.x.print()

d.delegate = a

d.x = 7

The resulting output:

=={{header|Wren}}==

Wren is dynamically typed so we can plug any kind of delegate into the Delegator.

thing { }

}

// with a delegate that does implement Thingable

d.delegate = Delegate2.new()

{{out}}

=={{header|zkl}}==

{{trans|Scala}}

class Delegator{

}

a:= Delegator();

a.operation().println(); //--> "default implementation"

// With a delegate:

a.delegate = Delegate();

A second example

var [mixin=File] dst; // File like semantics, eg Data, Pipe

dst = File.DevNull;

// initially, the logger does nothing

fcn log(msg){dst.writeln(vm.pasteArgs())}

Logger.dst=Console;

Logger.log("this is a test 2"); //-->writes to Console

class B(Logger){ log("Hello from ",self,"'s constructor"); }

The base class B was constructed at startup,