cast(immutable) vs extra variable

[Ali Çehreli]

On 09/19/2013 03:07 PM, Daniel Davidson wrote:

 > Here is a setup: Data is coming in - say over the wire or from a
 > database. It is very rich data with nestings of primitives, lists and
 > string keyed associative arrays, recursively - think nested json. Once
 > a data object is read in it is passed off to classes that use the data
 > in read-only fashion.

And there are two types of read-only data:

const: A promise to not mutate

immutable: A requirement that nobody mutates either.

 > So, for example, assume the root of the rich data is a Portfolio
 > instance. All members of Portfolio recursively are public since it is
 > really plain old data from one perspective and this makes using vibe
 > json serialization simple. Assume that a user of Portfolio data is an
 > Analyzer. This analyzer will need to do lots of complex operations
 > with the portfolio that it uses in readonly fashion.

Yes, that sounds like immutable(Portfolio), as the Analyzer would not be 
happy if the data could mutate.

 > It may have many
 > mutable members for intermediate calculations.
 >
 > Here is a mockup http://pastebin.com/nBLFDgv6 which is making use of
 > immutable(Portfolio) to ensure that (a) the analyzer does not modify
 > the data and (b) no other code can modify the data. To achieve this
 > there needs to be a point in time where the modifiable Portfolio is
 > done being read and made immutable. At this point it is cast to
 > immutable and henceforth only accessed that way.

I have added a couple of comments to you program:

import std.stdio;

struct Portfolio {
     double[string] data;
     // ...
}

struct HedgeRecommendation {
     string recommendation;
     this(int) {
         recommendation = "Sell, the market is rigged";
     }
}

struct Analyzer {
     // [Ali] Since you are worried about cost of copying, why not make 
this a
     //       pointer as well?
     immutable(Portfolio)* portfolio;
     this(ref immutable(Portfolio) portfolio) {
         // [Ali] Otherwise, this assignment would copy as well.
         this.portfolio = &portfolio;
     }

     HedgeRecommendation createHedge() {
         auto result = HedgeRecommendation(1);
         //...
         return result;
     }
}

// [Ali] If possible, make this function pure so that its return value can
//       automatically be casted to immutable.
Portfolio readPortfolio(string id) pure {
     // read portfolio from database
     return Portfolio([ "IBM" : 100.0, "SPY" : 300.0 ]);
}

HedgeRecommendation getHedgeRecommendation(string portfolioId) {
     // [Ali] No explicit cast needed because of that 'pure'.
     immutable(Portfolio) portfolio = readPortfolio(portfolioId);
     auto analyzer = Analyzer(portfolio);
     return analyzer.createHedge();
}

void main() {
     writeln(getHedgeRecommendation("1234"));
}

 > Given this setup - what do you see as the trade-offs?
 >
 > What can not be done or will be challenging in face of refactor?
 >
 > What are some better alternatives/recommendations?
 >
 > I am a fan of D but my struggles with const/immutable transitivity
 > feel endless and are wearing on me. I feel like having an ability to
 > say something will not change and not using that ability is like being
 > teased.

You are not alone. I tried to answer some of these questions in my DConf 
2013 talk. I think I have only scratched the surface:

   http://dconf.org/talks/cehreli.html

Ali