Oh, maybe I created a limitation in my own head...

Would this work then (for example):

module Modifier = struct

let recovery = Key.create "recovery"

let resist_pain = Key.create "resist_pain"

let resist_magic = Key.create "resist_magic"

(* a whole lot of these... *)

end

These would then be monomorphic? Anyway, the important thing is

they didn't require knowledge of any types to create all the keys, so

now having all other modules referencing Modifier wouldn't be bad at all.

Then something like the following will reify the type of the

Modifier.recovery key?

let mods = set mods Modifier.recovery (fun (a,b) -> a+6,b) in ...

I kept thinking that if I had a "grand central" of universal embeddors

they'd need to be aware of the types they're embedding... thereby

creating the type-dependencies I was worried about!

This solution, if I'm understanding it right, is perfectly fine!

Thank-you for cluing me in, Yaron!

On Wed, Apr 3, 2013 at 7:29 PM, Yaron Minsky <yminsky@janestreet.com> wrote:

Have you looked at Univ_map in Core? It has the same problem you're
complaining about, in that the keys do need to be tied to the type of
the data stored under that key. You then of course need to stash the
key somewhere. But I'm not sure what problem that creates. In
particular, I don't know why this creates a bottleneck of type
dependencies. Each Univ_map.Key.t is created independently, and can
be created at any point in the code.

y

On Wed, Apr 3, 2013 at 8:45 PM, Anthony Tavener
<anthony.tavener@gmail.com> wrote:
> 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.

--
Caml-list mailing list. Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs