Is there a programming language...
-
Phil Martin wrote:
Units are lost at runtime
Which is unfortunate because I'd possibly like to be able to reflect on the unit of measure. But it's an interesting avenue to explore. Thanks! Marc
Yeah, it is unfortunate. In the engineering applications I write, I've created a ScalaryQuantity and a VectorQuantity class. They are just the usual numeric structures which support all the normal arithmetic, but supports keeping track of units, and converting units when necessary. There's a big run time overhead involved, but for me it is worth it because it has helped me catch many errors far earlier in the process of developing new calculations.
-
A long time ago, at a defense contractor far, far defunct... The Ada programming language provided a semblance of semantic typing. You could create an 'Age' type that was a subtype of integer. I'm sure the computer scientists would scoff at Ada's limitations, but it does somewhat fit the bill. I don't know the modern language definition (I used it back in the 80's), so it might be more capable now.
Software Zen:
delete this;Gary Wheeler wrote:
The Ada programming language provided a semblance of semantic typing.
Ah, it does indeed. I've been reading the Ada type stuff - very slick. It's a pity these constructs aren't in other languages. I wonder why not - it seems like it would really help bullet proof code. Then again, like anything else, I bet it can be horribly abused as well. Marc
-
...that works "easily" with semantic types? For example, I may have:
int age = 51;which completely loses the concept that 51 is an age (in years). What I want is something like:AgeInYears myAge = 51;and yet still be able to specify that I can perform, say, arithmetic operations on "myAge". For example, in C#, I could write:class AgeInYears
{
public int Value {get;set;}
}... implement operators on AgeInYears
But that gets messy real fast - every "semantic type" needs these operators, etc. Furthermore, the unit of measurement is still not handled very elegantly. So, as the question states, are there programming languages out there that are more expressive of semantic types? Marc
"which completely loses the concept that 51 is an age (in years)." so write int ageInYears = 51; There are many ways to do it in c# (pass the int value in constructor, make an implicit cast operator, ...), but imho the best way is sticking with plain int, as that what "age in years" exactly is.
-
My mind doesn't work. So I would use Python. :zzz:
-
varhas its place. Too many programmers let it escape that place, unfortunately.Software Zen:
delete this; -
I hate myself for typing this:
namespace TestApp1
{
using AgeInYears = System.Int32;class Program { static void Main(string\[\] args) { AgeInYears myAge = 10; AgeInYears oldAge = 50; AgeInYears timeUntilOldAge = oldAge - myAge; } }}
Yes, that's perfectly legal C# code. Its technically an int, works the same way that #define does in c++ to replace types. It only works in single code files though.
It fails totally though for type safety.
using AgeInYears = System.Int32;
using AgeInDays = System.Int32;...
AgeInYears yearAge = 10;
AgeInDays dayAge = 3650;var myAge = yearAge + dayAge; // OOPS!
(A better example may involve standard units of measure: inches, miles, meters, temperatures, etc.) The system should at least prevent naive attempts to assign to incorrect types. Ideally, the system should be able to perform conversions where possible. Smalltalk and C++ both offer enough flexibility. In C#, a struct could be declared, but I think you'd struggle to make it semantically sound.
"If you don't fail at least 90 percent of the time, you're not aiming high enough." Alan Kay.
-
Gary Wheeler wrote:
The Ada programming language provided a semblance of semantic typing.
Ah, it does indeed. I've been reading the Ada type stuff - very slick. It's a pity these constructs aren't in other languages. I wonder why not - it seems like it would really help bullet proof code. Then again, like anything else, I bet it can be horribly abused as well. Marc
Stroustrup has written somewhere on implementing SI measures in C++ using user-defined literals and simple classes. That would work well, but should really be part of the standard library.
"If you don't fail at least 90 percent of the time, you're not aiming high enough." Alan Kay.
-
...that works "easily" with semantic types? For example, I may have:
int age = 51;which completely loses the concept that 51 is an age (in years). What I want is something like:AgeInYears myAge = 51;and yet still be able to specify that I can perform, say, arithmetic operations on "myAge". For example, in C#, I could write:class AgeInYears
{
public int Value {get;set;}
}... implement operators on AgeInYears
But that gets messy real fast - every "semantic type" needs these operators, etc. Furthermore, the unit of measurement is still not handled very elegantly. So, as the question states, are there programming languages out there that are more expressive of semantic types? Marc
CHILL (CCITT HIgh Level Language - CCITT was the old name of ITU-T) probably has the best developed strict type system of any industrial language. One of the features was the distinction between a SYNMODE and NEWMODE definitions (MODE is the CHILL term for type/class): A SYNMODE defines restrictions (like value subranges) or aggregates (like arrays) of existing types, but (within the restrictions) fully compatible with the base mode. A NEWMODE is similar, but defines an incompatible mode. So if you make new integer modes AppleCount and OrangeCount using SYNMODE, you can add apples and oranges. If you define dem using NEWMODE, the compiler won't allow you to add apples and oranges without an explicit cast. CHILL was developed to be the ITU standard for programming telephone switches, but the language design is just as general as, say, c or java. It never made any success in non-telephone environments (and even there it never took more than about half of the market), which is a pity: CHILL is one of the most thoroughly well-designed languages there is. But then again: The marketplace isn't known for always selecting the best designs... (I won't give c as an exapmple of that, that could hurt some people's feelings).
-
...that works "easily" with semantic types? For example, I may have:
int age = 51;which completely loses the concept that 51 is an age (in years). What I want is something like:AgeInYears myAge = 51;and yet still be able to specify that I can perform, say, arithmetic operations on "myAge". For example, in C#, I could write:class AgeInYears
{
public int Value {get;set;}
}... implement operators on AgeInYears
But that gets messy real fast - every "semantic type" needs these operators, etc. Furthermore, the unit of measurement is still not handled very elegantly. So, as the question states, are there programming languages out there that are more expressive of semantic types? Marc
Marc has already pointed to Smalltalk, someone else pointed out C++, I'd like to add Haskell to the mix. Getting type safety would be easy:
newtype meter m = meter m deriving (Show, Num, Eq, Ord)
newtype foot f = foot f deriving (Show, Num, Eq, Ord)-- Usage (ghci> is an iteractive prompt)
ghci> let m1 = meter 5
ghci> let m2 = meter 10
ghci> let m3 = m1 + m2
ghci> m3
meter 15
ghci> let f1 = foot 3
ghci> let f2 = foot 4
ghci> let f3 = f1 + f2
ghci> f3
foot 7
ghci> let e1 = f1 + m1 -- Won't Work - produces error of types mismatchingWith more work, it can be extended to add support for conversions, magnitudes (nm, mm, m, km, ...). Indeed someone has already done all this work for us: Dimensional[^] and Dimensional using type families[^]. All available at the standard repository Hackage[^].
"If you don't fail at least 90 percent of the time, you're not aiming high enough." Alan Kay.
-
Gary Wheeler wrote:
The Ada programming language provided a semblance of semantic typing.
Ah, it does indeed. I've been reading the Ada type stuff - very slick. It's a pity these constructs aren't in other languages. I wonder why not - it seems like it would really help bullet proof code. Then again, like anything else, I bet it can be horribly abused as well. Marc
The central goal behind Ada was to make it difficult to make common programming mistakes, and to have the compiler enforce as many conditions for correctness as possible. The language design succeeded in a lot of respects, but it made it difficult to write code in the language. It was very frustrating learning how to appease the compiler. In my case, we were beta testers for one of the first VAX/VMS Ada compilers. It was difficult to tell the difference between genuine flaws in our source and possible compiler bugs.
Software Zen:
delete this; -
:laugh:
Software Zen:
delete this; -
...that works "easily" with semantic types? For example, I may have:
int age = 51;which completely loses the concept that 51 is an age (in years). What I want is something like:AgeInYears myAge = 51;and yet still be able to specify that I can perform, say, arithmetic operations on "myAge". For example, in C#, I could write:class AgeInYears
{
public int Value {get;set;}
}... implement operators on AgeInYears
But that gets messy real fast - every "semantic type" needs these operators, etc. Furthermore, the unit of measurement is still not handled very elegantly. So, as the question states, are there programming languages out there that are more expressive of semantic types? Marc
In Python you can inherit from int (something like):
class AgeInYears(int):
unit = "years"
def __new__(cls, age:int):
cls.age = age
return int.__new__(cls,age)def \_\_str\_\_(self): return "{} {}".format(self.age, self.unit) def \_\_add\_\_(self, value:int): self.age += value return selfclass User():
def __init__(self, age:int):
self.age = AgeInYears(age)def \_\_str\_\_(self): return "User: age: {}".format(self.age)And then use it like:
user = User(29)
print(user) #User: age: 29 years
print(user.age) #29 years
print(type(user.age)) #user.age += 2 #use it like an int, and just increase it.
print(user.age) #31 years
print(type(user.age)) #Of course, you still have to override some default methods of int (new, add). This should cover the semantics nicely: you have an int, with unit, you can do basic int operations. Ed
-
In Python you can inherit from int (something like):
class AgeInYears(int):
unit = "years"
def __new__(cls, age:int):
cls.age = age
return int.__new__(cls,age)def \_\_str\_\_(self): return "{} {}".format(self.age, self.unit) def \_\_add\_\_(self, value:int): self.age += value return selfclass User():
def __init__(self, age:int):
self.age = AgeInYears(age)def \_\_str\_\_(self): return "User: age: {}".format(self.age)And then use it like:
user = User(29)
print(user) #User: age: 29 years
print(user.age) #29 years
print(type(user.age)) #user.age += 2 #use it like an int, and just increase it.
print(user.age) #31 years
print(type(user.age)) #Of course, you still have to override some default methods of int (new, add). This should cover the semantics nicely: you have an int, with unit, you can do basic int operations. Ed
Well, that is very snazzy - I'll take a closer look at Python now. Thank you for taking the time to put together that example. Marc
-
Marc has already pointed to Smalltalk, someone else pointed out C++, I'd like to add Haskell to the mix. Getting type safety would be easy:
newtype meter m = meter m deriving (Show, Num, Eq, Ord)
newtype foot f = foot f deriving (Show, Num, Eq, Ord)-- Usage (ghci> is an iteractive prompt)
ghci> let m1 = meter 5
ghci> let m2 = meter 10
ghci> let m3 = m1 + m2
ghci> m3
meter 15
ghci> let f1 = foot 3
ghci> let f2 = foot 4
ghci> let f3 = f1 + f2
ghci> f3
foot 7
ghci> let e1 = f1 + m1 -- Won't Work - produces error of types mismatchingWith more work, it can be extended to add support for conversions, magnitudes (nm, mm, m, km, ...). Indeed someone has already done all this work for us: Dimensional[^] and Dimensional using type families[^]. All available at the standard repository Hackage[^].
"If you don't fail at least 90 percent of the time, you're not aiming high enough." Alan Kay.
Fascinating - I was just reading the Python example below and then looked at your Haskell example. Thanks! Also, I appreciate the links. Marc
-
CHILL (CCITT HIgh Level Language - CCITT was the old name of ITU-T) probably has the best developed strict type system of any industrial language. One of the features was the distinction between a SYNMODE and NEWMODE definitions (MODE is the CHILL term for type/class): A SYNMODE defines restrictions (like value subranges) or aggregates (like arrays) of existing types, but (within the restrictions) fully compatible with the base mode. A NEWMODE is similar, but defines an incompatible mode. So if you make new integer modes AppleCount and OrangeCount using SYNMODE, you can add apples and oranges. If you define dem using NEWMODE, the compiler won't allow you to add apples and oranges without an explicit cast. CHILL was developed to be the ITU standard for programming telephone switches, but the language design is just as general as, say, c or java. It never made any success in non-telephone environments (and even there it never took more than about half of the market), which is a pity: CHILL is one of the most thoroughly well-designed languages there is. But then again: The marketplace isn't known for always selecting the best designs... (I won't give c as an exapmple of that, that could hurt some people's feelings).
Member 7989122 wrote:
CHILL (CCITT HIgh Level Language - CCITT was the old name of ITU-T)
Interesting! Your description of restrictions, aggregates, base modes, and incompatibility reminds me of what I was reading about Ada. Marc
-
Well This c++ 11 trick is very powerfull, really! I prefer to do all the hard work from scratch (ok, have R #). I believe that this threshold "semantic" is outside the domain of a programming language (commonly, it is a "system domain" concept), because it is difficult to predict the particularities of a user-defined (conversion, comparison, integrity, serialization, etc.).
greydmar wrote:
I believe that this threshold "semantic" is outside the domain of a programming language (commonly, it is a "system domain" concept),
Yes, that's what makes it interesting to look at. :) Marc
-
...that works "easily" with semantic types? For example, I may have:
int age = 51;which completely loses the concept that 51 is an age (in years). What I want is something like:AgeInYears myAge = 51;and yet still be able to specify that I can perform, say, arithmetic operations on "myAge". For example, in C#, I could write:class AgeInYears
{
public int Value {get;set;}
}... implement operators on AgeInYears
But that gets messy real fast - every "semantic type" needs these operators, etc. Furthermore, the unit of measurement is still not handled very elegantly. So, as the question states, are there programming languages out there that are more expressive of semantic types? Marc
-
I'm sorry but this has to be amongst the most pointless discursions this forum has ever seen!
Quote:
int age = 51;
A perfect encapsulation of an immutable truth ... age is just a number! What more could you possibly need?
Member 9082365 wrote:
A perfect encapsulation of an immutable truth ... age is just a number! What more could you possibly need?
OK, what's 34 (besides "just a number") ? Marc
-
Member 9082365 wrote:
A perfect encapsulation of an immutable truth ... age is just a number! What more could you possibly need?
OK, what's 34 (besides "just a number") ? Marc
Unless you're a thoroughgoing Pythagorean that question is no more meaningful than 'how is 34?' or 'why is 34?' It is just a number and as we all know (post pi) number doesn't exist in any real sense at all. As written it is an arbitrary typographical representation of a concept within an equally arbitrary logical system that bears no relation other than by extrapolation with what is, was or will be. It is an abstraction. A useful abstraction but an abstraction nonetheless. And doubly so once you bring time into it! Contrary to popular opinion even if we were born simultaneously our real ages are almost certainly different! That's relativity for you!
-
I hate myself for typing this:
namespace TestApp1
{
using AgeInYears = System.Int32;class Program { static void Main(string\[\] args) { AgeInYears myAge = 10; AgeInYears oldAge = 50; AgeInYears timeUntilOldAge = oldAge - myAge; } }}
Yes, that's perfectly legal C# code. Its technically an int, works the same way that #define does in c++ to replace types. It only works in single code files though.
You should rewrite it that way.
namespace TestApp1
{
using AgeInYears = System.Int32;class Program { static void Main(string\[\] args) { AgeInYears myAge = 10; // or whatever AgeInYears timeUntilOldAge = 10; AgeInYears oldAge = myAge + timeUntilOldAge; }}
}So you are forever young. :)
The good thing about pessimism is, that you are always either right or pleasently surprised.