Multiple dispatch (was Re: Parameter Modes, In In Out and Out

[mark_lundquist@my-deja.com]

The trail has kind of gone cold on this, but oh well..
(Why do you think they call it "Deja"? :-)

In article <93v898$k80$1@nnrp1.deja.com>,
  dmitry6243@my-deja.com wrote:

> In article <93q6cd$r3k$1@nnrp1.deja.com>,
>   Robert Dewar <robert_dewar@my-deja.com> wrote:
> >
> > Now if your emphasis is on *complete* here, i.e. with all the
> > details of semantic interactions worked out, then that
> > statement makes sense, but we don't need to go there to
> > discuss whether MD is useful. Just sketch out what MD would
> > mean to you in an Ada environment, and produce an example,
> > showing what you would like to be able to write.

[Dmitri's example:]
> --
> -- The base type uses some set of distribution functions
> -- of the confidence factor. The set is closed for +,-,*,/.
> -- The implementation could be potentially very slow.
> --
> package FuzzyNumbers is
>    type FuzzyNumber is tagged private;
>    function "+" (Left, Right : FuzzyNumber)
>       return FuzzyNumber;
>    ...
> end FuzzyNumbers;
> --
> -- A derived type that uses some specialized subset of
> -- the distribution functions. It is closed for only
> -- +,- but extremely fast. We derive it because we want to
> -- mix operands of both types and make some class-wide
> -- programming too.
> --
> package FuzzyNumbers.Special is
>    type SpecialFuzzyNumber is new FuzzyNumber with
>       null record;
>    function "+" (Left, Right : SpecialFuzzyNumber)
>       return SpecialFuzzyNumber;
>    ...
> end FuzzyNumbers.Special;
> --
> -- So far it is Ada 95. Let we make a fuzzy neuro network
> -- to fake our innoncent customers (:-)). We implement
> -- nodes of the network. Each node has a procedure
> -- calculating the output:
> --
> with FuzzyNumbers; use FuzzyNumbers;
> package Network is
>    type Node is tagged private;
>    type Link is access Node;
>    function Compute
>             (  X      : Node;
>                Input1 : FuzzyNumber'Class;
>                Input2 : FuzzyNumber'Class
>             )  return FuzzyNumber'Class;
>    ...
> end Network;
> --
> -- Summator is an instance of a node:
> --
> package Network.Summators is
>    type Summator is new Node with null record;
>    function Compute
>             (  X      : Summator;
>                Input1 : FuzzyNumber'Class;
>                Input2 : FuzzyNumber'Class
>             )  return FuzzyNumber'Class;
>    ...
> end Network.Summators;
> --
> -- Now a naive implementation of the summator
> -- node:
> --
> package body Network.Summators is
>    function Compute
>             (  X      : Summator;
>                Input1 : FuzzyNumber'Class;
>                Input2 : FuzzyNumber'Class
>             )  return FuzzyNumber'Class is
>    begin
>       return Input1 + Input2; -- Opps!
>    end Compute;
> end Network.Summators;
> --
> -- This implementation will time to time entertain us with
> -- Constraint_Error. The problem is that the developer
> -- expected here a triple dispatch to + involving the result,
> -- the left and the right operands.

If they expected triple dispatch, then they don't know Ada :-)

Maybe they really expected covariance, in which case they should have
used a generic instead.

Another possibility is that the inputs to Compute should be of type
FuzzyNumber, not FuzzyNumber'Class.  Users of Compute would upcast as
necessary.  (However, they somehow have to have some reason to believe
that upcasting yields a meaningful result, which is hard to know
without seeing into the implementations of the abstractions.  This is a
general difficulty with programming by extension).

> The specification
> -- of FuzzyNumbers.Special leaves most of the combinations
> -- FuzzyNumber, SpecialFuzzyNumbers undefined (Ada 95 does
> -- not have MD). An MD aware compiler could say for
> -- the specification of FuzzyNumber.Special:
>
> "Error! All signatures have to be overriden", I.e. not only
>
> function "+" (Left, Right : SpecialFuzzyNumber)
>    return SpecialFuzzyNumber;
>
> but also:
>
> function "+" (Left : FuzzyNumber; Right : SpecialFuzzyNumber)
>    return FuzzyNumber;
> function "+" (Left : SpecialFuzzyNumber; Right: FuzzyNumber)
>    return FuzzyNumber;
> function "+" (Left, Right : FuzzyNumber)
>    return FuzzySpecialNumber;
> function "+" (Left : FuzzyNumber; Right : SpecialFuzzyNumber)
>    return SpecialFuzzyNumber;
> function "+" (Left : SpecialFuzzyNumber; Right: FuzzyNumber)
>    return SpecialFuzzyNumber;
> function "+" (Left, Right : SpecialFuzzyNumber)
>    return FuzzyNumber;
>
> This would fill all the slots of the 3D dispatch table. Some
> syntax should be provided to inherit a combination from the
> ancestors.

I'm not a computer scientist, and I haven't ever studied multiple
dispatch, so maybe this is a naive question... but don't you now have a
problem with cross-coupled sibling dependencies?  Suppose I create
another type Wild_And_Wooly_Number, derived also from FuzzyNumber?  How
do you fill in your table then?

Mark Lundquist


Sent via Deja.com
http://www.deja.com/