Uma linguagem de programação que permite definir novos limites para tipos simples

Muitas línguas gosto C++, C#e Javapermitem que você crie objetos que representam tipos simples, como integerou float. Usando uma interface de classe, você pode substituir os operadores e executar lógica como verificar se um valor excede uma regra de negócios de 100.

Gostaria de saber se em alguns idiomas é possível definir essas regras como anotações ou atributos de uma variável / propriedade.

Por exemplo, C#você pode escrever:

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

Ou talvez C++você possa escrever:

int(0,100) x = 0;

Eu nunca vi algo assim ser feito, mas, considerando o quão dependentes nos tornamos da validação de dados antes do armazenamento. É estranho que esse recurso não tenha sido adicionado aos idiomas.

Você pode dar exemplos de idiomas onde isso é possível?

Pascal tinha tipos de subintervalos, ou seja, diminuindo o número de números que se encaixam em uma variável.

  TYPE name = val_min .. val_max;

Ada também tem uma noção de intervalos: 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); 

também pode fazer

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

E aqui é onde fica legal

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

C não possui um tipo estrito de subintervalo, mas existem maneiras de imitar um (pelo menos limitado) usando campos de bits para minimizar o número de bits usados. struct {int a : 10;} my_subrange_var;}. Isso pode funcionar como um limite superior para o conteúdo variável (em geral, eu diria: não use campos de bits para isso , isso é apenas para provar um ponto).

Muitas soluções para tipos inteiros de comprimento arbitrário em outras linguagens acontecem no nível da biblioteca, ou seja, o C ++ permite soluções baseadas em modelo.

Existem idiomas que permitem monitorar estados variáveis ​​e conectar asserções a ele. Por exemplo, em Clojurescript

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

(def A (atom 0 :validator mytest))

A função mytesté chamada quando amudou (via reset!ou swap!) verifica se as condições são atendidas. Este poderia ser um exemplo para implementar o comportamento de subintervalos em idiomas de ligação tardia (consulte http://blog.fogus.me/2011/09/23/clojurescript-watchers-and-validators/ ).

O Ada também é uma linguagem que permite limites para tipos simples; de fato, no Ada, é uma boa prática definir seus próprios tipos para o seu programa para garantir a correção.

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

myVar1 : MyType1;

Foi usado por um longo tempo pelo Departamento de Defesa, talvez ainda seja, mas eu perdi a noção do seu uso atual.

Consulte Limitando o intervalo de tipos de valor em C ++ para obter exemplos de como criar um tipo de valor verificado no intervalo em C ++.

Resumo executivo: Use um modelo para criar um tipo de valor com valores mínimo e máximo integrados, que você pode usar assim:

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

Você nem precisa de um modelo aqui; você pode usar uma classe para um efeito semelhante. O uso de um modelo permite especificar o tipo subjacente. Além disso, é importante observar que o tipo depercent acima não será um float, mas uma instância do modelo. Isso pode não satisfazer o aspecto "tipos simples" da sua pergunta.

É estranho que esse recurso não tenha sido adicionado aos idiomas.

Tipos simples são exatamente isso - simples. Eles geralmente são mais usados ​​como os blocos de construção para criar as ferramentas necessárias em vez de serem usadas diretamente.

De acordo com o meu conhecimento, alguma forma restrita de sua intenção é possível em Java e C # através de uma combinação de anotações e padrão de proxy dinâmico (existem implementações internas para proxies dinâmicos em Java e C #).

Versão Java

A anotação:

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

A classe Wrapper que cria a instância do Proxy:

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

O InvocationHandler servindo como desvio a cada chamada de 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);
}
}

A interface de exemplo para 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);

Resultado:

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

Versão C #

A anotação (em C # chamada 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; }
}

A subclasse 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;
    }
}

A ExampleClass:

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

Em conclusão, você vê que pode conseguir que algo assim funcione em Java , mas não é totalmente conveniente, porque

• A classe de proxy pode ser instanciada apenas para interfaces, ou seja, sua classe precisa implementar uma interface
• O intervalo permitido só pode ser declarado no nível da interface
• O uso posterior vem com um esforço extra no início (MyInvocationHandler, encapsulando a cada instanciação), o que também reduz um pouco a capacidade de compreensão

Os recursos da classe DynamicObject em C # removem a restrição de interface, como você vê na implementação de C #. Infelizmente, esse comportamento dinâmico remove a segurança do tipo estático nesse caso, portanto, são necessárias verificações de tempo de execução para determinar se uma chamada de método no proxy dinâmico é permitida.

Se essas restrições são aceitáveis ​​para você, isso pode servir de base para novas escavações!

As faixas são um caso especial de invariantes. Da Wikipedia:

Uma invariante é uma condição na qual se pode confiar durante a execução de um programa.

Um intervalo [a, b]pode ser declarado como uma variável x do tipo Integercom os invariantes x> = a e x <= b .

Portanto, os tipos de subintervalo Ada ou Pascal não são estritamente necessários. Eles podem ser implementados com um tipo inteiro com invariantes.

É estranho que esse recurso não tenha sido adicionado aos idiomas.

Recursos especiais para tipos de alcance limitado não são necessários no C ++ e em outros idiomas com sistemas de tipos avançados.

No C ++, seus objetivos podem ser alcançados de maneira relativamente simples com tipos definidos pelo usuário . E em aplicações em que tipos de alcance limitado são desejáveis, dificilmente são suficientes . Por exemplo, também se deseja que o compilador verifique se os cálculos das unidades físicas foram escritos corretamente, para que a velocidade / tempo produza uma aceleração e a raiz quadrada da aceleração / tempo produza uma velocidade. Fazer isso convenientemente requer a capacidade de definir um sistema de tipos, sem nomear explicitamente todos os tipos que possam aparecer em uma fórmula. Isso pode ser feito em C ++ .