digitalmars.D - Good examples of value types

=?UTF-8?B?Ikx1w61z?= Marques" (12/12) May 05 2015 Hi,

Justin Whear (7/9) May 05 2015 Dates, times, durations, regular expressions, tokens, lazy generators,

=?UTF-8?B?Ikx1w61z?= Marques" (28/38) May 06 2015 That's a very nice list, thank you, it *was* helpful. Still, I

Justin Whear (18/39) May 06 2015 By tokens I mean the output of a lexer, usually looking like:

deadalnix (15/28) May 05 2015 Let me tell you an actual war story of mine.

Dominikus Dittes Scherkl (2/4) May 06 2015 Maybe you meant reference types here?

deadalnix (3/7) May 06 2015 Yes, sorry for the confusion.

Russel Winder via Digitalmars-d (16/34) May 06 2015 I think you need to date the story, and say with GC was being used.

deadalnix (8/28) May 06 2015 It is relatively recent (a little more than 2 years ago). Any

=?UTF-8?B?Ikx1w61z?= Marques" (3/17) May 06 2015 That's sounds like a great story! What kind of "values" were you

deadalnix (8/10) May 06 2015 Without going into the details, we had entries in a DB, counting

=?UTF-8?B?Ikx1w61z?= Marques" (8/15) May 06 2015 OK, so here the advantages of value vs ref types had to do "only"

deadalnix (8/23) May 06 2015 It is not only with allocation issue, but that is certainly a

amiga (16/47) May 06 2015 People tend to use array of primitives in such cases.

Freddy (5/18) May 06 2015 Immutable types?

"Ola Fosheim =?UTF-8?B?R3LDuHN0YWQi?= (5/8) May 07 2015 Yep, this is very much true, but on x86 the register size is

Dejan Lekic (7/20) May 07 2015 To add to what others have said - whenever you think you will

Andrei Alexandrescu (8/30) May 07 2015 (Not sure I'm not being confused about the topic.) A coworker mentioned

Russel Winder via Digitalmars-d (18/22) May 07 2015 On Thu, 2015-05-07 at 07:36 -0700, Andrei Alexandrescu via Digitalmars-d

Andrei Alexandrescu (4/14) May 07 2015 Yah, my coworker had data (this is Facebook after all) and it was pretty...

Nikolay (10/10) May 07 2015 java.lang.String

=?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:

Hi,

For a comparison with the Java language, I'm trying to come up 
with some good examples of custom types that should be value 
types (but that must be ref types in Java). I think the most 
obvious ones are numeric types. So BigNum, MyNum, etc. are good 
examples because programmers are used to numeric types being 
value types, and having them suddenly become a ref type just 
because it's MyNum instead of long is really annoying. Still, 
could you come up with some type that would really benefit from 
being a value type but that isn't numeric (or otherwise similar)?

Thanks for your help!

Luís

May 05 2015

Justin Whear <justin economicmodeling.com> writes:

On Tue, 05 May 2015 20:40:58 +0000, Luís Marques wrote:

 could you come up with some type that would really benefit from being a
 value type but that isn't numeric (or otherwise similar)?

Dates, times, durations, regular expressions, tokens, lazy generators, 
digests, vectors, really any type that provides a interpretation/behavior 
wrapper around one or more trivially copyable types.

Frankly, the real divide in my mind is polymorphic/non-polymorphic, not 
by-reference vs by-value, though I will occasionally use `final class` if 
I want a convenience reference type around a resource.

May 05 2015

=?UTF-8?B?Ikx1w61z?= Marques" <luis luismarques.eu> writes:

On Tuesday, 5 May 2015 at 21:04:22 UTC, Justin Whear wrote:
 Dates, times, durations, regular expressions, tokens, lazy 
 generators,
 digests, vectors, really any type that provides a 
 interpretation/behavior
 wrapper around one or more trivially copyable types.

That's a very nice list, thank you, it *was* helpful. Still, I 
have some issues with it, maybe we can improve it.

* Dates, times, durations, vectors -> still somewhat numeric. I 
can add two weeks to a date, 3 seconds to a duration, etc. (for 
types which are not at all numeric it would probably make no 
difference what value are assigned which bit patterns, while for 
more numeric types the bit patterns must have some regularity to 
be able to efficiently implement operations like addition, etc.)

* Regular expressions -> I have no idea what you have in mind for 
this one; even after looking at std.regex...

* Tokens -> On the one hand, I think this could be an excellent 
example, since it's a case where the bit pattern is arbitrary 
(because it generally has no numeric properties). On the other 
hand, I could see people arguing that just using an int is 
perfectly fine, so it doesn't benefit from a custom type. Do 
notice that, even in D, an enum converts without a cast to an 
int, so the fact that an enum might be used to list the possible 
abstract values (the tokens) doesn't quite make it a completely 
independent type, IMHO.

* lazy generators -> explain, please?

* digests -> do you mean the digest output, or the digest 
function state?

 Frankly, the real divide in my mind is 
 polymorphic/non-polymorphic, not
 by-reference vs by-value, though I will occasionally use `final 
 class` if
 I want a convenience reference type around a resource.

Aren't you arguing against yourself? In those cases you wanted 
your type to have reference semantics, even though it wasn't a 
polymorphic type. Doesn't that counterexample prove that 
polymorphic/non-polymorphic is just an heuristic, while the 
value/ref distinction is more fundamental?

May 06 2015

Justin Whear <justin economicmodeling.com> writes:

On Wed, 06 May 2015 16:54:46 +0000, Luís Marques wrote:

 * Regular expressions -> I have no idea what you have in mind for this
 one; even after looking at std.regex...

I meant both patterns and matches/captures.

 * Tokens -> On the one hand, I think this could be an excellent example,
 since it's a case where the bit pattern is arbitrary (because it
 generally has no numeric properties). On the other hand, I could see
 people arguing that just using an int is perfectly fine, so it doesn't
 benefit from a custom type. Do notice that, even in D, an enum converts
 without a cast to an int, so the fact that an enum might be used to list
 the possible abstract values (the tokens) doesn't quite make it a
 completely independent type, IMHO.

By tokens I mean the output of a lexer, usually looking like:

struct Token
{
	Type type;
	uint line, uint col;
	string captured;
}

 * lazy generators -> explain, please?

Phobos is full of these.  A simple example is the result of 
std.range.iota.  The motivation is that a generator is actually an 
algorithm which happens to be wrapped up as a value.

 * digests -> do you mean the digest output, or the digest function
 state?

Certainly the output, haven't given much thought to the intermediate 
state.

 Frankly, the real divide in my mind is polymorphic/non-polymorphic, not
 by-reference vs by-value, though I will occasionally use `final class`
 if I want a convenience reference type around a resource.

 
 Aren't you arguing against yourself? In those cases you wanted your type
 to have reference semantics, even though it wasn't a polymorphic type.
 Doesn't that counterexample prove that polymorphic/non-polymorphic is
 just an heuristic, while the value/ref distinction is more fundamental?

Ideally they're orthogonal, though you need reference types to do true 
dynamic polymorphism.  Using `final class` is a pragmatic move given that 
D conflates reference types with polymorphic types, i.e. if there were a 
`ref struct` I'd use it.

May 06 2015