And more generally, using the ``generalizations`` vocabulary:
M: quotation |+|
dup infer in>> length [ nbi |+| ] 3curry ;
On Fri, Dec 5, 2014 at 7:22 AM, John Benediktsson <mrj...@gmail.com> wrote:
> You could use the stack-checker to infer the effect of the quotation and
> then dispatch like this:
>
> ```
> M: quotation |+|
> dup infer in>> length {
> { 1 [ [ bi |+| ] 2curry ] }
> { 2 [ [ 2bi |+| ] 2curry ] }
> { 3 [ [ 3bi |+| ] 2curry ] }
> } case ;
> ```
>
> But you might start running into places where the compiler is trying to
> dispatch on the run-time value of a quotation, and you would need to add a
> ``call( x y -- z )`` with static stack effects to tell it what to expect.
>
> We have multiple dispatch implemented in the ``multi-methods`` vocabulary,
> so you could do something like this:
>
> http://re-factor.blogspot.com/2013/10/rock-paper-scissors.html
>
>
>
> On Fri, Dec 5, 2014 at 2:10 AM, Andrea Ferretti <ferrettiand...@gmail.com>
> wrote:
>
>> Hi, I am trying to implement monoids in factor. A monoid is a set with
>> a binary associative operation (and, depending on the defintiion, a
>> neutral element for it).
>>
>> Typical examples are numbers (with either addition or multiplication)
>> or sequences (with concatenation). Other examples can be derived from
>> these, since hastables whose values are in a monoid are also naturally
>> a monoid.
>>
>> My implementation is here
>>
>>
>> https://github.com/andreaferretti/factor-work/blob/master/monoid/monoid.factor
>>
>> Using |+| as the word for the operation, one has for instance
>>
>> 3 5 |+|
>> ! gives 8
>>
>> "hello " "world" |+|
>> ! gives "hello world"
>>
>> H{ { 1 2 } { 3 4 } } H{ { 1 5 } { 5 6 } } |+|
>> ! gives H{ { 1 7 } { 3 4 } { 5 6 } }
>>
>>
>> The issue I have is with quotations. Functions with values in a monoid
>> are also naturally a monoid - in order to sum two functions, apply
>> both and sum the values.
>>
>> So I have the definition
>>
>> M: quotation |+| [ bi |+| ] 2curry ;
>>
>> The problem is that this only works for functions of one argument. For
>> functions of 2 arguments one would have to use
>>
>> M: quotation |+| [ 2bi |+| ] 2curry ;
>>
>> and so on.
>>
>> Unfortunately, there is only a class quotation, which does not seem to
>> distinguish the arity.
>>
>> For comparison, in scala functions have different types based on the
>> arity (such a Function2[A1, A2, B]), and this allows to correctly
>> define |+| - in fact it is a common method in scalaz.
>>
>> Is there anything I can do to make this work regardless of function
>> arity? Also, what about dispatching on both arguments, so that the
>> method only makes sense for a pair of numbers or a pair of quotations,
>> but, say
>>
>> 3 "hi" |+|
>>
>> fails to dispatch?
>>
>>
>> ------------------------------------------------------------------------------
>> Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server
>> from Actuate! Instantly Supercharge Your Business Reports and Dashboards
>> with Interactivity, Sharing, Native Excel Exports, App Integration & more
>> Get technology previously reserved for billion-dollar corporations, FREE
>>
>> http://pubads.g.doubleclick.net/gampad/clk?id=164703151&iu=/4140/ostg.clktrk
>> _______________________________________________
>> Factor-talk mailing list
>> Factor-talk@lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/factor-talk
>>
>
>
------------------------------------------------------------------------------
Download BIRT iHub F-Type - The Free Enterprise-Grade BIRT Server
from Actuate! Instantly Supercharge Your Business Reports and Dashboards
with Interactivity, Sharing, Native Excel Exports, App Integration & more
Get technology previously reserved for billion-dollar corporations, FREE
http://pubads.g.doubleclick.net/gampad/clk?id=164703151&iu=/4140/ostg.clktrk
_______________________________________________
Factor-talk mailing list
Factor-talk@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/factor-talk
