some ergonomics for continuations

[disruptek]

I think I may start from scratch tomorrow. I looked at the code and it's not even 1000 lines, really. We can rebuild it smaller, tighter, more correct. Don't worry; we won't lose any progress. But tell me what you think of this:

http://ix.io/2sEW/nim

{.experimental: "dotOperators".}
{.experimental: "callOperator".}

type
  ## just a generic continuation concept
  C[T] = concept c
    c.fn is P[T]
    c.data is T
  P[T] = proc (c: T): T {.nimcall.}

proc `()`[T](c: var C[T]): T =
  ## run a continuation; returns a result
  while not c.fn.isNil:
    c = c.fn(c)
  result = c.data

proc `.`[T](c: C[T]; p: P[T]): C[T] =
  ## create a mutating continuation
  result = c
  result.fn = p

type
  ## we'll design our own generic datatype
  Fibber[T] = object
    fn: proc(c: Fibber[T]): Fibber[T] {.nimcall.}
    data: seq[T]

proc grow[T](c: Fibber[T]): Fibber[T] =
  ## "grow" a continuation; whatever that means
  echo "grow()"
  result = c
  let d = c.data[^2].ord + c.data[^1].ord
  if d <= high(T).ord:
    result.data.add T(d)
  else:
    # terminate the continuation
    result.fn = nil

proc shrink[T](c: Fibber[T]): Fibber[T] =
  ## the opposite operation
  echo "shrink()"
  result = c
  if len(result.data) > 0:
    discard result.data.pop
  else:
    # terminate the continuation
    result.fn = nil

proc calculate[T: Ordinal](n: T): seq[T] =
  assert grow is P   # grow is a continuation proc

  # make a "computer" using code and data
  var
    c = Fibber[T](fn: grow[T], data: @[default(T), default(T).succ])

  assert c is C      # c is a continuation

  # call the continuation to produce a result
  result = c()

  # lazily mutate some data
  var d = c.shrink
  var e = d.shrink
  assert d is C                     # these are continuations,
  assert e is C                     # what else?

  # c() does not run grow() again
  assert len(c()) == len(e()) + 2   # e has run shrink() once
  assert len(c()) == len(d()) + 1   # d has run shrink() once

  echo "pre-shrunk: ", c()          # noop; yields result
  echo "    shrunk: ", d()          # noop; yields result
  echo "veryshrunk: ", e()          # noop; yields result

  # do it all at once
  var f = e.shrink()                # resolved continuation
  assert f is C                     # of course
  echo "     frunk: ", f()          # noop; yields result

assert calculate(0'i8) == @[0'i8, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
assert calculate(0'u8) == @[0'u8, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]

Output

grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
shrink()
shrink()
pre-shrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
    shrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
veryshrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
shrink()
     frunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21]
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
grow()
shrink()
shrink()
pre-shrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
    shrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]
veryshrunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
shrink()
     frunk: @[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

[zevv]

Excellent.

I think you just write down what I was about to write down first thing this morning. I'll have breakfast and stroll around the woods and then see if I can shoot a hole in it.

[zevv]

The call operator fits in very smooth and naturally here, stroke of genius.