ATSLIB/prelude/stream_vt

stream_vt

Synopsis

vtypedef
stream_vt (a:vt0p) = lazy_vt (stream_vt_con(a))

stream_vt_con

Synopsis

datavtype
stream_vt_con
  (a:vt@ype+) =
//
// vt@ype+: covariant
//
  | stream_vt_nil of ((*void*))
  | stream_vt_cons of (a, stream_vt(a))
//
where
stream_vt
  (a:vt@ype) = lazy_vt(stream_vt_con(a))

stream2list_vt

Synopsis

fun
{a:vt0p}
stream2list_vt
(stream_vt(INV(a))):<!wrt> List0_vt(a)

stream_vt_free

Synopsis

fun
{a:vt0p}
stream_vt_free
  (xs: stream_vt(a)):<!wrt> void

stream_vt_foreach

Synopsis

fun{a:vt0p}
stream_vt_foreach
  (stream_vt(INV(a))): stream_vt_con(a)

stream_vt_foreach_env

Synopsis

fun{
a:vt0p}{env:vt0p
} stream_vt_foreach_env
  (stream_vt(INV(a)), env: &env >> _): stream_vt_con(a)

stream_vt_foreach$fwork

Synopsis

fun{
a:vt0p}{env:vt0p
} stream_vt_foreach$fwork
  (x: &a >> a?!, env: &env >> _): void // lin-cleared

stream_vt_filter

Synopsis

fun{a:t0p}
stream_vt_filter
  (xs: stream_vt(INV(a))): stream_vt(a)

stream_vt_filter$pred

Synopsis

fun{a:t0p}
stream_vt_filter$pred(x: &a):<> bool

stream_vt_filter_fun

Synopsis

fun{a:t0p}
stream_vt_filter_fun
(
  xs: stream_vt(INV(a)), pred: (&a) -<fun> bool
) : stream_vt (a) // end of [stream_vt_filter_fun]

stream_vt_filter_cloptr

Synopsis

fun{a:t0p}
stream_vt_filter_cloptr
(
  xs: stream_vt(INV(a)), pred: (&a) -<cloptr1> bool
) : stream_vt (a) // end of [stream_vt_filter_cloptr]

stream_vt_filterlin

Synopsis

fun{a:vt0p}
stream_vt_filterlin
  (xs: stream_vt(INV(a))): stream_vt(a)

stream_vt_filterlin$clear

Synopsis

fun{a:vt0p}
stream_vt_filterlin$clear(x: &a >> a?):<!wrt> void

stream_vt_map

Synopsis

fun{
a:vt0p}{b:vt0p
} stream_vt_map
  (xs: stream_vt(INV(a))): stream_vt(b)

stream_vt_map$fopr

Synopsis

fun{
a:vt0p}{b:vt0p
} stream_vt_map$fopr(x: &a >> a?!):<1> (b)

stream_vt_map_fun

Synopsis

fun{
a:vt0p}{b:vt0p
} stream_vt_map_fun
(
xs: stream_vt(INV(a)), fopr: (&a >> a?!) -<fun1> b
) : stream_vt(b) // end-of-function

stream_vt_map_cloptr

Synopsis

fun{
a:vt0p}{b:vt0p
} stream_vt_map_cloptr
(
xs: stream_vt(INV(a)), fopr: (&a >> a?!) -<cloptr1> b
) : stream_vt(b) // end-of-function

stream_vt_map2

Synopsis

fun
{a1
,a2:t0p}
{b0:vt0p}
stream_vt_map2
(
  xs1: stream_vt(INV(a1))
, xs2: stream_vt(INV(a2))
) : stream_vt(b0) // end of [stream_vt_map2]

stream_vt_map2$fopr

Synopsis

fun
{a1
,a2:t0p}
{b0:vt0p}
stream_vt_map2$fopr(x1: &a1 >> _, x2: &a2 >> _):<1> b0

stream_vt_map2_fun

Synopsis

fun{
a1,a2:t0p}{b0:vt0p
} stream_vt_map2_fun
(
  xs1: stream_vt(INV(a1))
, xs2: stream_vt(INV(a2)), fopr: (&a1 >> _, &a2 >> _) -<fun1> b0
) : stream_vt(b0) // end of [stream_vt_map2_fun]

stream_vt_map2_cloptr

Synopsis

fun{
a1,a2:t0p}{b0:vt0p
} stream_vt_map2_cloptr
(
  xs1: stream_vt(INV(a1))
, xs2: stream_vt(INV(a2)), fopr: (&a1 >> _, &a2 >> _) -<cloptr1> b0
) : stream_vt(b0) // end of [stream_vt_map2_cloptr]

stream_vt_tabulate

Synopsis

fun
{a:vt0p}
stream_vt_tabulate((*void*)): stream_vt(a)

stream_vt_tabulate$fopr

Synopsis

fun
{a:vt0p}
stream_vt_tabulate$fopr(idx: intGte(0)): (a)

streamer_vt

Synopsis

vtypedef
streamer_vt(a:vt0p) = streamer_vtype(a)

streamer_vtype

Synopsis

absvtype
streamer_vtype(a:vt@ype+) = ptr

streamer_vt_make

Synopsis

fun{}
streamer_vt_make
  {a:vt0p}(stream_vt(INV(a))): streamer_vt(a)

streamer_vt_free

Synopsis

fun{}
streamer_vt_free{a:vt0p}(streamer_vt(INV(a))): void

streamer_vt_eval_exn

Synopsis

fun{
a:vt@ype
} streamer_vt_eval_exn(xser: !streamer_vt(INV(a))): (a)

Overloaded Symbols

~

Synopsis

overload ~ with streamer_vt_free

[]

Synopsis

overload [] with streamer_vt_eval_exn

.head

Synopsis

overload .head with stream_vt_head_exn

.tail

Synopsis

overload .tail with stream_vt_tail_exn

This page is created with ATS by Hongwei Xi and also maintained by Hongwei Xi.