On Wed, Jun 13, 2012 at 11:42 AM, Jose Mario Quintana
<jose.mario.quint...@gmail.com> wrote:
> I do not think I implemented a fixed point combinator either and I
> doubt it can really be done directly in J because verbs cannot take
> directly verbs as arguments, and adverbs or conjunctions cannot take
> directly adverbs or conjunctions (at least not anymore in the current
> standard implementation of J). Nevertheless, indirect recursion can
> be implemented neatly as we found out and others before us.
I think the trick here is that in a lisp-like language being at the
front of certain lisps is "special". It's special in much the way
that `:6 is special for gerunds or J's apply is special for named
verb's -- in a lisp-like language this special syntax signals that a
lambda needs to take action instead of being passive.
Hypothetically speaking, I think we could live with an analogy like "a
lambda in J is a gerund of a monadic verb" and build up a system in J
which is very like a lambda. J's limitation where a monadic verb
takes only one argument is something of a sticking point. But we
could solve that. Using psuedo-lisp, instead of
((lambda (a b c) ...) A B C)
we would do something like this:
((((lambda (a b c) ...) A) B) C)
of course, if we were really writing in a lisp-like language that
would look more like:
((((lambda (a)
(lambda (b)
(lambda (c)
...))) A) B) C)
so ideally, I would use some name other than "lambda" for my variant
construct, but "lambda" is a nonsense word -- it's just an arbitrary
letter -- so it's hard to think of a suitably systematic variant.
So... code:
lambda=:3 :0
if. 1=#;:y do.
3 :((y,'=.y');<;._2]0 :0)`''
else.
(,<#;:y) Defer (3 :(('''',y,'''=.y');<;._2]0 :0))`''
end.
)
Defer=:2 :0
if. (_1 {:: m) <: #m do.
v |. y;_1 }. m
else.
(y;m) Defer v`''
end.
)
Note''
single letter words which follow have meaning beyond
this message and outside the J language.
Search for "S combinator" for details and examples.
)
I=: lambda 'x'
x
)
K=: lambda 'x y'
y
)
S=: lambda 'x y z'
(x`:6 z)`:6 y`:6 z
)
I think I got that right -- I tried finding examples, but people
discussing this system seem to be shy about using examples.
Anyways, here's an example of how to achieve the above identity gerund
I in terms of S and K:
I`:6 'a'
a
(((S`:6 K)`:6 K)`:6 K)`:6 'a'
a
Of course, we could have instead defined K this way:
K=: lambda 'x'
I
)
But then the result of (((S`:6 K)`:6 K)`:6 K)`:6 would be I which
would defeat the point of implementing it without using I.
That said, note that S was not necessary here. K`:6 K already
represents the same operation that I represents.
(Again, I am assuming I got the definitions correct -- if someone sees
any errors here, please let me know.)
Thanks,
--
Raul
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
