Indeed, this seems promising too. I'll try using 'F.' as it would be better
to do that with a primitive, but I'll use a boxed string if that fails.
Thanks!
Le mer. 8 janv. 2020 à 03:28, Julian Fondren <jfond...@minimaltype.com> a
écrit :
> Howdy,
>
> Consider:
>
> infinite =: 1 ; 'last + 2'
> infinite
> ┌─┬────────┐
> │1│last + 2│
> └─┴────────┘
> car =: [: > {.
> car infinite
> 1
> cdr =: monad : 0
> last =: car y
> this =. ". > {: y
> this ; {: y
> )
> cdr infinite
> ┌─┬────────┐
> │3│last + 2│
> └─┴────────┘
> cdr cdr infinite
> ┌─┬────────┐
> │5│last + 2│
> └─┴────────┘
> (monad : 'car cdr^:y infinite')"0 i.10
> 1 3 5 7 9 11 13 15 17 19
>
> Is this wise, or efficient, or sane, or legal where you are? I've no
> idea. (Although calling cdr 9 times for the 9th element, and then 10
> times for the 10th element, is definitely an efficiency loser. This is
> a failure of the example rather than the data structure.) But this is
> an example of an 'infinite list' implemented as a pair of boxed values,
> the first the first real member of the list, and the second a boxed
> string describing how further values of the list can be calculated.
> This is similar to how you might implement a lazy list in a Lisp-like
> language that doesn't have any native support for them.
>
> In most languages you'd use an anonymous closure for the second member
> of the pair, and an eager language that had some support for 'lazy
> lists' might have some lazy/force syntax that's closures under the
> hood.
>
> On Wed, 2020-01-08 at 02:24 +0100, Raoul Schorer wrote:
> > Well, I guess that out of context my question boils down to:
> >
> > 'Is it possible to define infinite data structures and operate on
> > them in
> > J?'
> >
> > For example, take the first ten elements of an infinite list, as in
> > Haskell.
> > The 'F.' primitive family seems promising indeed.
> >
> >
> >
> > Le mer. 8 janv. 2020 à 01:56, Henry Rich <henryhr...@gmail.com> a
> > écrit :
> >
> > > I don't understand the task at all. You might look in NuVoc for
> > > $:, F.
> > > etc., and M.
> > >
> > > Henry Rich
> > >
> > > On 1/7/2020 7:51 PM, Raoul Schorer wrote:
> > > > Hi,
> > > >
> > > > Implementing Minikanren <http://minikanren.org/> in J by
> > > > translating
> > > from
> > > > Scheme, I stumbled on the following:
> > > > I have a Scheme procedure 'fives'
> > > > <
> > >
> https://github.com/jasonhemann/microKanren/blob/master/microKanren-test-programs.scm
> > > > that is passed a vector and yields a procedure that then takes a
> > > > pair.
> > > > ((fives (vector 0)) '(() . 0))
> > > >
> > > > My problem is that this then evaluates to a pair data --
> > > > procedure:
> > > > ((((#(0) . 5)) . 0) . #<procedure at microKanren-test-
> > > > programs.scm:677>)
> > > >
> > > > The second member of the pair (the procedure) is then evaluated
> > > > on demand
> > > > to yield another similar structure of length n+1, therefore
> > > > allowing the
> > > > lazy evaluation of this infinite "stream".
> > > >
> > > > Is switching to iterative/eager eval the only realistic way?
> > > > Can someone help me with lazy eval of infinite structures in J,
> > > > or give
> > > me
> > > > pointers to resources on the topic?
> > > >
> > > > Thanks!
> > > > Raoul Schorer
> > > > ---------------------------------------------------------------
> > > > -------
> > > > 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
>
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
