Code written during 'Par Hangount - Starting from familiar concepts'

.par

declare unit: !
define unit = !

type Bool = either {
  .true !
  .false !
}

type Color = either {
  .red!
  .green!
  .blue!
}

type Option<T> = either {
  .none!
  .some T
}

declare pair: (Color) (Bool) (Color) (Bool) !
define pair = (.red!) (.false!) (.green!) (.true!) !

declare negate: [Bool] Bool

define test_negation = negate(.true!)

declare choice: {
  left => Bool
  right => Color
}

define choice = {
  left => .true!
  right => .green!
}

define negate = [bool] bool {
  true? => .false!
  false? => .true!
}

define made_choice = choice.right

define true = .true!
define false = .false!
define some_color = .some .red!

type List<T> = recursive either {
  .empty!
  .item (T) self
}

declare sample_list: List<Color>

define sample_list =
  .item(.red!)
  .item(.green!)
  .item(.blue!)
  .empty!

declare negate_list: [List<Bool>] List<Bool>

define negate_list = [list] list begin {
  empty? => .empty!
  item[bool] rest => .item(negate(bool)) rest loop
}

define try_negate_list = negate_list(
  .item(.false!)
  .item(.true!)
  .item(.false!)
  .empty!
)

declare concat: [type T] [List<T>] [List<T>] List<T>

define try_concat = concat(type Color)(sample_list)(sample_list)

type UnknownValue = (type T) T

declare some_unknown: UnknownValue
define some_unknown = (type Color) .red!

define concat = [type T] [left] [right] left begin {
  empty?     => right
  item[x] xs => .item(x) {xs loop}
}

type Stream<T> = iterative {
  close => !
  next  => (T) loop
}

// recursive  iterative
// either     { => }
// (...)      [...]
// !          ?

type Zero = either {}
type Top  = {}

type DualStream<T> = chan Stream<T>
type DualStream<T> = recursive either {
  .close ?
  .next [T] self
}

declare red_forever: Stream<Color>

define red_forever = begin {
  close => !
  next  => (.red!) loop
}

define test = do {
  let stream = red_forever
  stream.next[color1]
  stream.next[color2]
  stream.next[color3]
  stream.close?
} in (color1)(color2)(color3)!