Código Delphi [-]
function TForm1.Algo:Integer;
begin
   Result := 2;
end;

Código Delphi [-]
procedure Algo(var Numero: integer);
begin
  Numero := (Numero * Numero) + Numero;
end;

Código Delphi [-]
function Algo(Numero: integer): integer;
begin
  result := (Numero * Numero) + Numero;
end;

Código Delphi [-]
unit UEjemplo;

interface
{Aqui declaro el cuerpo y la estructura. Todo en forma declarativa,
y no en forma "procedimental". Es decir que en esta sección no se encuentra
el código sino la declaración.
La sección interface sirve para hacer público el comportamiento de la unidad.
Es decir que lo declarado aquí será visto desde "afuera"}

{En este ejemplo desde cualquier otra unidad que haga uso de ésta (UEjemplo) se
podrá ver:
 * UNA_CONSTATE
 * TArreglo
 * TClase
}

uses
  {Unidades que usa la Unit UEjemplo}
  SysUtils, QDialogs;

const
  UNA_CONSTANTE = 1000;

type
  TArreglo = array[1..UNA_CONSTANTE] of integer;

  {Un ejemplo de clase}
  TClase = class
    {Una clase tiene 4 secciones: private, protected, public, published}
    private
    {Desde afuera de la clase no se puede tener acceso a esta sección. Por
      Tanto FCantidad es privada, solo puede ser empleada desde "adentro"
      de la propia clase}
      FCantidad: integer;
      {Primero se listan las variables y luego las funciones y/o procedimientos}
      procedure SetCantidad(Value: integer);
    public
     {Lo dispuesto en public es visto desde afuera. Cantidad es una propiedad
     y permite cambiar el valor de FCantidad mediante SetCantidad}
      property Cantidad: integer read FCantidad write SetCantidad;
  end;


implementation
{Lo declarado en implementation no es visto desde afuera. Tiene 2 propósitos:
1. Ocultar alguna función o procedimiento
2. Mantener el código}

var unArreglo: TArreglo;

procedure ProcedimientoOculto;
{Este procedimiento está oculto. No puede ser visto desde afuera}
var i: integer;
begin
  for i := 0 to UNA_CONSTANTE do
    unArreglo[i] := i;
end;

procedure Aviso;
begin
  ShowMessage('Se ha disparado la unidad');
end;

{ --- Aqui comienza el cuerpo de la clase ----}
procedure TClase.SetCantidad(Value: integer);
begin
  if Value <> FCantidad
     then FCantidad := Value
     else raise Exception.Create('Cantidad ya tiene dicho valor');
end;

initialization
{Esta sección es opcional. Y se usa para que cuando se "inicie" esta unidad
 se disparen algunos procedimientos, funciones, eventos.. etc}
  ProcedimientoOculto;
  Aviso;

end.

Código Delphi [-]
uses
  UEjemplo;

Código Delphi [-]

unit Foo;

interface

public function Foo(): boolean;

implementation

public function Foo(): boolean;
begin
  {...}
  result := true;
end;

end.

Código Delphi [-]

unit Foo;

interface

type
  TFoo = class
  public 
    function Foo(): boolean;
  end;

implementation

{ TFoo }

function TFoo.Foo(): boolean;
begin
  {...}
  result := true;
end;

end.

Código Delphi [-]
unit Foo;

interface

function FooGlobal(): boolean;
// Esta declaraciòn hace que FooGlobal sea vista y usada desde afuera

implementation

function FooGlobal(): boolean;
begin
  result := true;
end;

end.

Código Delphi [-]
unit Foo;

interface
{En interface no se se cuenta con la declaración de FooLocal. Solo puede ser usada localmente de cualquiera de estas formas:
1. Una función/procedimiento global "llama" a FooLocal
2. Aprovechando la sección Initialization y/o Finalization}

implementation

function FooLocal(): boolean;
begin
  result := true;
end;

end.

Código Delphi [-]
unit Foo;

interface

type
  TFoo = class
  // Inicio de la clase
  // Para proceder a dar visibilidad a los mètodos se procede asì:
  { Visibilidad
      1. Variables (si es Private)
      2. Propiedades
      3. Mètodos
  }

  public
  // aqui comienza la visibilidad public. Públic sólo posee un método Foo
    function Foo(): boolean;
  {el compilador solito interpreta donde comienza y termina la declaraciòn de las visibilidades. No hace falta un end, Ojo } 
  end; // aqui termina la clase

implementation

{ TFoo }

function TFoo.Foo(): boolean;
// Como ves... no hay ningún public o private aqui... el compilador solito
// se encarga de interpretar correctamente que tipo de visibilidad posee.
begin
  {...}
  result := true;
end;

end.