Un lenguaje de programación que le permite definir nuevos límites para tipos simples

Muchos idiomas C++, como , C#y le Javapermiten crear objetos que representan tipos simples como integero float. Usando una interfaz de clase, puede anular operadores y realizar lógica como verificar si un valor excede una regla comercial de 100.

Me pregunto si es posible en algunos idiomas definir estas reglas como anotaciones o atributos de una variable / propiedad.

Por ejemplo, en C#usted podría escribir:

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

O tal vez en C++ti podrías escribir:

int(0,100) x = 0;

Nunca he visto algo así, pero dado lo dependientes que nos hemos vuelto de la validación de datos antes del almacenamiento. Es extraño que esta característica no se haya agregado a los idiomas.

¿Puedes dar ejemplos de idiomas donde esto sea posible?

Pascal tenía tipos de subrango, es decir, disminuía el número de números que encajaban en una variable.

  TYPE name = val_min .. val_max;

Ada también tiene una noción de rangos: http://en.wikibooks.org/wiki/Ada_Programming/Types/range

De 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); 

también puede hacer

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

Y aquí es donde se pone genial

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

C no tiene un tipo de subrango estricto, pero hay formas de imitar uno (al menos limitado) mediante el uso de campos de bits para minimizar el número de bits utilizados. struct {int a : 10;} my_subrange_var;}. Esto puede funcionar como un límite superior para contenido variable (en general, diría: no use bitfields para esto , esto es solo para probar un punto).

Muchas soluciones para tipos enteros de longitud arbitraria en otros lenguajes suceden a nivel de biblioteca, es decir, C ++ permite soluciones basadas en plantillas.

Hay lenguajes que permiten monitorear estados variables y conectar aserciones. Por ejemplo en Clojurescript

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

(def A (atom 0 :validator mytest))

La función mytestse llama cuando aha cambiado (vía reset!o swap!) verifica si se cumplen las condiciones. Este podría ser un ejemplo para implementar el comportamiento de subrango en lenguajes de enlace tardío (consulte http://blog.fogus.me/2011/09/23/clojurescript-watchers-and-validators/ ).

Ada también es un lenguaje que permite límites para tipos simples, de hecho, en Ada es una buena práctica definir sus propios tipos para su programa para garantizar la corrección.

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

myVar1 : MyType1;

El Departamento de Defensa lo usó durante mucho tiempo, tal vez todavía lo sea, pero he perdido la noción de su uso actual.

Ver Limitar el rango de tipos de valor en C ++ para ver ejemplos de cómo crear un tipo de valor de rango verificado en C ++.

Resumen Ejecutivo: use una plantilla para crear un tipo de valor que tenga valores mínimos y máximos integrados, que puede usar de esta manera:

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

Realmente ni siquiera necesitas una plantilla aquí; podrías usar una clase con un efecto similar. El uso de una plantilla le permite especificar el tipo subyacente. Además, es importante tener en cuenta que el tipo de percentarriba no será unfloat , sino una instancia de la plantilla. Es posible que esto no satisfaga el aspecto de "tipos simples" de su pregunta.

Es extraño que esta característica no se haya agregado a los idiomas.

Los tipos simples son solo eso, simples. A menudo se usan mejor como bloques de construcción para crear las herramientas que necesita en lugar de usarse directamente.

Según mi conocimiento, alguna forma restringida de su intención es posible en Java y C # a través de una combinación de Anotaciones y Patrón de proxy dinámico (existen implementaciones incorporadas para proxys dinámicos en Java y C #).

Versión Java

La anotación:

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

La clase Wrapper que crea la instancia de Proxy:

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

El InvocationHandler sirve como bypass en cada llamada a método:

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);
}
}

La interfaz de ejemplo para el uso:

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

Método principal:

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);

Salida:

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

Versión C #

La anotación (en C # llamado atributo):

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

La clase de ejemplo:

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);
    }

En conclusión, ve que puede hacer que algo así funcione en Java , pero no es del todo conveniente, porque

• La clase de proxy solo puede ser instanciada para interfaces, es decir, su clase tiene que implementar una interfaz
• El rango permitido solo se puede declarar en el nivel de interfaz
• El uso posterior viene solo con un esfuerzo adicional al principio (MyInvocationHandler, envolviendo en cada instanciación) que también reduce ligeramente la comprensibilidad

Las capacidades de la clase DynamicObject en C # eliminan la restricción de la interfaz, como puede ver en la implementación de C #. Desafortunadamente, este comportamiento dinámico elimina la seguridad de tipo estático en este caso, por lo que las verificaciones de tiempo de ejecución son necesarias para determinar si se permite una llamada al método en el proxy dinámico.

Si esas restricciones son aceptables para usted, ¡esto puede servir como base para una mayor excavación!

Los rangos son un caso especial de invariantes. De Wikipedia:

Una invariante es una condición en la que se puede confiar que sea verdadera durante la ejecución de un programa.

Un rango [a, b]puede declararse como una variable x de tipo Integercon las invariantes x> = a y x <= b .

Por lo tanto, los tipos de subrango Ada o Pascal no son estrictamente necesarios. Podrían implementarse con un tipo entero con invariantes.

Es extraño que esta característica no se haya agregado a los idiomas.

No se necesitan características especiales para tipos de rango limitado en C ++ y otros lenguajes con sistemas de tipos potentes.

En C ++, sus objetivos se pueden cumplir de manera relativamente simple con tipos definidos por el usuario . Y en aplicaciones donde los tipos de rango limitado son deseables, apenas son suficientes . Por ejemplo, uno también querría que el compilador verifique que los cálculos de la unidad física se escribieron correctamente, de modo que la velocidad / tiempo produzca una aceleración, y tomar la raíz cuadrada de aceleración / tiempo produzca una velocidad. Hacer esto convenientemente requiere la capacidad de definir un sistema de tipos, sin nombrar explícitamente cada tipo que pueda aparecer en una fórmula. Esto se puede hacer en C ++ .