I hope that you guys will be able to help me out with a few general approach and design pointers as I work toward porting an application to F#.

I have developed several programs in Python and C# which generate and group exotic multi-race wagers. Examples of such wagers would be what are known as Doubles and Trebles.

Double Wager Example: 11/4 - $0.50

Treble Wager Example: 4/12/1 - $2.00

A wager consists of a *combination* (e.g. 11/4, signifying 11 to win in leg 1 and 4 to win in leg 2) and an amount (e.g. $0.50) to be wagered on that combination. In other words, all doubles consist of an integer pair and an amount, and all trebles consist of an integer 3-tuple and an amount.

Because money is involved, it makes sense to represent amounts as integer cents or use decimal type.

How such wagers are generated is beyond the scope of this question, but suffice it to say that enumerating all possible wager combinations is best done by generating cartesian products of the sets of available runners in each leg. It can actually get more complicated than this. For some particularly exotic exotics, the set of potential combinations might be (say) the cartesian product of the sets of 3-subsets of the available runners in each leg. Having enumerated all possible combinations, one then tests them (somehow) for viability and decides whether or not a wager should be created for each combination.

Sometimes it is necessary to group wager combinations and amounts (a form of compression analogous to the Set Cover Problem) - which can be computationally 'interesting' and requires recourse to various heuristics. Expansion back to constituent single wagers is just cartesian product.

I have been doing my thinking and experimentation in both Python and Scheme here and have learned (after taking up Scheme) that FP/Immutability is a Good Thing (even when it requires threading state up the wazoo) when testing out new heuristics.

I found it fairly easy to develop various wagering programs in Python. It has native tuples and lists (OK, purists would argue that Python lists are not the one true cons cell lists). Python tuples make excellent dictionary keys - something very handy for some of the processing I do on collections of these wager items. Of course it's possible to implement the same functionality in C# (and I have done so), but the amount of boilerplate verbosity required is much greater than in Python and I just find C# and all languages of that ilk painful to think in - at least they are not natural languages for thinking about lists, sets, and tuples! I did successfully implement my Python programs in C#, but I found it very painful and did not enjoy the lack of a REPL.

One reason I am interested in F# is that I wish to transfer as much of the correctness checking to the type system as possible. e.g. it's an error to attempt to make a treble with anything other than 3 runners. When dealing with many different types of exotic, it becomes tedious to code and unit test many constraints which I believe I ought to be able foist on the type system. This is one area where Python falls down. One has to unit test *everything* in order to be able to sleep at night.

So I guess I've finally arrived at the questions I want to ask:

Given that I wish to program as generically as possible such that it is easy for me to later introduce new exotic bet types with just a few new lines of code and without having to go and write many new unit tests:

1) Can I do this succinctly without classes/objects? I am a recovering C++/Java programmer coming to the ML family via Python and Scheme. I now dimly understand that OOP is just one paradigm and that the associated design patterns lore is mostly 'shoehorning' and 'lip sticking the pig'. I have no need of OOP as mental crutch and have enough Scheme under my belt now to be able to conceive of other approaches. But should I or should I not eschew an OOP approach in F# here? Only someone with a deeper understanding can tell me this. I'd really rather not waste too much time forming my own opinion on this as I need to get productive in F# fast.

For example, if I was using PLT Scheme to do this, I would most likely represent exotic wagers with a simple structure and have a module of primitives acting upon these structures and lists of them - the module exporting only those primitives and and composed methods I wished to expose - without recourse to any object system.

Should I take this approach in F# too? I'm not sure what is good style here and particularly wish to avoid being constrained later by bad design choices made now.

2) Does anyone have any particularly brilliant insights about how I can achieve great succinctness, generality, and correctness given the relatively simple data I am operating on? Within my organisation, I'm trying to make a case for much more FP at the computational sharp end. A good deal of what we do seems as if it's ossifying under the weight of class hierarchies (even allowing for the fact that we at least know to favour composition over inheritance most of the time) and everything takes forever to modify, let along experiment with. I really want to take a broom to this. I own shiny new copies of Cousineau, Harrop, Syme et al, so I don't expect to have much trouble in picking up the language per se. But I do want to try to avoid 'writing one to throw away' - right now I really don't have the time for this + am hoping to impress colleagues with 'how easy it is to get it right first time' (hahaha).

My apologies for a rather rambling post and I hope to learn something from your responses!

PS: Don, if you happen across this post, hi from a quondam E-Grouper!