Define a primitive data type: Difference between revisions

 

=={{header|Ada}}==

The compiler identifies the range of valid values from the range specification ''1..10'' and automatically builds in bounds checking where it is needed. The compiler is smart enough to omit bounds checking when it is not needed.

The compiler will omit bounds checking for the assignment of A to B above because both values are of My_Type. A cannot hold a value outside the range of 1..10, therefore the assignment cannot produce an out of bounds result.

 

 

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

INT max bounded = ( LENG max int * max int > long max int | ENTIER sqrt(max int) | max int );

OD;

except bounds error:

Output:

<pre>

===Other libraries or implementation specific extensions===

As of February 2009 no open source libraries to do this task have been located.

 

=={{header|C sharp|C#}}==

{

 

 

{

}

 

{

}

 

{

}

 

=={{header|C++}}==

This class relies on implicit conversions to do most int operations; however the combined operations with assignment have to be coded explicitly.

 

 

class tiny_int

private:

unsigned char value; // we don't need more space

 

=={{header|Clojure}}==

Use proxy on java.lang.Number so it can be used in Clojure's math operations.

 

(if (<= 1 value 10)

(proxy [Number] []

(doubleValue [] value)

(longValue [] value))

 

{{out}}

The built-in integer type specifier provides range parameters. <code>deftype</code> may be used to define an alias for it.

 

 

For a bounds check, one may use <code>typep</code> (a predicate) or <code>check-type</code> (signals an error if not of the type).

 

(check-type i one-to-ten)

(case i

(8 "eight")

(9 "nine")

 

(Note that the above can be written without the separate check-type by using <code>ecase</code> instead of <code>case</code>, which signals an error when no case matches.)

To inform the compiler that a variable will be of a certain type, permitting optimizations, use a declaration:

 

(declare (type one-to-ten i))

 

Note, however, that the standard does not specify what happens in the event that a declaration is false (though [[SBCL]], for example, does perform type checks on any declaration except when <code>safety</code> is 0); use <code>check-type</code> for portable bounds checks.

=={{header|D}}==

 

 

/++

assert(i < 5);

assert(j > i);

 

=={{header|Delphi}}==

The code below defines a new type <code>TinyInt</code>, provides bounds checking and implementation of all standard arithmetic operators:

 

 

 

Sample usage (interactive session):

 

dy>x += 4

 

dy>x * 2

 

=={{header|E}}==

 

for i :MyNumber in [0, 5, 10, 15, 20, 25] {

println(i)

(Note: The region guard, while provided with E, is entirely unprivileged code, and could be argued not to be "primitive".)

 

=={{header|EchoLisp}}==

Types are native objects (Boolean, ..) , or defined by predicates and/or combinations of other types. They are used to check data values or to define functions signatures. The '''types.lib''' library must be loaded.

(require 'types)

(require 'math)

(f10 42 666)

❗ error: One-ten : type-check failure : 42 → 'f10:x'

 

=={{header|Elena}}==

sealed struct TinyInt : BaseNumber

{

InvalidArgumentException.raise()

InvalidArgumentException.raise()

}

public program()

{

i + j

 

=={{header|Euphoria}}==

In Euphoria types are special functions that may be used in declaring the allowed values for a variable. A type must have exactly one parameter and should return an atom that is either true (non-zero) or false (zero). Types can also be called just like other functions. The types '''object''', '''sequence''', '''atom''' and '''integer''' are predefined.

return i >= 1 and i <= 10

 

=={{header|Factor}}==

We can accomplish this using a predicate class. A predicate class must be a subclass of an existing class and allows the programmer to write a predicate which determines membership.

This automatically creates the <code>my-int?</code> predicate word which determines whether an object is a <code>my-int</code>.

10 my-int? ! t

We can now write methods that specialize on <code>my-int</code>. We will define an increment word, <code>++</code>, which increments <code>integer</code>s by <tt>1</tt> but divides <code>my-int</code>s by <tt>2</tt>.

M: integer ++ 1 + ;

M: my-int ++ 2/ ;

 

10 ++ ! 5

 

=={{header|Forth}}==

=== Method 1: Safe Integer Store operators===

Forth is a fetch and store based virtual machine. If we create a safe version of store (!) the programmer simply uses this operator rather than the standard store operator.

: CLIP ( n lo hi -- n') ROT MIN MAX ;

: BETWEEN ( n lo hi -- flag) 1+ WITHIN ;

: SAFE! ( n addr -- )

OVER 1 10 BETWEEN 0= ABORT" out of range!"

Testing

7 X SAFE! X ? 7 ok

12 X CLIP! X ? 10 ok

$7FAA2B0C throw

$7FAD4698 c(abort")

=== Method 2: redefine standard "store" operator as DEFER word ===

Using the code in Method 1, we can re-define the store (!) operator to be switchable.

: FAST! ( n addr -- ) ! ; ( alias the standard version)

 

: LIMITS-ON ( -- ) ['] SAFE! IS ! ;

: LIMITS-OFF ( -- ) ['] FAST! IS ! ;

 

Testing

 

LIMITS-OFF ok

$7FAA2B0C throw

$7FAD4460 c(abort")

=== Method 3: Create a safe VALUE assignment operator===

A VALUE defines a numerical data type that returns it's value rather than an address (pointer) like a variable.

We can create a word that assigns a number to a VALUE but tests for out of range errors.

OVER 1 10 BETWEEN 0= ABORT" out of range!"

>BODY ! ;

IF POSTPONE ['] POSTPONE (->) \ compiling action

ELSE ' (->) \ interpret action

 

Test

99 TO Z ok ( normal assignment)

Z . 99 ok

$7FAA2B0C throw

$7FAD4570 c(abort")

 

=={{header|Fortran}}==

The module gives an example of how a ''bounded integer'' could be implemented in Fortran (not all the needed interfaces are implemented, and only the one for the + operator are shown). Bounds are checked at run-time.

 

implicit none

 

end function bounded_add_bbb

 

 

use Bounded

implicit none

c = c + b ! warning (c=10)

 

 

=={{header|FreeBASIC}}==

 

Type MyInteger

Print

Print "Press any key to quit"

 

{{out}}

</pre>

 

 

 

 

=={{header|Go}}==

 

2. Go doesn't support operator overloading and so methods need to be defined for the standard operations on integers. As in the case of the Kotlin entry, only the basic arithmetic operations and the increment and decrement operations have been catered for below.

 

import "fmt"

fmt.Println("t1 + 1 =", t1.Inc())

fmt.Println("t1 - 1 =", t1.Dec())

 

{{out}}

Haskell doesn't have any built-in subrange types. However, it is possible to declare arbitrary types that "behave like" any of the built-in types on the "usual" numeric etc. operations, because these operations are defined by type-classes. So we generalize the task a bit, and first declare a generic container type that supports an additional ''check'' operation. Then, we lift any operation in the base type to the container type, by executing the check after each operation:

 

 

data Check a b = Check { unCheck :: b } deriving (Eq, Ord)

quotRem = lift2p quotRem

divMod = lift2p divMod

Now we can declare the a subrange 1..10 of integer like this:

 

 

instance Checked TinyInt Int where

check x | x >= 0 && x <= 10 = Check x

In the same way, we could now declare the subtype of the even integers:

 

instance Checked EvenInt Int where

check x | even x = Check x

 

Similarly, we could declare the subtype of floating point numbers with restricted exponent, and so on.

 

=={{header|Java}}==

This example class throws an exception if the value is out of the bounds; it is implemented only in the assignment method "assign" and the addition method "add". The class can be easily extended.

 

{

public BoundedIntOutOfBoundsException(int v, int l, int u) {

}

}

 

=={{header|JavaScript}}==

 

n = Math.floor(n);

if(isNaN(n))

var y = new Num(0); //TypeError

var z = new Num(11); //TypeError

 

=={{header|jq}}==

In the following, we define a new type named "smallint", with arithmetic operations that either return the "smallint" one would expect from ordinary arithmetic, or else return nothing (an empty stream), as opposed to returning null or raising an error. The choice of an empty stream is made to highlight this alternative.

if type == "object" and has("type") then "\(.type)::\(.value)"

else .

 

This definition ensures that jq's basic tests for equality and inequality (== and !=) can be used for the instances of smallint.

As of this writing, the official release of jq does not support modules, so we will not use jq's new module system here, but it would allow us to place all the smallint functions in a Smallint module.

 

| if (i|type) == "number" and i == (i|floor) and i > 0 and i < 11 then {"type": "smallint", "value": i}

else empty

split("::") | smallint( .[1] | tonumber )

else empty

def minus(a;b): smallint(a.value - b.value);

def times(a;b): smallint(a.value * b.value);

def mod(a;b): smallint(a.value % b.value);

add( s(1); s(2)) | pp # "smallint::3"

 

=={{header|Julia}}==

Julia has true, machine-optimized user defined primitives, but they are defined as contiguous groups of N bits:

 

val::Int8

function LittleInt(n::Real)

@show a * LittleInt(2)

@show b ÷ LittleInt(2)

 

{{out}}

 

Rather than attempt to reproduce all functions or operators which the Int type supports, only the basic arithmetic operators and the increment and decrement operators are catered for below:

 

class TinyInt(i: Int) {

println("t1 + 1 = ${++t1}")

println("t2 - 1 = ${--t2}")

 

{{out}}

 

=={{header|Lasso}}==

data private value

dint(10) + 1 // Error: 11 greater than 10

dint(10) * 2 // Error: 20 greater than 10

 

=={{header|M2000 Interpreter}}==

We can use Currency, Decimal, Double, Single, Long, Integer for primitive data types. When we see type using Type$() we get "Group" (the user object type) but using TypeExp$() (defined in this example) we get group value's type, as Currency here.

 

Module CheckDataType {

Module CheckThis {

}

CheckDataType

 

=={{header|MATLAB}}==

In a folder named "@RingInt"

RingInt.m:

properties

end %classdef

 

Sample Usage:

 

ans =

ans =

 

 

=={{header|Modula-3}}==

In Modula-3, subrange types are automatically subtypes of their base type, so if you define a type called <code>MyInt</code> to be the subrange [1..10] then <code>MyInt</code> is a subtype of <code>INTEGER</code>. If we defined <code>MyChar</code> as the subrange ['A'..'C'] then <code>MyChar</code> would be a subtype of <code>CHAR</code>.

<code>MyInt</code> can now be used anywhere an <code>INTEGER</code> can, such as the standard arithmetic functions. Trying to assign a value outside of the range of <code>MyInt</code> will result in a compile time warning, and/or a runtime error.

 

=={{header|Nim}}==

Subranges are supported by the language and automatically boundchecked:

 

var x: MyInt = 5

 

 

 

=={{header|OCaml}}==

 

type 'a bounds = { min: 'a; max: 'a }

(mk_bounded res a.bounds)

;;

 

Using in the interactive top level:

val range : int bounds = {min = 1; max = 10}

 

 

# op ( + ) a b ;;

 

which can be used with floats in the same way:

val rf : float bounds = {min = 1.; max = 10.}

 

and b = mk_bounded 5.6 rf in

op ( +. ) a b ;;

 

=={{header|ooRexx}}==

* 21.06.2014 Walter Pachl

* implements a data type tinyint that can have an integer value 1..10

if wordpos(methName, "+ - * / % //")>0 then -- an arithmetic message in hand?

forward message (methName) to (v) array (methArgs[1])

'''output'''

<pre>a=1

In this case we are lucky. As a feature of constraint programming we can easily constrain the domain of integers.

 

I

in

I::1#10

 

Output:

 

=={{header|Pascal}}==

As per ISO 7185, any (attempted) assignment out of range constitutes an error.

However, the processor (usually a compiler) is permitted to leave such an error undetected.

=={{header|Perl}}==

{{works with|Perl|5}}

use Carp qw(croak);

use Tie::Scalar qw();

$t = 11; # dies, too big

$t = 'xyzzy';

 

=={{header|Phix}}==

{{trans|Euphoria}}

In Phix types are special functions that may be used in declaring the allowed values for a variable. A type must have exactly one parameter and should return true (non-zero) or false (zero). Types can also be called just like other functions. The types '''object''', '''sequence''', '''string''', '''atom''' and '''integer''' are predefined.

You can then declare variables of the new type just as you would the builtins

and typechecking occurs automatically

 

=={{header|PicoLisp}}==

{{trans|Java}}

# value lower upper

 

(set> B 9)

(when (catch 'boundedIntOutOfBounds (+> A (val> B)) NIL)

Output:

<pre>: (main)

 

=={{header|PowerShell}}==

[Int][ValidateRange(1,10)]$n = 3 # $n can only accept integers between 1 and 10

 

=={{header|Python}}==

This doesn't really apply as Python names don't have a type, but something can be done:

def __init__(self, b):

if 1 <= b <= 10:

>>> type(x)

<class '__main__.num'>

 

 

Most Racket programmers will use contracts to enforce additional guarantees on values. In the following example, the program exports <tt>x</tt> with a contract that ensures it is a number between 1 and 10.

 

#lang racket

 

 

(define x 5)

 

In Typed Racket, it is possible to define a type that only contains the integers from 1 to 10. However, this type is inconvenient to use and is unlikely to be used in practice.

 

#lang typed/racket

 

(: y 1UpTo10)

(define y 18)

 

=={{header|Retro}}==

variable update

---reveal---

: to dup 1 10 within [ update on ] [ drop "Out of bounds\n" puts ] if ;

: limited: create 1 , &.limited reclass ;

 

This creates a data element that returns a value from 1 to 10. Alteration of the value is possible using '''to'''.

 

1 to foo

foo .s

51 to foo

foo .s

 

=={{header|Ruby}}==

and define a method_missing method.

 

include Test::Unit::Assertions

 

 

assert_raise(ArgumentError) { c = a + b } # => invalid value '12', must be an integer

 

=={{header|Rust}}==

A simple example of implementing the newtype pattern manually would look like this:

 

 

mod test_mod {

let bar: i8 = foo.into();

println!("{} == {}", foo, bar);

 

However, there exist crates such as [https://lib.rs/crates/derive_more derive_more] to automate the parts other than the restricted construction logic based on a simple <code>#[derive(Add, Copy, Clone, Debug, Div, Into, Mul, Sub)]</code> and so on and so forth.

 

=={{header|Scala}}==

import TinyInt._

require(int >= lower && int <= upper, "TinyInt out of bounds.")

}

 

 

=={{header|Sidef}}==

 

class MyInt(value < MyIntLimit) {

 

a *= 2 # a=6

 

=={{header|Tcl}}==

Tcl does not attach types to values or variables, but it does allow the programmer to create traces on variables that can be used to enforce type-like constraints among other things. Traces are procedures that execute when variables are read, written and/or unset. (Traces are also available for commands and for the execution of a script.) Tcl's compiler does not enforce these constraints; they're strictly runtime entities.

variable value_cache

array set value_cache {}

error [format $errMsg $varname $value]

}

 

So, in an interactive tclsh we can see:

 

=={{header|Toka}}==

{

variable update

value:1-10: foo

1 to foo

 

=={{header|UNIX Shell}}==

* compound variables and

* "discipline functions" which get fired at get/set/unset events

function boundedint.set {

nameref var=${.sh.name}

boundedint=-5; echo $boundedint

boundedint=5; echo $boundedint

{{output}}

<pre>value out of bounds

5

value out of bounds

 

=={{header|Ursala}}==

corresponding operations on natural numbers with no further bounds

checking required.

 

my_number ::

 

add = my_number$[the_number: sum+ ~the_number~~]

test program:

 

output:

<pre>

</pre>

test program demonstrating bounds checking:

 

compile-time diagnostic output:

<pre>

</pre>

Note that restricted types are not idiomatic in Ursala if all we really want is integer arithmetic with run-time bounds checking, which can be done more directly like this.

 

#library+

#import

^|A(~&,//+ nrange(1,10)?</~& <'out of bounds'>!%)*

This code creates a new library of functions of natural numbers by selecting several of them by name from the standard <code>nat</code> library and putting a wrapper around each one that checks the bounds on the result and throws an exception if necessary. These functions can be used as drop-in replacements for the standard ones.

 

 

TinyInt.cls:

 

Public Property Let Value(ByVal vData As Integer)

'vb defaults to 0 for numbers; let's change that...

mvarValue = 1

 

Usage (in this case, from a form):

 

Private Sub Form_Click()

Randomize Timer

Set x = New TinyInt '"Set = New" REQUIRED

 

=={{header|Visual Basic .NET}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Visual FoxPro}}==

Visual FoxPro can't define primitives but they can be emulated with custom classes.

o = NEWOBJECT("BoundedInt")

DO WHILE NOT o.lHasError

ENDIF

THIS.lHasError = .T.

{{omit from|AWK}}

{{omit from|Axe}}

{{omit from|TI-89 BASIC|Does not have user-defined data structures.}}

{{omit from|Vim Script}}