Er... what makes a road a "dead end road"? Reaching the end of the
road too soon? (In other words: not enough problems and quirks?)
Anyways, I looked over your docs, and as near as I can tell, you just
left out user defined adverbs and conjunctions, as well as hooks and
forks. You might have left out some other stuff, like (name)=:
expression, and d. and so on. That is fine and good for a starting
effort, but some of your changes look like they would get in the way
of later development (so you might need to redo them or something).
But there's a lot you don't cover at all in your docs (like the
altered syntax rules you've used) so it's kind of hard to get an idea
of what all will not work.
(Writing good documentation - and getting it so people can find it
when they need it - is the hard part of an effort like this. As you
have no doubt been experiencing sometimes it's easier to just rewrite
a good part of the thing from scratch than it is to read the
documentation.)
You also might have some spurious characters in your documentation (|
and { and } in example lines - unless |": really is supposed to be
executable), so I am not quite sure if I understand your examples or
not.
Also, you got rid of _ for negative numbers, which mean extra rules
around handling spaces and/or complications when reusing numeric
vectors. Since you have not yet gotten around to documenting what you
did there, I have no idea which set of problems you decided to give
us.
Still, the core effort sounds like it might have been instructive. I'm
not sure this is useful enough yet that I would want to learn to use a
non-portable language like F#, but maybe going the other direction
(insight into some aspect of J) will have gotten somewhere good?
Thanks,
--
Raul
On Fri, Jul 29, 2016 at 8:29 AM, Erling Hellenäs
<[email protected]> wrote:
> Hi all !
>
> I released JWithATwist. https://github.com/andrimne/JWithATwist
>
> It is an experiment, a J-like language written in F#. I made it to learn F#
> and FParsec.
>
> It is a proposal for an alternative syntax of tacit J. I think what I call
> the hook-and-fork logic is a dead-end road. I love the syntax of explicit J
> and APL with right to left execution modified with parenthesis. This is how
> JWithATwist works.
>
> I thought JWithATwist would be a lot faster than J, because it is more like
> a compiled language. It does not seem to be. I guess tacit J and JWithATwist
> is actually very similar in how it basically works.
>
> It is an experiment in J integration in .NET.
>
> It has a possible use as an extension to F# for J and APL lovers.
>
> It can possibly be used for experiments of J integration in .NET.
>
> It contains a lot of possibly useful ideas for how J could be modified.
>
> I think J programmers could learn about how J works and get ideas about how
> it could be changed by looking in the manual and on the tests and possibly
> trying it out in the console.
>
> It is GPL.
>
> All opinions are welcome.
>
> Cheers,
>
> Erling Hellenäs
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
