pretty cool,
[: +: 2 2 'asd' strand
┌──┬───┬───┐
│+:│2 2│asd│
└──┴───┴───┘
[: +:@+/ 2 2 'asd' strand
┌────────────────┬───┬───┐
│┌─┬────────────┐│2 2│asd│
││/│┌──────────┐││ │ │
││ ││┌─┬──────┐│││ │ │
││ │││@│┌──┬─┐││││ │ │
││ │││ ││+:│+│││││ │ │
││ │││ │└──┴─┘││││ │ │
││ ││└─┴──────┘│││ │ │
││ │└──────────┘││ │ │
│└─┴────────────┘│ │ │
└────────────────┴───┴───┘
can provide infinite params to an adverb. Its a bit tricky to assign mixed
gerund(functions) and noun boxes though I'm sure its doable. A v verb could be
built up one parameter at a time as well.
I can think of many applications:
[: THEN if TEST (maybe implemented with ^:
ELSE THEN if TEST (implemented with @.) has advantage of fewer parens as the
right side of ` pretty much always needs some.
variable number of params to a modifier
short circuiting, where if some condition is reached in evaluation "so far",
then all of the remaining params are parsed and discarded.
By passing string (linear) representations as parameters, a verb train could be
build that all share the same adverb (error checking, logging, data coercion),
or different adverbs combined with a shared parameter.
It could also do parenless forks, where cap is inserted if there is an even
number of verbs, or disguarded if an odd number.
----- Original Message -----
From: Raul Miller <rauldmil...@gmail.com>
To: Programming forum <programm...@jsoftware.com>
Cc:
Sent: Friday, September 5, 2014 7:23:32 PM
Subject: Re: [Jprogramming] injecting local variables into tacit code
Here's another fun thing to try with that trick:
stranded=:2 :0
if.3=nc<'u' do.
if. [:`'' -: u`'' do.
n return.
end.
stranded(u`n)
else.
stranded((<m),n)
end.
)
strand=:stranded''
Example use:
[: 'this' 'is' 'a' 'test' strand
+----+--+-+----+
|this|is|a|test|
+----+--+-+----+
Mind you, I can't think of anything useful to do with this, but it's still
fun to play with.
Thanks,
--
Raul
On Fri, Sep 5, 2014 at 3:08 PM, 'Pascal Jasmin' via Programming <
programm...@jsoftware.com> wrote:
> Something very cool that works though not quite as well as I hoped. It is
> possible for an adverb to inject other adverbs into a tacit verb. One
> application of this is having syntactic sugar for tacit code:
>
> eval
> =: 1 : ' a: 1 : m'
> strbracket
> =: {.@:[ , ] , {:@[
> lrA
> =: 1 : '5!:5 < ''u'''
>
> sugartable =: > ({. (, <) ;: inv@:}. ) each ;: each cutLF 0 : 0
> Y @:]
> X @:[
> Y0 @:(0 {:: ])
> Y1 @:(1 {:: ])]
> Y2 @:(2 {:: ])]
> X0 @:(0 {:: [)
> X1 @:(1 {:: [)
> H @:{.
> R @:}.
> T @:{:
> )
>
> sugarA =: 2 : 0
> ('()' strbracket '[ ', ('()' strbracket u lrA) ,'] [ ]', , ('()'
> strbracket ;: inv)"1 (;: ,. (<'=.'),. ({:"1 sugartable) {~ ({."1
> sugartable) i. ;:) n) eval
> )
>
> This design allows not having every possible syntactic sugar definition
> stored in z
>
> sugartable
> ┌──┬────────────────┐
> │Y │@: ] │
> ├──┼────────────────┤
> │X │@: [ │
> ├──┼────────────────┤
> │Y0│@: ( 0 {:: ] ) │
> ├──┼────────────────┤
> │Y1│@: ( 1 {:: ] ) ]│
> ├──┼────────────────┤
> │Y2│@: ( 2 {:: ] ) ]│
> ├──┼────────────────┤
> │X0│@: ( 0 {:: [ ) │
> ├──┼────────────────┤
> │X1│@: ( 1 {:: [ ) │
> ├──┼────────────────┤
> │H │@: {. │
> ├──┼────────────────┤
> │R │@: }. │
> ├──┼────────────────┤
> │T │@: {: │
> └──┴────────────────┘
>
> the code is based on this possible expression:
>
> 2 3 ([ (]X + +/Y) ] [ ](X=. @:[) (Y =. @:])) 1 2 3
> 8 9
> ([ (]X + +/Y) ] [ ](X=. @:[) (Y =. @:]))
> [ (]@:[ + +/@:]) ] [ ]@:[@:]
>
> simplest use:
> (+:X + +:Y) sugarA 'Y X '
> [ (+:@:[ + +:@:]) ] [ ]@:]@:[
>
> (+:H R X + +:Y) sugarA 'Y X H R'
> [ (+:@:{.@:}.@:[ + +:@:]) ] [ ]@:]@:[@:{.@:}.
>
>
> sugarA takes as n arg a list of sugar adverbs defined from sugartable.
> The v arg isn't strictly needed as the whole table could be inserted into
> the resulting verb, but passing a table allows for unused sugar to be
> variables in scope, and if the whole table was always used, we might as
> well use the much more convenient z predefinitions.
>
> The u arg is a tacit verb with variables from sugartable.
>
> The verb that will be executed above is equivalent to:
>
> (+:@:{.@:}.@:[ + +:@:]) NB. double of head of rest of x + double
> of y
>
> The result could be cleaned up easily to be just this.
>
> 1 2(+:H R X + +:Y) sugarA 'Y X H R' 3
> 10
>
> The only reason I say this does not work well is that there needs to be an
> even number of adverbs in order not to change your tacit verb from hook to
> fork, as the variables are initially parsed as verbs. So to use an odd
> number of adverbs, you need to bracket or remove some:
>
> 1 2(+:(H X) + +:Y) sugarA 'Y X H R' 3
> 8
>
> or
> 1 2(+:H X + +:@]) sugarA 'Y X H R' 3
> 8
>
> This problem does not occur with predefined adverbs, and so given the
> typing savings of "sugarA 'Y X H R'", its easy to prefer that approach.
> The problem can also be eliminated by passing u as a string, so the
> approach is interesting even though I am putting it aside for now.
>
>
> Hopefully, it is also an interesting conjunction example: Building a
> tacit verb with external references.
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
