Un linguaggio di programmazione che consente di definire nuovi limiti per tipi semplici

Molte lingue come C++, C#e Javati consentono di creare oggetti che rappresentano tipi semplici come integero float. Utilizzando un'interfaccia di classe è possibile ignorare gli operatori ed eseguire la logica come verificare se un valore supera una regola aziendale di 100.

Mi chiedo se in alcune lingue sia possibile definire queste regole come annotazioni o attributi di una variabile / proprietà.

Ad esempio, C#potresti scrivere:

[Range(0,100)]
public int Price { get; set; }

O forse in C++te potresti scrivere:

int(0,100) x = 0;

Non ho mai visto qualcosa di simile, ma dato quanto siamo diventati dipendenti dalla convalida dei dati prima della memorizzazione. È strano che questa funzione non sia stata aggiunta alle lingue.

Puoi dare un esempio di lingue in cui ciò è possibile?

Pascal aveva tipi di sottorange, cioè diminuendo il numero di numeri che rientrano in una variabile.

  TYPE name = val_min .. val_max;

Ada ha anche una nozione di intervalli: http://en.wikibooks.org/wiki/Ada_Programming/Types/range

Da Wikipedia ....

type Day_type   is range    1 ..   31;
type Month_type is range    1 ..   12;
type Year_type  is range 1800 .. 2100;
type Hours is mod 24;
type Weekday is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday); 

può anche fare

subtype Weekend is  Weekday (Saturday..Sunday);
subtype WorkDay is  Weekday (Monday..Friday);

Ed ecco dove fa freddo

year : Year_type := Year_type`First -- 1800 in this case...... 

C non ha un tipo di sottorange rigoroso, ma ci sono modi per imitarne uno (almeno limitato) usando i campi di bit per minimizzare il numero di bit usati. struct {int a : 10;} my_subrange_var;}. Questo può funzionare come limite superiore per il contenuto variabile (in generale direi: non usare bitfield per questo , questo è solo per provare un punto).

Molte soluzioni per tipi interi di lunghezza arbitraria in altre lingue si presentano piuttosto a livello di libreria, ovvero C ++ consente soluzioni basate su template.

Esistono lingue che consentono il monitoraggio di stati variabili e il collegamento di asserzioni ad esso. Ad esempio in Clojurescript

(defn mytest 
   [new-val] 
   (and (< new-val 10)
        (<= 0 new-val)))

(def A (atom 0 :validator mytest))

La funzione mytestviene chiamata quando aè stata modificata (tramite reset!o swap!) verifica se le condizioni sono soddisfatte. Questo potrebbe essere un esempio per l'implementazione del comportamento subrange in linguaggi in ritardo (vedi http://blog.fogus.me/2011/09/23/clojurescript-watchers-and-validators/ ).

Ada è anche un linguaggio che consente limiti per tipi semplici, infatti in Ada è buona norma definire i propri tipi affinché il programma garantisca la correttezza.

type MyType1   is range    1 .. 100;
type MyType2   is range    5 .. 15;

myVar1 : MyType1;

È stato usato a lungo dal DoD, forse lo è ancora ma ho perso la traccia del suo uso corrente.

Vedere Limitazione dell'intervallo di tipi di valore in C ++ per esempi su come creare un tipo di valore controllato in intervallo in C ++.

Riepilogo esecutivo: utilizzare un modello per creare un tipo di valore con valori minimi e massimi incorporati, che è possibile utilizzare in questo modo:

// create a float named 'percent' that's limited to the range 0..100
RangeCheckedValue<float, 0, 100> percent(50.0);

Non hai nemmeno bisogno di un modello qui; potresti usare una classe con effetti simili. L'uso di un modello consente di specificare il tipo sottostante. Inoltre, è importante notare che il tipo dipercent sopra non sarà a float, ma piuttosto un'istanza del modello. Questo potrebbe non soddisfare l'aspetto "tipi semplici" della tua domanda.

È strano che questa funzione non sia stata aggiunta alle lingue.

I tipi semplici sono proprio questo: semplici. Spesso sono meglio utilizzati come elementi costitutivi per la creazione degli strumenti necessari invece di essere utilizzati direttamente.

Qualche forma limitata della tua intenzione è la mia conoscenza possibile in Java e C # attraverso una combinazione di Annotazioni e Dynamic Proxy Pattern (esistono implementazioni integrate per proxy dinamici in Java e C #).

Versione Java

L'annotazione:

@Target(ElementType.PARAMETER)
@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface IntRange {
     int min ();
     int max ();
}

La classe Wrapper che crea l'istanza Proxy:

public class Wrapper {
    public static Object wrap(Object obj) {
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), new MyInvocationHandler(obj));
    }
}

InvocationHandler che funge da bypass ad ogni chiamata di metodo:

public class MyInvocationHandler implements InvocationHandler {
    private Object impl;

    public MyInvocationHandler(Object obj) {
        this.impl = obj;
    }

@Override
public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable {
    Annotation[][] parAnnotations = method.getParameterAnnotations();
    Annotation[] par = null;
    for (int i = 0; i<parAnnotations.length; i++) {
        par = parAnnotations[i];
        if (par.length > 0) {
            for (Annotation anno : par) {
                if (anno.annotationType() == IntRange.class) {
                    IntRange range = ((IntRange) anno);
                    if ((int)args[i] < range.min() || (int)args[i] > range.max()) {
                        throw new Throwable("int-Parameter "+(i+1)+" in method \""+method.getName()+"\" must be in Range ("+range.min()+","+range.max()+")"); 
                    }
                }
            }
        }
    }
    return method.invoke(impl, args);
}
}

L'interfaccia di esempio per l'uso:

public interface Example {
    public void print(@IntRange(min=0,max=100) int num);
}

Main-Metodo:

Example e = new Example() {
    @Override
    public void print(int num) {
        System.out.println(num);
    }
};
e = (Example)Wrapper.wrap(e);
e.print(-1);
e.print(10);

Produzione:

Exception in thread "main" java.lang.reflect.UndeclaredThrowableException
at com.sun.proxy.$Proxy0.print(Unknown Source)
at application.Main.main(Main.java:13)
Caused by: java.lang.Throwable: int-Parameter 1 in method "print" must be in Range (0,100)
at application.MyInvocationHandler.invoke(MyInvocationHandler.java:27)
... 2 more

C # -Version

L'annotazione (in C # chiamato attributo):

[AttributeUsage(AttributeTargets.Parameter)]
public class IntRange : Attribute
{
    public IntRange(int min, int max)
    {
        Min = min;
        Max = max;
    }

    public virtual int Min { get; private set; }

    public virtual int Max { get; private set; }
}

La sottoclasse DynamicObject:

public class DynamicProxy : DynamicObject
{
    readonly object _target;

    public DynamicProxy(object target)
    {
        _target = target;
    }

    public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
    {
        TypeInfo clazz = (TypeInfo) _target.GetType();
        MethodInfo method = clazz.GetDeclaredMethod(binder.Name);
        ParameterInfo[] paramInfo = method.GetParameters();
        for (int i = 0; i < paramInfo.Count(); i++)
        {
            IEnumerable<Attribute> attributes = paramInfo[i].GetCustomAttributes();
            foreach (Attribute attr in attributes)
            {
                if (attr is IntRange)
                {
                    IntRange range = attr as IntRange;
                    if ((int) args[i] < range.Min || (int) args[i] > range.Max)
                        throw new AccessViolationException("int-Parameter " + (i+1) + " in method \"" + method.Name + "\" must be in Range (" + range.Min + "," + range.Max + ")");
                }
            }
        }

        result = _target.GetType().InvokeMember(binder.Name, BindingFlags.InvokeMethod, null, _target, args);

        return true;
    }
}

EsempioClass:

public class ExampleClass
{
    public void PrintNum([IntRange(0,100)] int num)
    {
        Console.WriteLine(num.ToString());
    }
}

Uso:

    static void Main(string[] args)
    {
        dynamic myObj = new DynamicProxy(new ExampleClass());
        myObj.PrintNum(99);
        myObj.PrintNum(-5);
    }

In conclusione, vedi che puoi ottenere qualcosa del genere per funzionare in Java , ma non è del tutto conveniente, perché

• La classe proxy può essere solo istanziata per le interfacce, ovvero la tua classe deve implementare un'interfaccia
• L'intervallo consentito può essere dichiarato solo a livello di interfaccia
• L'utilizzo successivo arriva solo con uno sforzo supplementare all'inizio (MyInvocationHandler, avvolgimento ad ogni istanza) che riduce anche leggermente la comprensibilità

Le funzionalità della classe DynamicObject in C # rimuovono la restrizione dell'interfaccia, come vedi nell'implementazione di C #. Sfortunatamente, questo comportamento dinamico rimuove in questo caso la sicurezza di tipo statico, quindi sono necessari controlli di runtime per determinare se è consentita una chiamata di metodo sul proxy dinamico.

Se queste restrizioni sono accettabili per te, allora questo può servire come base per ulteriori scavi!

Gli intervalli sono un caso speciale di invarianti. Da Wikipedia:

Un invariante è una condizione su cui si può fare affidamento per essere vera durante l'esecuzione di un programma.

Un intervallo [a, b]può essere dichiarato come una variabile x di tipo Integercon gli invarianti x> = a e x <= b .

Pertanto i tipi di subrange Ada o Pascal non sono strettamente necessari. Potrebbero essere implementati con un tipo intero con invarianti.

È strano che questa funzione non sia stata aggiunta alle lingue.

Funzionalità speciali per tipi con intervallo limitato non sono necessarie in C ++ e in altre lingue con sistemi di tipi potenti.

In C ++, i tuoi obiettivi possono essere raggiunti in modo relativamente semplice con tipi definiti dall'utente . E nelle applicazioni in cui sono desiderabili tipi a portata limitata, sono appena sufficienti . Ad esempio, si vorrebbe anche che il compilatore verifichi che i calcoli delle unità fisiche sono stati scritti correttamente, in modo che velocità / tempo producano un'accelerazione, e prendendo la radice quadrata di accelerazione / tempo produca una velocità. Fare ciò richiede convenientemente la capacità di definire un sistema di tipi, senza nominare esplicitamente ogni tipo che potrebbe mai apparire in una formula. Questo può essere fatto in C ++ .