I think I might be up against a brick wall. But maybe there's a door I don't
see, without Obj.magicing myself through the wall. (I haven't had to use
magic
for anything yet!) :)

I want to stash values under a key, and retrieve them by that key. All
values
bound to a given key are of the same type, but the type will differ between
keys. Basically like a hashtable you'd find in a dynamic language.

  (* modifier-additions like this would be scattered across the code-base *)
  contribute `RecoveryRoll (fun (a,b) -> a+3,b)
  contribute `RecoveryRoll (fun (a,b) -> a,b-1)
  contribute `ResistPain (fun a -> a+1)
  contribute `MagicResistance (fun a -> match a with None -> None | Some x
-> Some(x+3))
  contribute `MagicResistance (fun a -> match a with None -> Some 7 | Some
x -> Some(x+7))

  (* example of applying modifiers... *)
  let modified = fold `RecoveryRoll (4,1) in
  ...

(There are details I've left out here, like the need for 'contribute'
returning an id
by which to remove a modifier, as well as control over
order-of-application.)

Now I think the type signature of these functions would be:

  val contribute: a'. 'a key -> ('a -> 'a) -> unit
  val fold: 'a. 'a key -> 'a -> 'a

And the thorn in my side would be that the key must be "keyed" to the type,
or
is there an escape? At one point I tried a universal type to "hide" the
signature of the function-list, but I also stashed the inj/proj under the
key
-- well, of course the inj/proj functions had different types per entry in a
hashtable, so that worked as well as not having a universal type involved.
:)

If I provide the inj/proj functions at each invocation then I need to
pre-create these and house them somewhere (which could create a bottleneck
of
type-dependencies) -- Imagine several hundred modifiers like `RecoveryRoll;
some might use types that only need visibility in one module. Trying to
place
each modifier in suitable modules also seems a mess... a lot of them
conceptually exist "in the spaces between modules".

So I keep trying to create an airy light-weight "implied" association to
connect modifiers to use-sites... but to satisfy typing it seems I need to
be
explicit at some point.

Does anyone have any ideas? I'm often surprised at the gymnastics OCaml's
type-system can accomplish under the guidance of some smart folks. If
anyone's
made a heterogenous dictionary/hashtable that doesn't need types explicity
declared, that would probably be what I'm looking for.


Note that I've had this problem surface several times and managed to find
solutions that suited the specific problem, but each problem can have it's
subtle details. In this case, the large number of keys and functions,
combined with their spread across codebase and the sparse nature of their
use (a game-entity might have a few dozen modifiers out of hundreds)...
really
seems to push for association-by-name-only. At least that's all my brain
gravitates toward.

-Tony