# test net with all features

lang go

declare @import 'import "fmt"'

declare """
func abs (n int) int {
  if n < 0 {
    return -n
  } else {
    return n
  }
}

func max (init int, values ...int) int {
  m := init
  for v := range values {
    if v > m {
      m = v
    }
  }
  return m
}

func inc (v interface{}, n uint64) (interface{}, uint64) {
  return v.(int)+1, n
}

var MAX int = 5
"""

net "test net" :
    place p0 Token = DOT # ensure finite execution
    place p1 int = 0, 1, 2
    place p2 int = 1, 2, 3
    place p3 int = MAX, {MAX+1}
    # values
    trans t01 :
        < p0 val = DOT
        < p1 val = 1
        > p2 val = 2
    # variables
    trans t02 x > 0 :
        < p0 val = DOT
        < p1 var = x
        > p2 var = x
    # input multiarc, expressions
    trans t03 x != y :
        < p0 val = DOT
        < p1 var  = x
        < p1 var  = y
        > p2 expr = x+y
    # input expressions
    trans t04 x > 0 :
        < p0 val = DOT
        < p1 var  = x
        < p1 expr = x+1
        > p2 expr = x+2
    # output multiarc, expressions reuse, untyped output
    trans t05 x != y :
        < p0 val = DOT
        < p1 var  = x
        < p1 var  = y
        < p1 expr = abs(x - y)
        > p2 var  = x
        > p2 expr = y+1
        > p3 expr = abs(x - y)
    # test on input
    trans t06 x != y :
        < p0 val = DOT
        < p1 var  = x
        < p2 ?var = y
        > p3 expr = x+y
    # test on input multiarc
    trans t07 x != y :
        < p0 val = DOT
        < p1 var  = x
        < p1 ?var = y
        > p3 expr = x+y
    # only test inputs
    trans t08 x != y :
        < p0 val = DOT
        < p1 ?var = x
        < p2 ?var = y
        > p3 expr = x+y
    # only tests in input multiarc
    trans t09 x != y :
        < p0 val = DOT
        < p1 ?var = x
        < p1 ?var = y
        > p3 expr = x+y
    # test on output
    trans t10 x != y :
        < p0 val = DOT
        < p1 var  = x
        < p2 var  = y
        > p3 ?expr = x+y
    # flush and fill arcs
    trans t11 m.Len() > 0 :
        < p0 val = DOT
        < p1 flush = m
        < p3 flush+ = n
        > p2 fill  = m.Copy().Add(n)
    # test flush and test fill
    trans t12 m.Len() > 0 :
        < p0 val = DOT
        < p1 ?flush = m
        > p2 ?fill  = m.Copy().Add(m)
    # multiarc fill
    trans t13 m.Len() > 0 :
        < p0 val = DOT
        < p1 flush = m
        > p1 fill  = m
        > p1 fill  = m.Map(inc)
    # inhibitor value
    trans t14 :
        < p0 val = DOT
        < p1 !val = 1
        > p2 val  = 2
    # inhibitor variable
    trans t15 :
        < p0 val = DOT
        < p1 var       = x
        < p2 ![y<x]var = y
        > p3 val       = 2
    # inhibitor expression
    trans t16 :
        < p0 val = DOT
        < p1 var   = x
        < p2 !expr = x+1
        > p3 val   = 2
    # tuples
    place p5 (int, int)
    place p6 (string, (int, int), bool)
    # input/output and nested
    trans t17 :
        < p0 val = DOT
        < p5 (var, var) = (x, y)
        < p6 (var, (var, var), var) = (z, (x, y), b)
        > p6 (expr, (var, var), expr) = ({fmt.Sprintf("%d+%d", x, y)}, (x, y), {x==y})
    # partially matched tuples
    trans t18 :
        < p0 val = DOT
        < p5 var = x
        > p6 (expr, var, expr) = ({fmt.Sprintf("(%d, %d)", x._0, x._1)}, x, {max(x._0, x._1) > 0})
    # tests
    trans t19 :
        < p0 val = DOT
        < p5 ?(var, val) = (x, 0)
        > p6 ?(var, expr, val) = (x, [_int_int_{x+1, x}], true)
    # multiarc
    trans t20 :
        < p0 val = DOT
        < p5 (var, val) = (x, 0)
        < p5 var = y
        > p6 (expr, var, val) = ({fmt.Sprintf("%d", x)}, y, true)
        > p6 (val, (var, expr), val) = ({fmt.Sprintf("%d", x)}, (x, {x-1}), true)
    # inhibitor
    trans t22 :
        < p0 val = DOT
        < p5 !(var, val) = (x, 0)