ATSLIB/prelude/stream_vt


  • stream_vt
  • stream_vt_con
  • stream2list_vt
  • stream_vt_free
  • stream_vt_foreach
  • stream_vt_foreach_env
  • stream_vt_foreach$fwork
  • stream_vt_filter
  • stream_vt_filter$pred
  • stream_vt_filter_fun
  • stream_vt_filter_cloptr
  • stream_vt_filterlin
  • stream_vt_filterlin$clear
  • stream_vt_map
  • stream_vt_map$fopr
  • stream_vt_map_fun
  • stream_vt_map_cloptr
  • stream_vt_map2
  • stream_vt_map2$fopr
  • stream_vt_map2_fun
  • stream_vt_map2_cloptr
  • stream_vt_tabulate
  • stream_vt_tabulate$fopr
  • streamer_vt
  • streamer_vtype
  • streamer_vt_make
  • streamer_vt_free
  • streamer_vt_eval_exn
  • Overloaded Symbols
  • ~
  • []
  • .head
  • .tail

  • 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
      (xs: stream_vt(INV(a))): List0_vt(a)

    stream_vt_free

    Synopsis

    fun{a:t0p}
    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) -<cloptr> 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?!): b // lin-cleared

    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}{b:vt0p
    } stream_vt_map2 (
      xs1: stream_vt (INV(a1))
    , xs2: stream_vt (INV(a2))
    ) : stream_vt (b) // end of [stream_vt_map2]

    stream_vt_map2$fopr

    Synopsis

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

    stream_vt_map2_fun

    Synopsis

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

    stream_vt_map2_cloptr

    Synopsis

    fun{
    a1,a2:t0p}{b:vt0p
    } stream_vt_map2_cloptr
    (
      xs1: stream_vt(INV(a1))
    , xs2: stream_vt(INV(a2))
    , fopr: (&a1 >> _, &a2 >> _) -<cloptr1> b
    ) : stream_vt(b) // 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

    .tail

    Synopsis

    overload .tail with stream_vt_tail

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