Abstract type: Difference between revisions

'''Task''': show how an abstract type can be declared in the language. If the language makes a distinction between interfaces and partially implemented types illustrate both.

=={{header|11l}}==

You can declare a virtual function to not have an implementation by using <code>F.virtual.abstract</code> keyword. A type containing at least one abstract virtual function cannot be instantiated.

F.virtual.abstract enqueue(Int item) -> N

=={{header|AArch64 Assembly}}==

=={{header|ABAP}}==

=== Abstract Class ===

public section.

methods method1 abstract importing iv_value type f exporting ev_ret type i.

2. Variables must be static final. The values may be computed at run time.

3. No static initialiser blockers. No static initialiser helper methods.

methods: method1 importing iv_value type f exporting ev_ret type i,

method2 importing iv_name type string exporting ev_ret type i,

=={{header|ActionScript}}==

While ActionScript does not support explicit abstract classes, it does have interfaces. Interfaces in ActionScript may not implement any methods and all methods are public and implicitly abstract. Interfaces can extend other interfaces, and interfaces may be multiply inherited.

{

public interface IInterface

Abstract types can also be simulated using the built-in <code>flash.utils.getQualifiedClassName()</code> function in the constructor to check that the runtime type is an inhertied class, and throwing exceptions from "abstract" methods which can be overridden by inheritors to disable them. If any inheriting class does not implement an abstract method, the error will not be thrown until the non-implemented method is called.

package {

import flash.utils.getQualifiedClassName;

Inheriting this class:

package {

===Interface===

Interfaces in [[Ada]] may have no components or implemented operation except for ones implemented as null operations. Interfaces can be multiply inherited.

procedure Enqueue (Lounge : in out Queue; Item : in out Element) is abstract;

procedure Dequeue (Lounge : in out Queue; Item : in out Element) is abstract;</syntaxhighlight>

Interfaces can be declared synchronized or task when intended implementations are to be provided by protected objects or [[task]]s. For example:

procedure Plan (Manager : in out Scheduler; Activity : in out Job) is abstract;</syntaxhighlight>

===Abstract type===

Abstract types may provide components and implementation of their operations. Abstract types are singly inherited.

...

type Node is abstract new Ada.Finalization.Limited_Controlled and Queue with record

Using [http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Records records] for storing the interface methods and [http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.InstanceArguments instance arguments] (which are [http://wiki.portal.chalmers.se/agda/pmwiki.php?n=ReferenceManual.ModellingTypeClassesWithInstanceArguments similar] to Haskell type classes) for overloading:

open import Function

An abstract class contains functions that have no body defined. You cannot instantiate a class that contains abstract functions.

public function method1...

public function method2...

}</syntaxhighlight>

Interfaces in Aikido define a set of functions, operators, classes, interfaces, monitors or threads (but no variables) that must be implemented by a class implementing the interface.

function isFatal : integer

function operate (para : integer = 0)

In AmigaE, abstract methods are supported but interfaces are not.

OBJECT fruit

ENDOBJECT

=={{header|Apex}}==

// Interface

public interface PurchaseOrder {

=={{header|Argile}}==

{{works with|Argile|1.0.0}}

(: abstract class :)

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_L}}

static color

If !color

{{works with|BBC BASIC for Windows}}

BBC BASIC is a procedural language with no built-in OO features. The CLASSLIB library implements simple Object Classes with multiple inheritance; an abstract class may be created without any instantiation, the sole purpose of which is for other classes to inherit from it. At least one member or method must be declared, but no error will be generated if there is no implementation:

REM Declare a class with no implementation:

==={{header|QB64}}===

QB64, along with QBasic and QuickBasic (without extension), is not Object-Oriented; however, the following addresses issues raised in the description of the problem as well as the problem itself:

'said, the following is both legal and executable.

{{works with|QuickBasic|4.5}}

{{trans|QB64}}

TYPE c

The header file for the abstract class, interfaceAbs.h

#define INTERFACE_ABS

the code is in file silly.h. Note the actual structure of the class is not provided

here. We don't want it visible.

#define SILLY_H

#include "intefaceAbs.h"

Ok. Now it is necessary to provide the implementation of the realizable class.

This code should be in silly.c.

#include <string.h>

#include <stdio.h>

Now all's left is some example code that uses all this stuff.

#include "silly.h"

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

{

public abstract void method1();

=={{header|C++}}==

You can declare a virtual function to not have an implementation (called "pure virtual function") by the following "<tt>= 0</tt>" syntax after the method declaration. A class containing at least one pure virtual function (or inheriting one and not overriding it) cannot be instantiated.

public:

virtual int method1(double value) = 0;

In Caché, abstract and data type classes cannot be instantiated directly - there must be a 'concrete subclass' that extends them as well as the '%RegisteredObject' class in order to instantiate an object, see example below.

{

Parameter SHAPE = 1;

Data type classes differ because they cannot contain properties, see example below.

{

Parameter SHAPE = 1;

Using defprotocol, we can define what is essentially an interface.

=={{header|COBOL}}==

===Interface===

{{trans|F#}}

PROCEDURE DIVISION.

In Common Lisp, classes do not implement methods, but methods specialized for particular kinds of arguments may be defined for generic functions. Since we can programmatically determine whether methods are defined for a list of arguments, we can simulate a kind of abstract type. We define an abstract type <code>kons</code> to which an object belongs if methods for <code>kar</code> and <code>kdr</code> are defined for it. We define a type predicate <code>konsp</code> and a type <code>kons</code> in terms of the type predicate.

(:documentation "Return the kar of a kons."))

We can make the built-in types <code>cons</code> and <code>integer</code> <code>kons</code>es. We start with <code>cons</code>, using the obvious definitions.

(car cons))

For integers, we'll define the <code>kar</code> of <var>n</var> to be <var>1</var> and the <code>kdr</code> of <var>n</var> to be <var>n - 1</var>. This means that for an integer <var>n</var>, <var>n</var> = <code>(+ (kar <var>n</var>) (kdr <var>n</var>))</code>.

1)

=={{header|Component Pascal}}==

(* Abstract type *)

Object = POINTER TO ABSTRACT RECORD END;

</syntaxhighlight>

...

(* Abstract method of Object *)

PROCEDURE (dn: Object) Show*, NEW, ABSTRACT;

=={{header|Crystal}}==

abstract def move

abstract def think

=={{header|D}}==

class Foo {

Abstract Class introduced in Delphi 2006. An abstract class cannot be instantiated and must be derived from in order to be used.

...

end;</syntaxhighlight>

Abstract Methods can only be implemented in derived classes. A concrete class that contains abstract methods can be instantiated. A warning will be generated at compile time, and an EAbstractError exception will thrown if the method is called at run time.

TMyObject = class(TObject)

public

A simple abstract type without enforcement can be created using the interface expression:

to bar(a :int, b :int)

}</syntaxhighlight>

With enforcement, a separate ''stamp'' is created which must be applied to the instances. This is analogous to a Java interface.

to bar(a :int, b :int)

}

=={{header|Eiffel}}==

deferred class

AN_ABSTRACT_CLASS

A more expressive view of an Abstract type in Eiffel:

note

title: "Prototype Person"

=={{header|Elena}}==

{

abstract run();

=={{header|F Sharp|F#}}==

A type with only abstract members and without constructors is an '''interface''' (when not marked with the <code>AbstractClass</code> attribute). Example:

abstract Perimeter: unit -> float

abstract Area: unit -> float

A type that leaves some or all members unimplemented, is an '''abstract class'''. It has to be marked with the <code>AbstractClass</code> attribute. Example:

type Bird() =

// an abstract (=virtual) method with default impl.

=={{header|Fantom}}==

abstract class X

{

{{trans|Fantom}}

There are numerous, mutually incompatible object oriented frameworks for Forth. This one works with the FOOS preprocessor extension of [[4tH]].

:: X()

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

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

The FMS object extension uses duck typing and so has no need for abstract types.

=={{header|Fortran}}==

Simple abstract derived type (i.e. abstract class) in Fortran 2008

! abstract derived type

type, abstract :: TFigure

However, you can effectively create an abstract type by declaring all its methods to be abstract, so that they do not require a body in the declaring type itself. Such methods can then be overridden and implemented by its derived types. For example :-

Type Animal Extends Object

=={{header|Genyris}}==

In Genyris by default there are no constructors. In effect all classes are Abstract until they are used to tag (describe) an object. This in keeping with the language's roots in Description Logic. To prevent the class ever being associated with an instance it suffices to force the validator to fail.

def .valid?(object) nil

However this is not much use if we want to use an abstract class to define an '''interface'''. Here is a quasi-abstract class which can be used to tag objects if they conform to the class's membership expectations. In this case it wants two methods, ''.enstack'' and ''.destack'':

def .valid?(object)

object

So if ever we find an object which conforms to the validator it can be tagged. Here's a 'traditional' class definition using the Object class which ''does'' provide a constructor:

def .init()

var .items ()

tmp</syntaxhighlight>

Now we can tag an object that conforms to the Interface:

=={{header|Go}}==

In the following example, the Dog and Cat types both satisfy the Beast interface because they each have the specified methods. The ''bprint'' function can print details for any Beast.

import "fmt"

As in [[Java]], methods that are declared but not implemented are called "abstract" methods. An interface is a class-level typing construct that can only contain abstract method declarations (well, and constants, but pay no attention to those).

int method1(double value)

int method2(String name)

An abstract class may implement some of its methods and leave others unimplemented. The unimplemented methods and the class itself must be declared "abstract".

abstract public int methodA(Date value)

abstract protected int methodB(String name)

An abstract class may also be used to partially implement an interface. Here class "Abstract2" implements the "add" method from the inherited "Interface", but leaves the other two methods, "method1" and "method2", unimplemented. Abstract methods that an abstract class inherits from an interface or another abstract class do not have to be redeclared.

int add(int a, int b) { a + b }

}</syntaxhighlight>

Interfaces and abstract classes cannot be instantiated directly. There must be a "concrete subclass" that contains a complete implementation in order to instantiate an object.

public int method1(double value) { value as int }

public int method2(String name) { (! name) ? 0 : name.toList().collect { it as char }.sum() }

Obligatory test:

assert c1 instanceof Interface

println (new Concrete1().method2("Superman"))

For example, the built-in type class Eq (the types that can be compared for equality) can be declared as follows:

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool</syntaxhighlight>

Default implementations of the functions can be provided:

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool

Consider the following function which uses the operator == of the type class Eq from above. The arguments to == above were of the unknown type "a", which is of class Eq, so the type of the expression below now must include this restriction:

func x = x == x</syntaxhighlight>

Suppose I make a new type

One could then provide an implementation ("instance") the type class Eq with this type

(Foo x1 str1) == (Foo x2 str2) =

(x1 == x2) && (str1 == str2)</syntaxhighlight>

An abstract class is a class with abstract methods. Icon is not object-oriented.

abstract method compare(l,r) # generates runerr(700, "method compare()")

end</syntaxhighlight>

Methods that don't have an implementation are called abstract methods in Java. A class that contains an abstract method or inherits one but did not override it must be an abstract class; but an abstract class does not need to contain any abstract methods. An abstract class cannot be instantiated. If a method is abstract, it cannot be private.

public abstract int method1(double value);

protected abstract int method2(String name);

}</syntaxhighlight>

Before Java 8, interfaces could not implement any methods and all methods were implicitly public and abstract.

int method1(double value);

int method2(String name);

Usage:

abstract type «name» <: «supertype» end</syntaxhighlight>

Examples:

abstract type Real <: Number end

abstract type FloatingPoint <: Real end

Here's a very simple (and silly) example of both:

interface Announcer {

=={{header|Lasso}}==

Instead of abstract classes or interfaces, Lasso uses a [http://lassoguide.com/language/types.html trait system].

require get(index::integer)

In some movie script:

-- 'raw' instance of abstract class is made parent ("ancestor") of the

-- passed instance, i.e. the passed instance extends the abstract class

Parent script "AbstractClass":

on new (me)

-- optional: show error message as alert

Parent script "MyClass"

on new (me)

Usage:

obj.ring(3)

-- "Bell"

In some movie script:

interfaceFuncs = interfaceClass.handlers()

funcs = instance.handlers()

Parent script "InterfaceClass":

(Note: in Lingo closing function definitions with "end" is optional, so this a valid definition of 3 empty functions)

on bar

on foobar</syntaxhighlight>

Parent script "MyClass":

-- if this class doesn't implement all functions of the

-- interface class, instantiation fails

Usage:

put obj -- would show <Void> if interface is not fully implemented

-- <offspring "MyClass" 2 171868></syntaxhighlight>

Logtalk supports the definition of interfaces (protocols), which can contain public, protected, and private declarations of methods (predicates). In addition, an object can qualify an implements relation with an interface (protocol) using the keywords "public", "protected", and "private".

:- protocol(datep).

=={{header|Lua}}==

Lua does not include built-in object oriented paradigms. These features can be added using simple code such as the following:

function class ( baseClass )

BaseClass.abstractClass = abstractClass</syntaxhighlight>

The 'class' function produces a new class from an existing parent class (BaseClass is default). From this class other classes or instances can be created. If a class is created through the 'abstractClass' function, however, the resulting class will throw an error if one attempts to instantiate it. Example:

AA = A:class() -- New class AA inherits from existing class A

B = abstractClass() -- New abstract class B

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

M2000 not use interfaces, but can combine groups (used as objects), and because we can alter definitions, we can make an Abstract group by implement modules and functions with a call to Error "not implement yet"

Private:

      x as double=1212, z1 as currency=1000, k$="ok"

Mathematica is a symbolic language and as such does not support traditional object oriented design patterns. However, it is quite easy to define pseudo-interfaces that depend on an object implementing a set of functions:

(* Define an interface, Foo, which requires that the functions Foo, Bar, and Baz be defined *)

InterfaceFooQ[obj_] := ValueQ[Foo[obj]] && ValueQ[Bar[obj]] && ValueQ[Baz[obj]];

=={{header|MATLAB}}==

; Abstract Class

...

end</syntaxhighlight>

When you define any abstract methods or properties, MATLAB® automatically sets the class Abstract attribute to true.

; Abstract Methods

abstMethod(obj)

end</syntaxhighlight>

* Concrete subclasses are not required to support the same number of input and output arguments and do not need to use the same argument names. However, subclasses generally use the same signature when implementing their version of the method.

; Abstract Properties

AbsProp

end</syntaxhighlight>

these features by default for all tpyes.

:- interface.

=={{header|Nemerle}}==

namespace RosettaCode

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

=={{header|newLISP}}==

; url: http://rosettacode.org/wiki/Abstract_type

; author: oofoe 2012-01-28

=={{header|Nim}}==

In Nim type classes can be seen as an abstract type. Type classes specify interfaces, which can be instantiated by concrete types.

Comparable = concept x, y

(x < y) is bool

Source: [https://github.com/nitlang/nit/blob/master/examples/rosettacode/abstract_type.nit the official Nit’s repository]

#

# Methods without implementation are annotated `abstract`.

=={{header|Oberon-2}}==

{{Works with|oo2c Version 2}}

TYPE

Animal = POINTER TO AnimalDesc;

=={{header|Objeck}}==

class ClassA {

method : virtual : public : MethodA() ~ Int;

The equivalent of what is called abstract type in the other OO examples of this page is just called '''virtual''' in Objective Caml to define '''virtual methods''' and '''virtual classes''':

object

method virtual bar : int

In OCaml what we call an abstract type is not OO related, it is only a type defined without definition, for example:

it is used for example to hide an implementation from the interface of a module or for type algebra.

Example of abstracting a type in an interface:

type t

end = struct

Pure abstract types in the implementation:

type v

type 'a t

Unlike interfaces, properties can include method implementations and attributes (see lang/Comparable.of for instance).

Spherical method: radius @r ;

Spherical method: setRadius := r ;

Usage :

| b p |

Ballon new($red, 0.1) ->b

===Interface===

-- shape is the interface class that defines the methods a shape instance

-- is expected to implement as abstract methods. Instances of the shape

===Abstract Type===

-- shape is the abstract class that defines the abstract method area

-- which is then implemented by its two subclasses, rectangle and circle

There are no abstract types as part of the language, but we can do as in Python and raise exceptions:

class BaseQueue

attr

=={{header|Perl}}==

use strict;

Since Perl 5.12, the Yadda Yadda operator (...) dies with an Unimplemented error,

package AbstractFoo;

Raku inspired roles are provided by the [http://search.cpan.org/perldoc?Moose Moose] library

use Moose::Role;

Roles are also provided in a more lightweight form with [http://search.cpan.org/perldoc?Role::Tiny Role::Tiny] library

use Role::Tiny;

You can also have explicitly abstract classes (and/or abstract methods). Needs 0.8.1+

<span style="color: #008080;">abstract</span> <span style="color: #008080;">class</span> <span style="color: #000000;">job</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">id</span>

Methods that don't have an implementation are called abstract methods in PHP. A class that contains an abstract method or inherits one but did not override it must be an abstract class; but an abstract class does not need to contain any abstract methods. An abstract class cannot be instantiated. If a method is abstract, it must be public or protected

abstract public function method1($value);

abstract protected function method2($name);

}</syntaxhighlight>

Interfaces in PHP may not implement any methods and all methods are public and implicitly abstract.

public function method1($value);

public function method2($name);

=={{header|PicoLisp}}==

# There is just a naming convention where abstract classes start with a

# lower-case character after the '+' (the naming convention for classes).

=={{header|PowerShell}}==

#Requires -Version 5.0

</syntaxhighlight>

Create a new player:

$player1 = [Player]::new("sam bradford", "philadelphia eagles", "qb", 7)

$player1

</pre>

Trade the player:

$player1.Trade("minnesota vikings", 8)

$player1

</pre>

Create a new player:

$player2 = [Player]::new("demarco murray", "philadelphia eagles", "rb", 29)

$player2

</pre>

Trade the player:

$player2.Trade("tennessee titans")

$player2

=={{header|Python}}==

"""Abstract/Virtual Class

"""

Starting from Python 2.6, abstract classes can be created using the standard abc module:

class BaseQueue():

=={{header|Racket}}==

#lang racket

Raku supports roles, which are a bit like interfaces, but unlike interfaces in Java they can also contain some implementation.

use v6;

=={{header|REBOL}}==

Title: "Abstract Type"

URL: http://rosettacode.org/wiki/Abstract_type

=={{header|Red}}==

Title: "Abstract Type"

Original-Author: oofoe

=={{header|ReScript}}==

Here is an abstract type definition:

=={{header|REXX}}==

The Python and Tcl provisos apply to Ruby too. Nevertheless, a {{libheader|RubyGems}} package called [http://github.com/Peeja/abstraction/tree/master abstraction] exists where:

class AbstractQueue

Rust doesn't have traditional object oriented concepts such as classes, instead it uses a concept called traits. Traits are similar to abstract classes in the sense that they define an interface a struct must conform to. A trait can be defined as such:

fn area(self) -> i32;

}</syntaxhighlight>

The trait can then be implemented on a struct.

side_length: i32

}

Note, traits can also have a default implementation:

fn area(self) -> i32;

different meaning that described in this page. Here are some examples:

type A

var B: A

A function is automaticall attached to the interface, when it has an parameter of the interface type.

const type: myInterf is sub object interface;

=={{header|Sidef}}==

{{trans|Raku}}

# must be filled in by the class which will inherit it

method abstract() { die 'Unimplemented' };

Abtract Datatypes are declared using the VIRTUAL keyword.

For example, we need the following two procedures hash and equalto for a hash map implementation.

! ABSTRACT HASH KEY TYPE ;

LISTVAL CLASS HASHKEY;

</syntaxhighlight>

A concrete implementation can be derived as follows:

! COMMON HASH KEY TYPE IS TEXT ;

HASHKEY CLASS TEXTHASHKEY(T); VALUE T; TEXT T;

=={{header|Smalltalk}}==

A class is declared abtract by responding to the query <tt>isAbstract</tt> with true, and defining the required protocol for subclasses to raise an error notification. Optionally, instance creation can be blocked (but seldom done, as you will hit a subclassResponsibility anyway soon). Typically, the IDE provides menu functions to generate these definitions automatically (eg. "Insert Abstract Class" in the refactoring submenu of the class browser):

^ true

Here is an example signature for a queue data structure:

type 'a queue

val empty : 'a queue

will be abstract if we use opaque ascription. Instead we could create a version of the signature which specifies the type,

in which case it will never be abstract:

type 'a queue = 'a list

val empty : 'a queue

While in general Tcl does not use abstract classes at all (and has no need at all for interfaces due to supporting multiple inheritance and mixins), an equivalent effect can be had by concealing the construction methods on the class instance; instances are only created by subclassing the class first (or by mixing it in). In this example, the methods are also error-returning stubs...

method enqueue item {

error "not implemented"

}</syntaxhighlight>

=={{header|Vala}}==

public void eat() {

print("Chomp! Chomp!\n");

* By convention all abstract classes have one or more Protected constructors.

Protected Sub New()

Interfaces may contain Functions, Subroutines, Properties, and Events.

Sub Method_Must_Be_Implemented()

End Interface</syntaxhighlight>

In the following example, the Dog and Cat types both satisfy the Beast interface because they each have the specified methods. The ''bprint'' function can print details for any Beast.

kind() string

name() string

The Go example, when rewritten in Wren, looks like this.

class Beast{

=={{header|zkl}}==

In zkl, nothing is ever abstract, objects are always runnable. However, it is easy to define "meta" objects, objects that define an interface/api for a "class" of objects. For example, it is desirable for "stream" objects (such as File, List, etc) to share semantics so that code doesn't need to know what the source object really is.

var [proxy protected]

isBroken = fcn { _broken.isSet() },

And now for a "real" object:

var [const] fileName = "DevNull"; // compatibility with File

fcn init { Stream.init() }

{{omit from|ALGOL 68}}

{{omit from|AWK}}

{{omit from|BASIC}}

{{omit from|Falcon|Does not support the concept of an abstract type.}}

{{omit from|gnuplot}}

{{omit from|Integer BASIC}}

{{omit from|JavaScript}}

{{omit from|LaTeX}}

{{omit from|Make}}

{{omit from|Maxima}}

{{omit from|Metafont}}

{{omit from|ML/I}}

{{omit from|Modula-2}}

{{omit from|Scratch}}

{{omit from|TI-89 BASIC|Does not have static or user-defined types.}}

{{omit from|UNIX Shell}}

{{omit from|ZX Spectrum Basic}}