/*---------------------------------------------------------------------------
  Copyright 2012-2024, Microsoft Research, Daan Leijen.

  This is free software; you can redistribute it and/or modify it under the
  terms of the Apache License, Version 2.0. A copy of the License can be
  found in the LICENSE file at the root of this distribution.
---------------------------------------------------------------------------*/

// Standard vector functions.
module std/core/vectorstd/core/vector

import std/core/typesstd/core/types
import std/core/undivstd/core/undiv
import std/core/hndstd/core/hnd
import std/core/exnstd/core/exn
import std/core/intstd/core/int

extern import
  c  file "inline/vector"
  js file "inline/vector.js"

// ----------------------------------------------------------------------------
//  Vectors
// ----------------------------------------------------------------------------

// Return the element at position `index`  in vector `v`  without bounds check!
inline extern unsafe-idxstd/core/vector/unsafe-idx: forall<a> (v : vector<a>, index : ssize_t) -> a( ^v : vectorstd/core/types/vector: V -> V<aa: V>, index : ssize_tstd/core/types/ssize_t: V ) : totalstd/core/types/total: E aa: V
  c  "kk_vector_at_borrow"
  cs inline "(#1)[#2]"
  js inline "(#1)[#2]"

inline extern unsafe-assignstd/core/vector/unsafe-assign: forall<a> (v : vector<a>, i : ssize_t, x : a) -> () : forall<aa: V> ( v : vectorstd/core/types/vector: V -> V<aa: V>, i : ssize_tstd/core/types/ssize_t: V, x : aa: V ) -> totalstd/core/types/total: E (std/core/types/unit: V)std/core/types/unit: V
  c "kk_vector_unsafe_assign"
  cs inline "(#1)[#2] = #3"
  js inline "(#1)[#2] = #3"

inline extern unsafe-vectorstd/core/vector/unsafe-vector: forall<a> (n : ssize_t) -> vector<a> : forall<aa: V> ( n : ssize_tstd/core/types/ssize_t: V ) -> totalstd/core/types/total: E vectorstd/core/types/vector: V -> V<aa: V>
  c  inline "kk_vector_alloc(#1,kk_box_null(),kk_context())"
  cs inline "(new ##1[#1])"
  js inline "Array(#1)"

pub extern @unsafe-vector : forall<aa: V> ( n : ssize_tstd/core/types/ssize_t: V ) -> totalstd/core/types/total: E vectorstd/core/types/vector: V -> V<aa: V>
  c  inline "kk_vector_alloc(#1,kk_box_null(),kk_context())"
  cs inline "(new ##1[#1])"
  js inline "Array(#1)"

// Assign to an entry in a local `:vector` variable.
inline extern @index( ^self : local-varstd/core/types/local-var: (H, V) -> V<ss: H,vectorstd/core/types/vector: V -> V<aa: V>>, ^index : ssize_tstd/core/types/ssize_t: V, assigned : aa: V ) : <localstd/core/types/local: H -> X<ss: H>,exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> (std/core/types/unit: V)std/core/types/unit: V
  c  "kk_ref_vector_assign_borrow"
  js "$std_core_vector.kk_ref_vector_assign_borrow" 

// Assign to an entry in a local `:vector` variable.
pub inline fun @index( ^selfself: local-var<$314,vector<$312>> : local-varstd/core/types/local-var: (H, V) -> V<ss: H,vectorstd/core/types/vector: V -> V<aa: V>>, ^indexindex: int : intstd/core/types/int: V, assignedassigned: $312 : aa: V )result: -> <local<431>,exn|430> () : <localstd/core/types/local: H -> X<ss: H>,exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> (std/core/types/unit: V)std/core/types/unit: V
  withwith: () -> <div,exn,local<$314>|$313> () pretend-no-divstd/core/undiv/pretend-no-div: (action : () -> <div,exn,local<$314>|$313> ()) -> <exn,local<$314>|$313> ()
  val idxidx: ssize_t = indexindex: int.ssize_tstd/core/int/ssize_t: (i : int) -> <div,exn,local<$314>|$313> ssize_t()
  if idxidx: ssize_t <std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> <div,exn,local<$314>|$313> bool selfself: vector<$312>
?hdiv=iev@344.lengthzstd/core/vector/lengthz: (v : vector<$312>) -> <div,exn,local<$314>|$313> ssize_t then selfself: local-var<$314,vector<$312>>[idxidx: ssize_t] := assignedassigned: $312 else throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <div,exn,local<$314>|$313> ()("index out of bounds"literal: string
count= 19,ExnRangestd/core/exn/ExnRange: exception-info)  

// Length of a vector.
inline extern lengthzstd/core/vector/lengthz: forall<a> (v : vector<a>) -> ssize_t( ^v : vectorstd/core/types/vector: V -> V<aa: V> ) : ssize_tstd/core/types/ssize_t: V
  c  "kk_vector_len_borrow"
  cs inline "((#1).Length)"
  js inline "((#1).length)"

// Create a new vector of length `n`  with initial elements `init`` .
extern vector-allocstd/core/vector/vector-alloc: forall<a,e> (n : ssize_t, init : a) -> e vector<a>(nn: ssize_t : ssize_tstd/core/types/ssize_t: V, initinit: $441 : aa: V) : ee: E vectorstd/core/types/vector: V -> V<aa: V>
  c "kk_vector_alloc"
  cs inline "Primitive.NewArray<##1>(#1,#2)"
  js inline "_vector_initz(#1,#2)"

// Create a new vector of length `n`  with initial elements given by a total function `f` .
extern vector-alloc-totalstd/core/vector/vector-alloc-total: forall<a> (n : ssize_t, f : (ssize_t) -> a) -> vector<a>(nn: ssize_t : ssize_tstd/core/types/ssize_t: V, ff: (ssize_t) -> $470 : ssize_tstd/core/types/ssize_t: V -> astd/core/types/total: E) : vectorstd/core/types/vector: V -> V<aa: V>
  c "kk_vector_init_total"
  cs inline "Primitive.NewArray<##1>(#1,#2)"
  js inline "_vector_initf(#1,#2)"

// Create an empty vector.
extern prim-emptystd/core/vector/prim-empty: forall<a> () -> vector<a>() : vectorstd/core/types/vector: V -> V<aa: V>
  c  inline "kk_vector_empty()"
  cs inline "new ##1[0]"
  js inline "[]"

// Create an empty vector
pub fun emptystd/core/vector/empty: forall<a> () -> vector<a>()result: -> total vector<526> : vectorstd/core/types/vector: V -> V<aa: V> 
  prim-emptystd/core/vector/prim-empty: () -> vector<$512>()

// Return the element at position `index`  in vector `v`.
// Raise an out of bounds exception if `index < 0`  or `index >= v.length`.
pub fun @index( ^vv: vector<$253> : vectorstd/core/types/vector: V -> V<aa: V>, ^indexindex: int : intstd/core/types/int: V )result: -> exn 307 : exnstd/core/exn/exn: (E, V) -> V aa: V
  val idxidx: ssize_t = indexindex: int.ssize_tstd/core/int/ssize_t: (i : int) -> exn ssize_t()
  if idxidx: ssize_t <std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> exn bool vv: vector<$253>.lengthzstd/core/vector/lengthz: (v : vector<$253>) -> exn ssize_t then unsafe-idxstd/core/vector/unsafe-idx: (v : vector<$253>, index : ssize_t) -> exn $253(vv: vector<$253>,idxidx: ssize_t) else throwstd/core/exn/throw: (message : string, info : ? exception-info) -> exn $253("index out of bounds"literal: string
count= 19,ExnRangestd/core/exn/ExnRange: exception-info)

// Return the element at position `index` in vector `v`, or `Nothing` if out of bounds
pub fun atstd/core/vector/at: forall<a> (v : vector<a>, index : int) -> maybe<a>( ^vv: vector<$531> : vectorstd/core/types/vector: V -> V<aa: V>, ^indexindex: int : intstd/core/types/int: V )result: -> total maybe<579> : maybestd/core/types/maybe: V -> V<aa: V>
  val idxidx: ssize_t = indexindex: int.ssize_tstd/core/int/ssize_t: (i : int) -> ssize_t
  if idxidx: ssize_t <std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> bool vv: vector<$531>.lengthzstd/core/vector/lengthz: (v : vector<$531>) -> ssize_t then Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(unsafe-idxstd/core/vector/unsafe-idx: (v : vector<$531>, index : ssize_t) -> $531(vv: vector<$531>,idxidx: ssize_t)) else Nothingstd/core/types/Nothing: forall<a> maybe<a>

// Return the length of a vector.
pub fun lengthstd/core/vector/length: forall<a> (v : vector<a>) -> int( ^vv: vector<$584> : vectorstd/core/types/vector: V -> V<aa: V> )result: -> total int : intstd/core/types/int: V
  vv: vector<$584>.lengthzstd/core/vector/lengthz: (v : vector<$584>) -> ssize_t.intstd/core/int/ssize_t/int: (i : ssize_t) -> int

// Create a new vector of length `n`  with initial elements `default` .
pub fun vectorstd/core/vector/vector: forall<a> (n : int, default : a) -> vector<a>( ^nn: int : intstd/core/types/int: V, defaultdefault: $608 : aa: V)result: -> total vector<629> : vectorstd/core/types/vector: V -> V<aa: V>
  vector-allocstd/core/vector/vector-alloc: (n : ssize_t, init : $608) -> vector<$608>(nn: int.ssize_tstd/core/int/ssize_t: (i : int) -> ssize_t, defaultdefault: $608)

// Create a new vector of length `n`  with initial elements given by _total_ function `f`.
// (can be more efficient than `vector-init`)
pub fun vector-init-totalstd/core/vector/vector-init-total: forall<a> (n : int, f : (int) -> a) -> vector<a>( ^nn: int : intstd/core/types/int: V, ff: (int) -> $634 : intstd/core/types/int: V -> astd/core/types/total: E )result: -> total vector<664> : vectorstd/core/types/vector: V -> V<aa: V>
  vector-alloc-totalstd/core/vector/vector-alloc-total: (n : ssize_t, f : (ssize_t) -> $634) -> vector<$634>( nn: int.ssize_tstd/core/int/ssize_t: (i : int) -> ssize_t, fnfn: (i : ssize_t) -> $634(ii: ssize_t) ff: (int) -> $634(ii: ssize_t.intstd/core/int/ssize_t/int: (i : ssize_t) -> int) )

// Create a new vector of length `n`  with initial elements given by function `f` which can have a control effect.
pub fun vector-initstd/core/vector/vector-init: forall<a,e> (n : int, f : (int) -> e a) -> e vector<a>( ^nn: int : intstd/core/types/int: V, ff: (int) -> $732 $731 : intstd/core/types/int: V -> ee: E aa: V )result: -> 780 vector<779> : ee: E vectorstd/core/types/vector: V -> V<aa: V>
  val lenlen: ssize_t = nn: int.ssize_tstd/core/int/ssize_t: (i : int) -> $732 ssize_t
  val vv: vector<$731> = unsafe-vectorstd/core/vector/unsafe-vector: (n : ssize_t) -> $732 vector<$731>(lenlen: ssize_t)
  forzstd/core/vector/forz: (n : ssize_t, action : (ssize_t) -> $732 ()) -> $732 ()( lenlen: ssize_t ) fnfn: (i : ssize_t) -> $732 ()(ii: ssize_t)
    unsafe-assignstd/core/vector/unsafe-assign: (v : vector<$731>, i : ssize_t, x : $731) -> $732 ()(vv: vector<$731>,ii: ssize_t,ff: (int) -> $732 $731(ii: ssize_t.intstd/core/int/ssize_t/int: (i : ssize_t) -> $732 int))
  vv: vector<$731>

// Invoke a function `f` for each element in a vector `v`
pub fun foreachstd/core/vector/foreach: forall<a,e> (v : vector<a>, f : (a) -> e ()) -> e ()( vv: vector<$832> : vectorstd/core/types/vector: V -> V<aa: V>, ff: ($832) -> $833 () : (aa: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 857 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  vv: vector<$832>.foreach-indexedzstd/core/vector/foreach-indexedz: (v : vector<$832>, f : (ssize_t, $832) -> $833 ()) -> $833 ()( fnfn: (ssize_t, x : $832) -> $833 ()(_,xx: $832) { ff: ($832) -> $833 ()(xx: $832) })

// Invoke a function `f` for each element in a vector `v`
pub fun foreach-indexedstd/core/vector/foreach-indexed: forall<a,e> (v : vector<a>, f : (int, a) -> e ()) -> e ()( vv: vector<$864> : vectorstd/core/types/vector: V -> V<aa: V>, ff: (int, $864) -> $865 () : (intstd/core/types/int: V,aa: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 894 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  foreach-indexedzstd/core/vector/foreach-indexedz: (v : vector<$864>, f : (ssize_t, $864) -> $865 ()) -> $865 ()( vv: vector<$864>, fnfn: (i : ssize_t, x : $864) -> $865 ()(ii: ssize_t,xx: $864) { ff: (int, $864) -> $865 ()(ii: ssize_t.intstd/core/int/ssize_t/int: (i : ssize_t) -> $865 int,xx: $864) } )

fun foreach-indexedzstd/core/vector/foreach-indexedz: forall<a,e> (v : vector<a>, f : (ssize_t, a) -> e ()) -> e ()( vv: vector<$787> : vectorstd/core/types/vector: V -> V<aa: V>, ff: (ssize_t, $787) -> $788 () : (ssize_tstd/core/types/ssize_t: V,aa: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 825 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  forzstd/core/vector/forz: (n : ssize_t, action : (ssize_t) -> $788 ()) -> $788 ()( vv: vector<$787>.lengthzstd/core/vector/lengthz: (v : vector<$787>) -> $788 ssize_t ) fnfn: (i : ssize_t) -> $788 ()(ii: ssize_t)
    ff: (ssize_t, $787) -> $788 ()(ii: ssize_t,vv: vector<$787>.unsafe-idxstd/core/vector/unsafe-idx: (v : vector<$787>, index : ssize_t) -> $788 $787(ii: ssize_t))

// Invoke a function `f` for each element in a vector `v`.
// If `f` returns `Just`, the iteration is stopped early and the result is returned.
pub fun foreach-whilestd/core/vector/foreach-while: forall<a,b,e> (v : vector<a>, f : (a) -> e maybe<b>) -> e maybe<b>( vv: vector<$975> : vectorstd/core/types/vector: V -> V<aa: V>, ff: ($975) -> $977 maybe<$976> : aa: V -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 1021 maybe<1020> : ee: E maybestd/core/types/maybe: V -> V<bb: V>
  for-whilezstd/core/vector/for-whilez: (n : ssize_t, action : (ssize_t) -> $977 maybe<$976>) -> $977 maybe<$976>( vv: vector<$975>.lengthzstd/core/vector/lengthz: (v : vector<$975>) -> $977 ssize_t ) fnfn: (i : ssize_t) -> $977 maybe<$976>(ii: ssize_t)
    ff: ($975) -> $977 maybe<$976>(vv: vector<$975>.unsafe-idxstd/core/vector/unsafe-idx: (v : vector<$975>, index : ssize_t) -> $977 $975(ii: ssize_t))

// Apply a function `f` to each element in a vector `v`
pub fun mapstd/core/vector/map: forall<a,b,e> (v : vector<a>, f : (a) -> e b) -> e vector<b>( vv: vector<$1031> : vectorstd/core/types/vector: V -> V<aa: V>, ff: ($1031) -> $1033 $1032 : aa: V -> ee: E bb: V )result: -> 1091 vector<1090> : ee: E vectorstd/core/types/vector: V -> V<bb: V>
  val ww: vector<$1032> = unsafe-vectorstd/core/vector/unsafe-vector: (n : ssize_t) -> $1033 vector<$1032>(vv: vector<$1031>.lengthstd/core/vector/length: (v : vector<$1031>) -> $1033 int.ssize_tstd/core/int/ssize_t: (i : int) -> $1033 ssize_t)
  vv: vector<$1031>.foreach-indexedzstd/core/vector/foreach-indexedz: (v : vector<$1031>, f : (ssize_t, $1031) -> $1033 ()) -> $1033 () fnfn: (i : ssize_t, x : $1031) -> $1033 ()(ii: ssize_t,xx: $1031)
    unsafe-assignstd/core/vector/unsafe-assign: (v : vector<$1032>, i : ssize_t, x : $1032) -> $1033 ()(ww: vector<$1032>,ii: ssize_t,ff: ($1031) -> $1033 $1032(xx: $1031))
  ww: vector<$1032>

// Convert a vector to a list.
pub fun liststd/core/vector/list: forall<a> (v : vector<a>) -> list<a>( vv: vector<$1128> : vectorstd/core/types/vector: V -> V<aa: V> )result: -> total list<1146> : liststd/core/types/list: V -> V<aa: V>
  vv: vector<$1128>.vliststd/core/vector/vlist: (v : vector<$1128>, tail : ? (list<$1128>)) -> list<$1128>

// Convert a vector to a list with an optional tail.
pub extern vliststd/core/vector/vlist: forall<a> (v : vector<a>, tail : ? (list<a>)) -> list<a>( vv: vector<$1101> : vectorstd/core/types/vector: V -> V<aa: V>, tailtail: ? (list<$1101>) : liststd/core/types/list: V -> V<aa: V> = [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a> ) : liststd/core/types/list: V -> V<aa: V>
  c  "kk_vector_to_list"
  cs inline "Primitive.VList<##1>(#1,#2)"
  js inline "_vlist(#1,#2)"

// Convert a list to a vector.
pub fun list/vectorstd/core/vector/list/vector: forall<a> (xs : list<a>) -> vector<a>( xsxs: list<$1171> : liststd/core/types/list: V -> V<aa: V> )result: -> total vector<1186> : vectorstd/core/types/vector: V -> V<aa: V>
  xsxs: list<$1171>.unvliststd/core/vector/unvlist: (xs : list<$1171>) -> vector<$1171>

extern unvliststd/core/vector/unvlist: forall<a> (xs : list<a>) -> vector<a>( xsxs: list<$1151> : liststd/core/types/list: V -> V<aa: V> ) : vectorstd/core/types/vector: V -> V<aa: V>
  c  "kk_list_to_vector"
  cs inline "Primitive.UnVList<##1>(#1)"
  js inline "_unvlist(#1)"


// Executes `action` `n` times for each integer between [`0`,`n`)  (excluding `n` ).
// If `n <= 0`  the function returns without any call to `action` .
fun forzstd/core/vector/forz: forall<e> (n : ssize_t, action : (ssize_t) -> e ()) -> e ()( nn: ssize_t : ssize_tstd/core/types/ssize_t: V, actionaction: (ssize_t) -> $685 () : (ssize_tstd/core/types/ssize_t: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 727 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  fun reprep: (i : ssize_t) -> $685 ()( ii: ssize_t : ssize_tstd/core/types/ssize_t: V )result: -> $685 ()
    if ii: ssize_t <std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> $685 bool nn: ssize_t then
      actionaction: (ssize_t) -> $685 ()(ii: ssize_t)
      reprep: (i : ssize_t) -> $685 ()(pretend-decreasingstd/core/undiv/pretend-decreasing: (x : ssize_t) -> $685 ssize_t(ii: ssize_t.incrstd/core/vector/ssize_t/incr: (i : ssize_t) -> $685 ssize_t))std/core/types/Unit: ()
  reprep: (i : ssize_t) -> $685 ()(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000.ssize_tstd/core/int/ssize_t: (i : int) -> $685 ssize_t)

// Executes `action` at most `n` times for each integer between `0`  upto `n`  (excluding `n` ).
// If `n <= 0`  the function returns without any call to `action` .
// If `action` returns `Just`, the iteration is stopped and the result returned
fun for-whilezstd/core/vector/for-whilez: forall<a,e> (n : ssize_t, action : (ssize_t) -> e maybe<a>) -> e maybe<a>( nn: ssize_t : ssize_tstd/core/types/ssize_t: V, actionaction: (ssize_t) -> $902 maybe<$901> : (ssize_tstd/core/types/ssize_t: V) -> ee: E maybestd/core/types/maybe: V -> V<aa: V> )result: -> 968 maybe<967> : ee: E maybestd/core/types/maybe: V -> V<aa: V>
  fun reprep: (i : ssize_t) -> $902 maybe<$901>( ii: ssize_t : ssize_tstd/core/types/ssize_t: V )result: -> $902 maybe<$901>
    if ii: ssize_t <std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> $902 bool nn: ssize_t then
      match actionaction: (ssize_t) -> $902 maybe<$901>(ii: ssize_t)
        Nothingstd/core/types/Nothing: forall<a> maybe<a> -> reprep: (i : ssize_t) -> $902 maybe<$901>(pretend-decreasingstd/core/undiv/pretend-decreasing: (x : ssize_t) -> $902 ssize_t(ii: ssize_t.incrstd/core/vector/ssize_t/incr: (i : ssize_t) -> $902 ssize_t))
        Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $901) -> Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $901)
    else Nothingstd/core/types/Nothing: forall<a> maybe<a>
  reprep: (i : ssize_t) -> $902 maybe<$901>(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000.ssize_tstd/core/int/ssize_t: (i : int) -> $902 ssize_t)




// Minimal set of operations that we need in `std/core`.
inline fip extern ssize_t/(<=)std/core/vector/ssize_t/(<=): (ssize_t, ssize_t) -> bool : (ssize_tstd/core/types/ssize_t: V,ssize_tstd/core/types/ssize_t: V) -> boolstd/core/types/bool: V
  inline "(#1 <= #2)"

inline fip extern ssize_t/(>=)std/core/vector/ssize_t/(>=): (ssize_t, ssize_t) -> bool : (ssize_tstd/core/types/ssize_t: V,ssize_tstd/core/types/ssize_t: V) -> boolstd/core/types/bool: V
  inline "(#1 >= #2)"

inline fip extern ssize_t/(<)std/core/vector/ssize_t/(<): (ssize_t, ssize_t) -> bool  : (ssize_tstd/core/types/ssize_t: V,ssize_tstd/core/types/ssize_t: V) -> boolstd/core/types/bool: V
  inline "(#1 < #2)"

inline fip extern ssize_t/(+)std/core/vector/ssize_t/(+): (ssize_t, ssize_t) -> ssize_t  : (ssize_tstd/core/types/ssize_t: V,ssize_tstd/core/types/ssize_t: V) -> ssize_tstd/core/types/ssize_t: V
  js inline "((#1 + #2)|0)"
  inline "(#1 + #2)"
  
inline fip extern ssize_t/(-)std/core/vector/ssize_t/(-): (ssize_t, ssize_t) -> ssize_t  : (ssize_tstd/core/types/ssize_t: V,ssize_tstd/core/types/ssize_t: V) -> ssize_tstd/core/types/ssize_t: V
  js inline "((#1 - #2)|0)"
  inline "(#1 - #2)"
  
inline fip extern ssize_t/is-posstd/core/vector/ssize_t/is-pos: (i : ssize_t) -> bool( i : ssize_tstd/core/types/ssize_t: V ) : boolstd/core/types/bool: V
  inline "(#1 > 0)"

inline fip extern ssize_t/is-negstd/core/vector/ssize_t/is-neg: (i : ssize_t) -> bool( i : ssize_tstd/core/types/ssize_t: V ) : boolstd/core/types/bool: V
  inline "(#1 < 0)"

fip extern ssize_t/is-zerostd/core/vector/ssize_t/is-zero: (i : ssize_t) -> bool( ii: ssize_t : ssize_tstd/core/types/ssize_t: V ) : boolstd/core/types/bool: V
  js inline "(#1 === 0)"
  inline "(#1 == 0)"
  
fip extern ssize_t/decrstd/core/vector/ssize_t/decr: (i : ssize_t) -> ssize_t(ii: ssize_t : ssize_tstd/core/types/ssize_t: V ) : ssize_tstd/core/types/ssize_t: V
  inline "(#1 - 1)"

fip extern ssize_t/incrstd/core/vector/ssize_t/incr: (i : ssize_t) -> ssize_t(ii: ssize_t : ssize_tstd/core/types/ssize_t: V ) : ssize_tstd/core/types/ssize_t: V
  inline "(#1 + 1)"