Ada-ähnliche Typen in Nimrod

Question

heute habe ich in D-Mailing-Liste gefragt, ob es möglich ist, benutzerdefinierte Datentypen auf ähnliche Weise wie z. Beispiel aus Adas wiki Seite:

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


type Date is 
    record 
    Day : Day_type; 
    Month : Month_type; 
    Year : Year_type; 
    end record; 

subtype Working_Hours is Hours range 0 .. 12; 
subtype Working_Day is Weekday range Monday .. Friday; 
Work_Load: constant array(Working_Day) of Working_Hours 
    := (Friday => 6, Monday => 4, others => 10); 

und die reply demonstriert so etwas wie:

import std.typecons; 
import std.exception; 

struct Limited(T, T lower, T upper) 
{ 
    T _t; 
    mixin Proxy!_t; //Limited acts as T (almost) 
    invariant() 
    { 
     enforce(_t >= lower && _t <= upper); 
    } 
    this(T t) 
    { 
     _t = t; 
    } 
} 

auto limited(T, T lower, T upper)(T init = T.init) 
{ 
    return Limited!(T, lower, upper)(init); 
} 

unittest 
{ 
    enum l = [-4,9]; 
    auto a = limited!(int, l[0], l[1])(); 
    foreach(i; l[0] .. l[1]+1) 
    { 
     a = i; 
    } 

    assertThrown({a = -5;}()); 
    assertThrown({a = 10;}()); 
} 

, die es möglich ist zeigt, aber wahrscheinlich verfehlt Adas Eleganz.

Nun, nachdem ich vor kurzem über Nimrod gelesen habe, frage ich mich, wie es ähnliche Aufgabe mit der Bereitstellung, die gleiche Ada-Typ-Sicherheit zu gewährleisten, umgehen kann?

Answer 1

Nimrod unterstützen diese vielmehr direkt:

type 
    Day = range[1..31] 
    Month = range[1..12] 

    WeekDay = enum 
    Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday 

    WorkingDays = range[Monday..Friday] 
    WorkingHours = range[0..12] 

    WorkSchedule = array[WorkingDays, WorkingHours] 

Fehler erzwungen werden entweder zur Compile-Zeit:

var x: Day 
x = 40 # conversion from int literal(40) to Day is invalid 

.. oder zur Laufzeit

var x: Day 
var y = unknownInt() # let's say it returns 100 

x = y # unhandled exception: value 100 out of range [EOutOfRange] 

Außerdem distinct types Kann verwendet werden, wenn eine noch stärkere Typsicherheit erforderlich ist.

Answer 2

Ferner wird Instanziierung ein Argument einfacher mit

import std.traits; 

/*! Instantiator for \c Limited. */ 
template limited(alias min, alias max, bool Exceptional = true) 
    if (!is(CommonType!(typeof(min), typeof(max)) == void)) { 
    auto limited(CommonType!(typeof(min), typeof(max)) value) { 
     return Limited!(typeof(value), min, max)(value); 
    } 
} 

Siehe Instantiator Function for Bound template doesn't compile