Interesting or unique types in programming languages? [closed]

Question

We have all seen integer, floating point, string, and the occasional decimal type. What are some of the most strange or unique or useful types you have encountered, useful or not?

Answer 1

I'll be short:

Maybe a

in Haskell.

With this simple construct, the language solves the issue of crashes or NullPointerException, it neatly sidesteps the "One Million Mistake" of Tony Hoare :)

Frankly, an optional presence checked at compile-time ? It's dreamlike...

Answer 2

Felix has anonymous sum types. The type is written like:

typedef il = int + long;

as it would be in theory. The values are ugly:

case 0 of il (1)
case 1 of il (2L)

except perhaps for a unit sum such as 3 = 1 + 1 + 1

case 0 of 3
case 1 of 3 

which unfortunately uses zero origin counting for "C compatibility". Anonymous sums are necessary for structurally typed algebraic types, for example:

(1 + T * li) as li

is a (singly linked) list of T. All other languages I know of required nominally typed sums, where both the type itself and the constructors must be given names.

The shorthand 3 used above is cute, the following is in the library:

typedef void = 0;
typedef unit = 1;
typedef bool = 2;

and this notation:

 T ^ 3

is an array of static length 3 .. the 3 is not an integer but a sum of 3 units. What a pity + is not associative :)

Answer 3

Googles Go has a "Channel" type which is quite unique.

Answer 4

If you want a language with a unique type then head for BCPL. This language only has one data type, the word, being a fixed number of bits for the language implementation.

Answer 5

Clojure is interesting because it has a meta-concept of "abstractions" that pervade the language. Examples:

• Collections
• Sequences (lazy and non-lazy)
• Higher Order Functions
• Multimethods
• Protocols
• Managed references
• Macros
• various others.....

To some extent, the abstractions take the "single responsibility principle" to the extreme. It's up to you to compose them to get the functionality that you want, but you can be extremely flexible about how you glue them together.

For example, if you want a class-based OOP system with inheritance, you could build one out of these core abstractions relatively quickly.

In practice, the abstractions themselves are designed in a way that multiple implementations are possible, e.g. through specific interfaces like clojure.lang.ISeq for sequences or clojure.lang.IFn for higher order functions.

There's an interesting video about this topic: The Art of Abstraction

Answer 6

VHDL has physical types. A literal of such type includes both a value and a unit. You can define subunits as well. For instance, a predefined physical type is time:

type time is range <machine dependant> to <machine dependant> 
units
  fs;
  ps = 1000 fs;
  ns = 1000 ps;
  us = 1000 ns;
  Ms = 1000 us;
  sec = 1000 ms;
  min = 60 sec;
  hr = 60 min;
end units;

Together with operator overloading, you can define very interesting things.

Answer 7

Delphi has sets (see also), which I don't believe are implemented the same way in other languages.

This makes storing multi-variable attributes in databases a breeze :D

Answer 8

Ruby's symbol type is a bit unusual. It's essentially a string implementing the singleton pattern. Or something. So far, I've found the best uses for symbols are in tracking states and passing function names.

Answer 9

Lisp has two interesting types: t and nil. What's interesting about them is that everything is a t and nothing is a nil.

Answer 10

I am perennially fond of void *. It's probably a symptom of something deeply flawed in me.

Answer 11

I suppose it's really only strange coming from programming on a classical architecture, but certainly one of the hardest types for me to wrap my head around at first was the quantum register, which shows up in QCL.

Answer 12

I'm surprised nobody has mentioned Monads or Algebraic Datatypes yet.

Answer 13

A handful of languages in the functional family have a class of types known as Unity. The distinguishing feature of Unity types are that they contain no information, they are zero bit types. A unity type (in some variations) is also its only value, or (in most others) has only one value (that is not itself a type).

These are useful, though, because they are distinguished types. Since you can't implicitly convert from one unity type to another, you can put static type checking to work in a very efficient, and expressive way.

Unity is also the way most such languages describe Enums, by allowing a new type to be any of a defined set of other types, or to describe maybe types, values that may be either a value of a typical type (say, an integer), or have a value that represents no-value.

Some languages that don't employ the richness of user defined unity types still have unity in them, in some form or another. For instance, Python has at least three unity types, NoneType, NotImplementedType, and EllipsisType. It's interesting that the first two both mean something like "No value", but the third is used in complex values (specifically, slice expressions) to represent interesting special cases.

Other interesting examples of unity include NULL in sql and undefined in javascript, but not void in C or C++. void fails. Even though it describes a value of no information, but no actual value can be of type void.

Answer 14

Clipper had 'Code Blocks', which were similar to anonymous methods. They could be passed around and evaluated as needed, usually as a form of a callback. You'd often use them for things like performing calculations on the fly when presenting tables of data.

Answer 15

Regular Expressions:

They are extremely powerful yet compact objects.
Languages that have them built in have great ability to manipulate text (lets not hear the word parse they are not that good).

Answer 16

COBOL. Essentially only two basic data types, strings and numbers, but you have to specify exactly how they're laid out in memory, e.g. PIC S9(5)V99 COMP-3.

Answer 17

Fortran has common blocks; it's one of the least common data types in modern languages, or, rather an unusual way to efficiently share data.

Fortran 95 has interval types and built-in interval arithmetics.

The list would not be complete without monadic types found in Haskell. To understand them you need a bit of effort.

Answer 18

I'm still trying to wrap my head around what a multi-parameter function becomes in F# and other functional languages. Basically int f(Foo, Bar) becomes func f(Foo)

That is the two parameter function that takes a Foo, and a Bar and returns an int is really a one parameter function that takes a Foo and returns a one parameter function that takes a bar and returns an int. But somehow you can call it with two parameters if you want. I wrote a post about it here

Answer 19

I found union's in C++ to be 'quirky' when I first heard about them. I still haven't hit a scenario where they're the obvious choice to implement.

Answer 20

Lua has a built-in table that is most impressive. It has a built-in hashtable and a vector, and with the use of metatables can be the fundamental base for object-oriented programming in a procedural language.

Each index of a table can receive any of the basic language structures (number, boolean, string, function -yes, functions are types on lua -, and tables).

Answer 21

q/kdb+ has tables built-in. Since it's a programming language and column-oriented database in one, there's no need for LINQ or ORMs.

For example, can create a table like this (assignment is distinquished by : rather than = as in most languages):

people:([]name:`Joe`Amy`Sarah; age:17 15 18; GPA:3.5 3.8 3.33)

Now I can look at my table:

q)show people
name  age GPA 
--------------
Joe   17  3.5 
Amy   15  3.8 
Sarah 18  3.33

And I can query it:

q)select from people where GPA>3.4
name age GPA
------------
Joe  17  3.5
Amy  15  3.8

Answer 22

I had a soft spot in my heart for Euphoria's data types when I was younger

It is structured as thus:

Object
-> Atom
-> Sequence

• Atom = A single numeric value

• Sequence = A sequence of Objects

  -- examples of atoms:
  
  0
  98.6
  -1e6
  
  -- examples of sequences:
  
  {2, 3, 5, 7, 11, 13, 17, 19}
  {1, 2, {3, 3, 3}, 4, {5, {6}}}
  {{"jon", "smith"}, 52389, 97.25}
  {}                        -- the 0-element sequence
  

  See: The Ref Manual

Note: "jon" is actually a short hand way of writing the sequence of ASCII values. For example "ABCDEFG" is the same as {65, 66, 67, 68, 69, 70, 71}

Answer 23

SNOBOL: pattern (essentially a LL(1) parser tree, if I remember it correctly).

Answer 24

PL/SQL lets you declare variables of type my_table.some_column%type... I find that pretty damn useful.

And C# lets you declare objects as nullable or not, though I'm not sure that counts as a type.