/*---------------------------------------------------------------------------
  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 `:list` functions.
module std/core/liststd/core/list

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/charstd/core/char
import std/core/stringstd/core/string
import std/core/intstd/core/int
import std/core/vectorstd/core/vector


// Return the head of list if the list is not empty.
pub fbip fun maybe/headstd/core/list/maybe/head: forall<a> (xs : list<a>) -> maybe<a>( xsxs: list<$572> : liststd/core/types/list: V -> V<aa: V> )result: -> total maybe<597> : maybestd/core/types/maybe: V -> V<aa: V>
  match xsxs: list<$572>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $572) -> Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $572)
    _       -> Nothingstd/core/types/Nothing: forall<a> maybe<a>

// Return the head of list with a default value in case the list is empty.
pub fbip fun headstd/core/list/head: forall<a> (xs : list<a>, default : a) -> a( xsxs: list<$602> : liststd/core/types/list: V -> V<aa: V>, defaultdefault: $602 : aa: V )result: -> total 618 : astd/core/types/total: E
  match xsxs: list<$602>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $602) -> xx: $602
    _       -> defaultdefault: $602

// Return the tail of list. Returns the empty list if `xs` is empty.
pub fbip fun tailstd/core/list/tail: forall<a> (xs : list<a>) -> list<a>( xsxs: list<$623> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<641> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$623>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(_,xxxx: list<$623>) -> xxxx: list<$623>
    _          -> [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>

// Is the list empty?
pub fip fun is-emptystd/core/list/is-empty: forall<a> (xs : list<a>) -> bool( ^xsxs: list<$646> : liststd/core/types/list: V -> V<aa: V> )result: -> total bool : boolstd/core/types/bool: V
  match xsxs: list<$646>
    Nilstd/core/types/Nil: forall<a> list<a> -> Truestd/core/types/True: bool
    _   -> Falsestd/core/types/False: bool


// ----------------------------------------------------------------------------
// List functions
// ----------------------------------------------------------------------------

// Returns a singleton list.
pub fip(1) fun singlestd/core/list/single: forall<a> (x : a) -> list<a>(xx: _667)result: -> total list<681>
  [std/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>xx: _667]std/core/types/Nil: forall<a> list<a>

// Returns the length of a list.
pub fun lengthstd/core/list/length: forall<a> (xs : list<a>) -> int(xsxs: list<_722>)result: -> total int
  fun lenlen: forall<a> (ys : list<a>, acc : int) -> int(ysys: list<_696>,accacc: int)result: -> total int
    match ysys: list<_696>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(_,yyyy: list<_696>) -> yyyy: list<_696>.lenlen: (ys : list<_696>, acc : int) -> int(accacc: int+std/core/int/(+): (x : int, y : int) -> int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001)
      Nilstd/core/types/Nil: forall<a> list<a>        -> accacc: int
  xsxs: list<_722>.lenlen: (ys : list<_722>, acc : int) -> int(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000)

// Returns an integer list of increasing elements from `lo`  to `hi`
// (including both `lo`  and `hi` ).
// If `lo > hi`  the function returns the empty list.
pub fun range/liststd/core/list/range/list: (lo : int, hi : int) -> list<int>( lolo: int: intstd/core/types/int: V, hihi: int: intstd/core/types/int: V )result: -> total list<int> : totalstd/core/types/total: E liststd/core/types/list: V -> V<intstd/core/types/int: V>
  if lolo: int <=std/core/int/(<=): (x : int, y : int) -> bool hihi: int
    then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>( lolo: int, liststd/core/list/range/list: (lo : int, hi : int) -> list<int>( pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> int(lolo: int.incstd/core/int/inc: (i : int) -> int), hihi: int ) )
    else Nilstd/core/types/Nil: forall<a> list<a>

// Returns an integer list of increasing elements from `lo`  to `hi` with stride `stride`.
// If `lo > hi`  the function returns the empty list.
pub fun stride/liststd/core/list/stride/list: (lo : int, hi : int, stride : int) -> list<int>( lolo: int: intstd/core/types/int: V, hihi: int: intstd/core/types/int: V, stridestride: int : intstd/core/types/int: V )result: -> total list<int> : totalstd/core/types/total: E liststd/core/types/list: V -> V<intstd/core/types/int: V>
  if lolo: int <=std/core/int/(<=): (x : int, y : int) -> bool hihi: int
    then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>( lolo: int, liststd/core/list/stride/list: (lo : int, hi : int, stride : int) -> list<int>(  pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> int(lolo: int +std/core/int/(+): (x : int, y : int) -> int stridestride: int), hihi: int, stridestride: int ))
    else Nilstd/core/types/Nil: forall<a> list<a>

// Applies a function `f` to list of increasing elements from `lo`  to `hi`
// (including both `lo`  and `hi` ).
// If `lo > hi`  the function returns the empty list.
pub fun function/liststd/core/list/function/list: forall<a,e> (lo : int, hi : int, f : (int) -> e a) -> e list<a>( lolo: int: intstd/core/types/int: V, hihi: int: intstd/core/types/int: V, ff: (int) -> $1879 $1878 : intstd/core/types/int: V -> ee: E aa: V )result: -> 1939 list<1938> : ee: E liststd/core/types/list: V -> V<aa: V>
  if lolo: int <=std/core/int/(<=): (x : int, y : int) -> $1879 bool hihi: int
    then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>( ff: (int) -> $1879 $1878(lolo: int), liststd/core/list/function/list: (lo : int, hi : int, f : (int) -> $1879 $1878) -> $1879 list<$1878>( pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> $1879 int(lolo: int.incstd/core/int/inc: (i : int) -> $1879 int), hihi: int, ff: (int) -> $1879 $1878 ))
    else Nilstd/core/types/Nil: forall<a> list<a>

// Returns an integer list of increasing elements from `lo`  to `hi` with stride `stride`.
// If `lo > hi`  the function returns the empty list.
pub fun stridefunction/liststd/core/list/stridefunction/list: forall<a,e> (lo : int, hi : int, stride : int, f : (int) -> e a) -> e list<a>( lolo: int: intstd/core/types/int: V, hihi: int: intstd/core/types/int: V, stridestride: int : intstd/core/types/int: V, ff: (int) -> $2057 $2056 : intstd/core/types/int: V -> ee: E aa: V )result: -> 2119 list<2118> : ee: E liststd/core/types/list: V -> V<aa: V>
  if lolo: int <=std/core/int/(<=): (x : int, y : int) -> $2057 bool hihi: int
    then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>( ff: (int) -> $2057 $2056(lolo: int), liststd/core/list/stridefunction/list: (lo : int, hi : int, stride : int, f : (int) -> $2057 $2056) -> $2057 list<$2056>(  pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> $2057 int(lolo: int +std/core/int/(+): (x : int, y : int) -> $2057 int stridestride: int), hihi: int, stridestride: int, ff: (int) -> $2057 $2056 ))
    else Nilstd/core/types/Nil: forall<a> list<a>

// Create a list of characters from `lo`  to `hi`  (including `hi`).
pub fun char/liststd/core/list/char/list: (lo : char, hi : char) -> list<char>( lolo: char : charstd/core/types/char: V, hihi: char : charstd/core/types/char: V )result: -> total list<char> : totalstd/core/types/total: E liststd/core/types/list: V -> V<charstd/core/types/char: V>
  liststd/core/list/range/list: (lo : int, hi : int) -> list<int>(lolo: char.intstd/core/char/int: (char) -> int, hihi: char.intstd/core/char/int: (char) -> int).mapstd/core/list/map: (xs : list<int>, f : (int) -> char) -> list<char>( charstd/core/char/int/char: (i : int) -> char )

// Element-wise list equality
pub fun (==)std/core/list/(==): forall<a,e> (xs : list<a>, ys : list<a>, @implicit/(==) : (a, a) -> e bool) -> e bool( xsxs: list<$733> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$733> : liststd/core/types/list: V -> V<aa: V>, (@implicit/==)?(==): ($733, $733) -> $734 bool : (aa: V,aa: V) -> ee: E boolstd/core/types/bool: V )result: -> 814 bool : ee: E boolstd/core/types/bool: V
  match xsxs: list<$733>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $733,xxxx: list<$733>) -> match ysys: list<$733>
                    Nilstd/core/types/Nil: forall<a> list<a>        -> Falsestd/core/types/False: bool
                    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $733,yyyy: list<$733>) -> (xx: $733==?(==): ($733, $733) -> $734 boolyy: $733) &&std/core/types/(&&): (x : bool, y : bool) -> $734 bool (xxxx: list<$733>==std/core/list/(==): (xs : list<$733>, ys : list<$733>, @implicit/(==) : ($733, $733) -> $734 bool) -> $734 bool
?(==)=?(==)yyyy: list<$733>)
    Nilstd/core/types/Nil: forall<a> list<a> -> match ysys: list<$733>
             Nilstd/core/types/Nil: forall<a> list<a>  -> Truestd/core/types/True: bool
             Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a> -> Falsestd/core/types/False: bool

// Order on lists
pub fun cmpstd/core/list/cmp: forall<a,e> (xs : list<a>, ys : list<a>, @implicit/cmp : (a, a) -> e order) -> e order( xsxs: list<$834> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$834> : liststd/core/types/list: V -> V<aa: V>, @implicit/cmp?cmp: ($834, $834) -> $835 order : (aa: V,aa: V) -> ee: E orderstd/core/types/order: V )result: -> 910 order : ee: E orderstd/core/types/order: V
  match xsxs: list<$834>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $834,xxxx: list<$834>) -> match ysys: list<$834>
                    Nilstd/core/types/Nil: forall<a> list<a>        -> Gtstd/core/types/Gt: order
                    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $834,yyyy: list<$834>) -> match cmp?cmp: ($834, $834) -> $835 order(xx: $834,yy: $834)
                                    Eqstd/core/types/Eq: order -> cmpstd/core/list/cmp: (xs : list<$834>, ys : list<$834>, @implicit/cmp : ($834, $834) -> $835 order) -> $835 order
?cmp=?cmp(xxxx: list<$834>,yyyy: list<$834>)
                                    lglg: order -> lglg: order
    Nilstd/core/types/Nil: forall<a> list<a> -> match ysys: list<$834>
             Nilstd/core/types/Nil: forall<a> list<a>  -> Eqstd/core/types/Eq: order
             Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a> -> Ltstd/core/types/Lt: order

// Order2 on lists
pub fun order2std/core/list/order2: forall<a,e> (xs : list<a>, ys : list<a>, @implicit/order2 : (a, a) -> e order2<a>) -> e order2<list<a>>(xsxs: list<$2268> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$2268>: liststd/core/types/list: V -> V<aa: V>, ^@implicit/order2?order2: ($2268, $2268) -> $2269 order2<$2268>: (aa: V, aa: V) -> ee: E order2std/core/types/order2: V -> V<aa: V>)result: -> 2514 order2<list<2513>>: ee: E order2std/core/types/order2: V -> V<liststd/core/types/list: V -> V<aa: V>>
  match xsxs: list<$2268> 
    Nilstd/core/types/Nil: forall<a> list<a> -> match ysys: list<$2268> 
      Nilstd/core/types/Nil: forall<a> list<a> -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(Nilstd/core/types/Nil: forall<a> list<a>)
      ys'ys': list<$2268> -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(Nilstd/core/types/Nil: forall<a> list<a>, ys'ys': list<$2268>)
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2268,xxxx: list<$2268>) ->
      match ysys: list<$2268>
        Nilstd/core/types/Nil: forall<a> list<a> -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(Nilstd/core/types/Nil: forall<a> list<a>, Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2268,xxxx: list<$2268>))
        Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $2268,yyyy: list<$2268>) -> 
          match order2?order2: ($2268, $2268) -> $2269 order2<$2268>(xx: $2268,yy: $2268)
            Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(zz: $2268) -> 
              match order2std/core/list/order2: (xs : list<$2268>, ys : list<$2268>, @implicit/order2 : ($2268, $2268) -> $2269 order2<$2268>) -> $2269 order2<list<$2268>>
?order2=?order2(xxxx: list<$2268>,yyyy: list<$2268>)
                Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(zzzz: list<$2268>) -> Eq2std/core/types/Eq2: forall<a> (eq : a) -> order2<a>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $2268,zzzz: list<$2268>))
                Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(xx'xx': list<$2268>, yy'yy': list<$2268>) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $2268,xx'xx': list<$2268>), Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $2268,yy'yy': list<$2268>))
                Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(yy'yy': list<$2268>, xx'xx': list<$2268>) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $2268,yy'yy': list<$2268>), Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $2268,xx'xx': list<$2268>))
            Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(x'x': $2268,y'y': $2268) -> Lt2std/core/types/Lt2: forall<a> (lt : a, gt : a) -> order2<a>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(x'x': $2268,xxxx: list<$2268>), Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(y'y': $2268,yyyy: list<$2268>))
            Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(y'y': $2268,x'x': $2268) -> Gt2std/core/types/Gt2: forall<a> (lt : a, gt : a) -> order2<a>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(y'y': $2268,yyyy: list<$2268>), Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(x'x': $2268,xxxx: list<$2268>))

// Show a list
pub fun showstd/core/list/show: forall<a,e> (xs : list<a>, @implicit/show : (a) -> e string) -> e string( xsxs: list<$3731> : liststd/core/types/list: V -> V<aa: V>, @implicit/show?show: ($3731) -> $3732 string : aa: V -> ee: E stringstd/core/types/string: V )result: -> 3801 string : ee: E stringstd/core/types/string: V
  "["literal: string
count= 1 ++std/core/types/(++): (x : string, y : string) -> $3732 string xsxs: list<$3731>.mapstd/core/list/map: (xs : list<$3731>, f : ($3731) -> $3732 string) -> $3732 list<string>(show?show: ($3731) -> $3732 string).joinstd/core/list/joinsep/join: (xs : list<string>, sep : string) -> $3732 string(","literal: string
count= 1) ++std/core/types/(++): (x : string, y : string) -> $3732 string "]"literal: string
count= 1


// _deprecated_, use `list/show` instead.
pub fun show-liststd/core/list/show-list: forall<a,e> (xs : list<a>, show-elem : (a) -> e string) -> e string( xsxs: list<$3818> : liststd/core/types/list: V -> V<aa: V>, show-elemshow-elem: ($3818) -> $3819 string : (aa: V) -> ee: E stringstd/core/types/string: V )result: -> 3841 string : ee: E stringstd/core/types/string: V
  showstd/core/list/show: (xs : list<$3818>, @implicit/show : ($3818) -> $3819 string) -> $3819 string(xsxs: list<$3818>,@implicit/show=show-elemshow-elem: ($3818) -> $3819 string)



// Zip two lists together by pairing the corresponding elements.
// The returned list is only as long as the smallest input list.
pub fbip fun zipstd/core/list/zip: forall<a,b> (xs : list<a>, ys : list<b>) -> list<(a, b)>( xsxs: list<$3848> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$3849> : liststd/core/types/list: V -> V<bb: V> )result: -> total list<(3917, 3918)> : liststd/core/types/list: V -> V<(std/core/types/tuple2: (V, V) -> Vaa: V,bb: V)>
  match xsxs: list<$3848>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3848,xxxx: list<$3848>) -> match ysys: list<$3849>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $3849,yyyy: list<$3849>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)xx: $3848,yy: $3849)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b),zipstd/core/list/zip: (xs : list<$3848>, ys : list<$3849>) -> list<($3848, $3849)>(xxxx: list<$3848>,yyyy: list<$3849>))
      Nilstd/core/types/Nil: forall<a> list<a>        -> Nilstd/core/types/Nil: forall<a> list<a>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Zip two lists together by apply a function `f` to all corresponding elements.
// The returned list is only as long as the smallest input list.
pub fbip fun zipwithstd/core/list/zipwith: forall<a,b,c,e> (xs : list<a>, ys : list<b>, f : (a, b) -> e c) -> e list<c>( xsxs: list<$3926> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$3927> :liststd/core/types/list: V -> V<bb: V>, ^ff: ($3926, $3927) -> $3929 $3928 : (aa: V,bb: V) -> ee: E cc: V )result: -> 4001 list<4000> : ee: E liststd/core/types/list: V -> V<cc: V>
  match xsxs: list<$3926>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3926,xxxx: list<$3926>) -> match ysys: list<$3927>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $3927,yyyy: list<$3927>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: ($3926, $3927) -> $3929 $3928(xx: $3926,yy: $3927),zipwithstd/core/list/zipwith: (xs : list<$3926>, ys : list<$3927>, f : ($3926, $3927) -> $3929 $3928) -> $3929 list<$3928>(xxxx: list<$3926>,yyyy: list<$3927>,ff: ($3926, $3927) -> $3929 $3928))
      Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
    _ -> Nilstd/core/types/Nil: forall<a> list<a>

// Zip two lists together by apply a function `f` to all corresponding elements
// and their index in the list.
// The returned list is only as long as the smallest input list.
pub fbip fun zipwith-indexedstd/core/list/zipwith-indexed: forall<a,b,c,e> (xs0 : list<a>, ys0 : list<b>, f : (int, a, b) -> e c) -> e list<c>( xs0xs0: list<$4088> : liststd/core/types/list: V -> V<aa: V>, ys0ys0: list<$4089> :liststd/core/types/list: V -> V<bb: V>, ^ff: (int, $4088, $4089) -> $4091 $4090 : (intstd/core/types/int: V,aa: V,bb: V) -> ee: E cc: V )result: -> 4130 list<4129> : ee: E liststd/core/types/list: V -> V<cc: V>
  zipwith-iterstd/core/list/zipwith-iter: (i : int, xs : list<$4088>, ys : list<$4089>, f : (int, $4088, $4089) -> $4091 $4090) -> $4091 list<$4090>(0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000,xs0xs0: list<$4088>,ys0ys0: list<$4089>,ff: (int, $4088, $4089) -> $4091 $4090)

fbip fun zipwith-iterstd/core/list/zipwith-iter: forall<a,b,c,e> (i : int, xs : list<a>, ys : list<b>, f : (int, a, b) -> e c) -> e list<c>( ii: int, xsxs: list<_4022>, ysys: list<_4027>, ^ff: (int, _4022, _4027) -> _4018 _4033 )result: -> _4018 list<_4033>
  match xsxs: list<_4022>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: _4022,xxxx: list<_4022>) -> match ysys: list<_4027>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: _4027,yyyy: list<_4027>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: (int, _4022, _4027) -> _4018 _4033(ii: int,xx: _4022,yy: _4027),zipwith-iterstd/core/list/zipwith-iter: (i : int, xs : list<_4022>, ys : list<_4027>, f : (int, _4022, _4027) -> _4018 _4033) -> _4018 list<_4033>(ii: int+std/core/int/(+): (x : int, y : int) -> _4018 int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001,xxxx: list<_4022>,yyyy: list<_4027>,ff: (int, _4022, _4027) -> _4018 _4033))
      Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Unzip a list of pairs into two lists
pub fun unzipstd/core/list/unzip: forall<a,b> (xs : list<(a, b)>) -> (list<a>, list<b>)( xsxs: list<($4143, $4144)> : liststd/core/types/list: V -> V<(std/core/types/tuple2: (V, V) -> Vaa: V,bb: V)> )result: -> total (list<4346>, list<4347>) : (std/core/types/tuple2: (V, V) -> Vliststd/core/types/list: V -> V<aa: V>,liststd/core/types/list: V -> V<bb: V>)
  fun iteriter: forall<a,b,c,d> (ys : list<(a, b)>, acc1 : cctx<c,list<a>>, acc2 : cctx<d,list<b>>) -> (c, d)( ysys: list<(_4156, _4157)>, acc1acc1: cctx<_4201,list<_4156>>, acc2acc2: cctx<_4244,list<_4157>> )result: -> total (_4201, _4244)
    match ysys: list<(_4156, _4157)>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>((std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)xx: _4156,yy: _4157)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b),xxxx: list<(_4156, _4157)>) -> iteriter: (ys : list<(_4156, _4157)>, acc1 : cctx<_4201,list<_4156>>, acc2 : cctx<_4244,list<_4157>>) -> (_4201, _4244)(xxxx: list<(_4156, _4157)>,acc1acc1: cctx<_4201,list<_4156>> ++std/core/types/cctx/(++): (c1 : cctx<_4201,list<_4156>>, c2 : cctx<list<_4156>,list<_4156>>) -> cctx<_4201,list<_4156>> ctxctx: cctx<list<_4156>,list<_4156>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: _4156,holehole: list<_4156>),acc2acc2: cctx<_4244,list<_4157>> ++std/core/types/cctx/(++): (c1 : cctx<_4244,list<_4157>>, c2 : cctx<list<_4157>,list<_4157>>) -> cctx<_4244,list<_4157>> ctxctx: cctx<list<_4157>,list<_4157>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: _4157,holehole: list<_4157>))
      Nilstd/core/types/Nil: forall<a> list<a>            -> (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)acc1acc1: cctx<_4201,list<_4156>> ++.std/core/types/cctx/(++.): (c : cctx<_4201,list<_4156>>, x : list<_4156>) -> _4201 Nilstd/core/types/Nil: forall<a> list<a>,acc2acc2: cctx<_4244,list<_4157>> ++.std/core/types/cctx/(++.): (c : cctx<_4244,list<_4157>>, x : list<_4157>) -> _4244 Nilstd/core/types/Nil: forall<a> list<a>)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)
  iteriter: (ys : list<($4143, $4144)>, acc1 : cctx<list<$4143>,list<$4143>>, acc2 : cctx<list<$4144>,list<$4144>>) -> (list<$4143>, list<$4144>)(xsxs: list<($4143, $4144)>,ctxctx: ctx<list<$4143>> holehole: list<$4143>,ctxctx: ctx<list<$4144>> holehole: list<$4144>)

// Unzip a list of triples into three lists
pub fun unzip3std/core/list/unzip3: forall<a,b,c> (xs : list<(a, b, c)>) -> (list<a>, list<b>, list<c>)( xsxs: list<($4355, $4356, $4357)> : liststd/core/types/list: V -> V<(std/core/types/tuple3: (V, V, V) -> Vaa: V,bb: V,cc: V)>)result: -> total (list<4645>, list<4646>, list<4647>) : (std/core/types/tuple3: (V, V, V) -> Vliststd/core/types/list: V -> V<aa: V>,liststd/core/types/list: V -> V<bb: V>,liststd/core/types/list: V -> V<cc: V>)
  fun iteriter: forall<a,b,c,d,a1,b1> (ys : list<(a, b, c)>, acc1 : cctx<d,list<a>>, acc2 : cctx<a1,list<b>>, acc3 : cctx<b1,list<c>>) -> (d, a1, b1)( ysys: list<(_4371, _4372, _4373)>, acc1acc1: cctx<_4417,list<_4371>>, acc2acc2: cctx<_4460,list<_4372>>, acc3acc3: cctx<_4503,list<_4373>> )result: -> total (_4417, _4460, _4503)
    match ysys: list<(_4371, _4372, _4373)>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>((std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)xx: _4371,yy: _4372,zz: _4373)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c),xxxx: list<(_4371, _4372, _4373)>) -> iteriter: (ys : list<(_4371, _4372, _4373)>, acc1 : cctx<_4417,list<_4371>>, acc2 : cctx<_4460,list<_4372>>, acc3 : cctx<_4503,list<_4373>>) -> (_4417, _4460, _4503)(xxxx: list<(_4371, _4372, _4373)>,acc1acc1: cctx<_4417,list<_4371>> ++std/core/types/cctx/(++): (c1 : cctx<_4417,list<_4371>>, c2 : cctx<list<_4371>,list<_4371>>) -> cctx<_4417,list<_4371>> ctxctx: cctx<list<_4371>,list<_4371>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: _4371,holehole: list<_4371>),acc2acc2: cctx<_4460,list<_4372>> ++std/core/types/cctx/(++): (c1 : cctx<_4460,list<_4372>>, c2 : cctx<list<_4372>,list<_4372>>) -> cctx<_4460,list<_4372>> ctxctx: cctx<list<_4372>,list<_4372>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: _4372,holehole: list<_4372>),acc3acc3: cctx<_4503,list<_4373>> ++std/core/types/cctx/(++): (c1 : cctx<_4503,list<_4373>>, c2 : cctx<list<_4373>,list<_4373>>) -> cctx<_4503,list<_4373>> ctxctx: cctx<list<_4373>,list<_4373>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: _4373,holehole: list<_4373>))
      Nilstd/core/types/Nil: forall<a> list<a>            -> (std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)acc1acc1: cctx<_4417,list<_4371>> ++.std/core/types/cctx/(++.): (c : cctx<_4417,list<_4371>>, x : list<_4371>) -> _4417 Nilstd/core/types/Nil: forall<a> list<a>,acc2acc2: cctx<_4460,list<_4372>> ++.std/core/types/cctx/(++.): (c : cctx<_4460,list<_4372>>, x : list<_4372>) -> _4460 Nilstd/core/types/Nil: forall<a> list<a>,acc3acc3: cctx<_4503,list<_4373>> ++.std/core/types/cctx/(++.): (c : cctx<_4503,list<_4373>>, x : list<_4373>) -> _4503 Nilstd/core/types/Nil: forall<a> list<a>)std/core/types/Tuple3: forall<a,b,c> (fst : a, snd : b, thd : c) -> (a, b, c)
  iteriter: (ys : list<($4355, $4356, $4357)>, acc1 : cctx<list<$4355>,list<$4355>>, acc2 : cctx<list<$4356>,list<$4356>>, acc3 : cctx<list<$4357>,list<$4357>>) -> (list<$4355>, list<$4356>, list<$4357>)(xsxs: list<($4355, $4356, $4357)>,ctxctx: ctx<list<$4355>> holehole: list<$4355>,ctxctx: ctx<list<$4356>> holehole: list<$4356>,ctxctx: ctx<list<$4357>> holehole: list<$4357>)

// Unzip a list of quadruples into four lists
pub fun unzip4std/core/list/unzip4: forall<a,b,c,d> (xs : list<(a, b, c, d)>) -> (list<a>, list<b>, list<c>, list<d>)( xsxs: list<($4658, $4659, $4660, $4661)> : liststd/core/types/list: V -> V<(std/core/types/tuple4: (V, V, V, V) -> Vaa: V,bb: V,cc: V,dd: V)>)result: -> total (list<5035>, list<5036>, list<5037>, list<5038>) : (std/core/types/tuple4: (V, V, V, V) -> Vliststd/core/types/list: V -> V<aa: V>,liststd/core/types/list: V -> V<bb: V>,liststd/core/types/list: V -> V<cc: V>,liststd/core/types/list: V -> V<dd: V>)
  fun iteriter: forall<a,b,c,d,a1,b1,c1,d1> (ys : list<(a, b, c, d)>, acc1 : cctx<a1,list<a>>, acc2 : cctx<b1,list<b>>, acc3 : cctx<c1,list<c>>, acc4 : cctx<d1,list<d>>) -> (a1, b1, c1, d1)( ysys: list<(_4677, _4678, _4679, _4680)>, acc1acc1: cctx<_4724,list<_4677>>, acc2acc2: cctx<_4767,list<_4678>>, acc3acc3: cctx<_4810,list<_4679>>, acc4acc4: cctx<_4853,list<_4680>> )result: -> total (_4724, _4767, _4810, _4853)
    match ysys: list<(_4677, _4678, _4679, _4680)>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>((std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)xx: _4677,yy: _4678,zz: _4679,ww: _4680)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d),xxxx: list<(_4677, _4678, _4679, _4680)>) -> iteriter: (ys : list<(_4677, _4678, _4679, _4680)>, acc1 : cctx<_4724,list<_4677>>, acc2 : cctx<_4767,list<_4678>>, acc3 : cctx<_4810,list<_4679>>, acc4 : cctx<_4853,list<_4680>>) -> (_4724, _4767, _4810, _4853)(xxxx: list<(_4677, _4678, _4679, _4680)>,acc1acc1: cctx<_4724,list<_4677>> ++std/core/types/cctx/(++): (c1 : cctx<_4724,list<_4677>>, c2 : cctx<list<_4677>,list<_4677>>) -> cctx<_4724,list<_4677>> ctxctx: cctx<list<_4677>,list<_4677>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: _4677,holehole: list<_4677>),acc2acc2: cctx<_4767,list<_4678>> ++std/core/types/cctx/(++): (c1 : cctx<_4767,list<_4678>>, c2 : cctx<list<_4678>,list<_4678>>) -> cctx<_4767,list<_4678>> ctxctx: cctx<list<_4678>,list<_4678>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: _4678,holehole: list<_4678>),acc3acc3: cctx<_4810,list<_4679>> ++std/core/types/cctx/(++): (c1 : cctx<_4810,list<_4679>>, c2 : cctx<list<_4679>,list<_4679>>) -> cctx<_4810,list<_4679>> ctxctx: cctx<list<_4679>,list<_4679>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: _4679,holehole: list<_4679>),acc4acc4: cctx<_4853,list<_4680>> ++std/core/types/cctx/(++): (c1 : cctx<_4853,list<_4680>>, c2 : cctx<list<_4680>,list<_4680>>) -> cctx<_4853,list<_4680>> ctxctx: cctx<list<_4680>,list<_4680>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ww: _4680,holehole: list<_4680>))
      Nilstd/core/types/Nil: forall<a> list<a>            -> (std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)acc1acc1: cctx<_4724,list<_4677>> ++.std/core/types/cctx/(++.): (c : cctx<_4724,list<_4677>>, x : list<_4677>) -> _4724 Nilstd/core/types/Nil: forall<a> list<a>,acc2acc2: cctx<_4767,list<_4678>> ++.std/core/types/cctx/(++.): (c : cctx<_4767,list<_4678>>, x : list<_4678>) -> _4767 Nilstd/core/types/Nil: forall<a> list<a>,acc3acc3: cctx<_4810,list<_4679>> ++.std/core/types/cctx/(++.): (c : cctx<_4810,list<_4679>>, x : list<_4679>) -> _4810 Nilstd/core/types/Nil: forall<a> list<a>,acc4acc4: cctx<_4853,list<_4680>> ++.std/core/types/cctx/(++.): (c : cctx<_4853,list<_4680>>, x : list<_4680>) -> _4853 Nilstd/core/types/Nil: forall<a> list<a>)std/core/types/Tuple4: forall<a,b,c,d> (fst : a, snd : b, thd : c, field4 : d) -> (a, b, c, d)
  iteriter: (ys : list<($4658, $4659, $4660, $4661)>, acc1 : cctx<list<$4658>,list<$4658>>, acc2 : cctx<list<$4659>,list<$4659>>, acc3 : cctx<list<$4660>,list<$4660>>, acc4 : cctx<list<$4661>,list<$4661>>) -> (list<$4658>, list<$4659>, list<$4660>, list<$4661>)(xsxs: list<($4658, $4659, $4660, $4661)>,ctxctx: ctx<list<$4658>> holehole: list<$4658>,ctxctx: ctx<list<$4659>> holehole: list<$4659>,ctxctx: ctx<list<$4660>> holehole: list<$4660>,ctxctx: ctx<list<$4661>> holehole: list<$4661>)

// Take the first `n` elements of a list (or fewer if the list is shorter than `n`)
pub fun takestd/core/list/take: forall<a> (xs : list<a>, n : int) -> list<a>( xsxs: list<$926> : liststd/core/types/list: V -> V<aa: V>, nn: int : intstd/core/types/int: V )result: -> total list<971> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$926>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $926,xxxx: list<$926>) | nn: int >std/core/int/(>): (x : int, y : int) -> bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $926, takestd/core/list/take: (xs : list<$926>, n : int) -> list<$926>(xxxx: list<$926>, nn: int -std/core/int/(-): (x : int, y : int) -> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001))
    _ -> Nilstd/core/types/Nil: forall<a> list<a>

// Drop the first `n` elements of a list (or fewer if the list is shorter than `n`)
pub fun dropstd/core/list/drop: forall<a> (xs : list<a>, n : int) -> list<a>( xsxs: list<$976> : liststd/core/types/list: V -> V<aa: V>, nn: int : intstd/core/types/int: V )result: -> total list<1011> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$976>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(_,xxxx: list<$976>) | nn: int >std/core/int/(>): (x : int, y : int) -> bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 -> dropstd/core/list/drop: (xs : list<$976>, n : int) -> list<$976>(xxxx: list<$976>, nn: int -std/core/int/(-): (x : int, y : int) -> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001)
    _ -> xsxs: list<$976>

// Apply a function `f` to each element of the input list in sequence.
pub fip fun mapstd/core/list/map: forall<a,b,e> (xs : list<a>, f : (a) -> e b) -> e list<b>(xsxs: list<$2172> : liststd/core/types/list: V -> V<aa: V>, ^ff: ($2172) -> $2174 $2173 : aa: V -> ee: E bb: V)result: -> 2230 list<2229> : ee: E liststd/core/types/list: V -> V<bb: V>
  match xsxs: list<$2172>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2172,xxxx: list<$2172>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: ($2172) -> $2174 $2173(xx: $2172), xxxx: list<$2172>.mapstd/core/list/map: (xs : list<$2172>, f : ($2172) -> $2174 $2173) -> $2174 list<$2173>(ff: ($2172) -> $2174 $2173))
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Apply a function `f` to each element of the input list in sequence where takes
// both the index of the current element and the element itself as arguments.
pub fun map-indexedstd/core/list/map-indexed: forall<a,b,e> (xs : list<a>, f : (idx : int, value : a) -> e b) -> e list<b>(xsxs: list<$2530> : liststd/core/types/list: V -> V<aa: V>, ff: (idx : int, value : $2530) -> $2532 $2531 : (idx : intstd/core/types/int: V, value : aa: V) -> ee: E bb: V)result: -> 2590 list<2589> : ee: E liststd/core/types/list: V -> V<bb: V>
  fun map-idxmap-idx: (ys : list<$2530>, i : int) -> $2532 list<$2531>(ysys: list<$2530>,ii: int)result: -> $2532 list<$2531>
    match ysys: list<$2530>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $2530,yyyy: list<$2530>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: (idx : int, value : $2530) -> $2532 $2531(ii: int,yy: $2530), map-idxmap-idx: (ys : list<$2530>, i : int) -> $2532 list<$2531>(yyyy: list<$2530>,ii: int+std/core/int/(+): (x : int, y : int) -> $2532 int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001))
      Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
  map-idxmap-idx: (ys : list<$2530>, i : int) -> $2532 list<$2531>(xsxs: list<$2530>,0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000)

// Apply a function `f` to each element of the input list in sequence where `f` takes
// both the current element and the tail list as arguments.
pub fun map-peekstd/core/list/map-peek: forall<a,b,e> (xs : list<a>, f : (value : a, rest : list<a>) -> e b) -> e list<b>(xsxs: list<$2600> : liststd/core/types/list: V -> V<aa: V>, ff: (value : $2600, rest : list<$2600>) -> $2602 $2601 : (value : aa: V, rest : liststd/core/types/list: V -> V<aa: V>) -> ee: E bb: V)result: -> 2652 list<2651> : ee: E liststd/core/types/list: V -> V<bb: V>
  fun mappeekmappeek: (ys : list<$2600>) -> $2602 list<$2601>(ysys: list<$2600>)result: -> $2602 list<$2601>
    match ysys: list<$2600>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $2600,yyyy: list<$2600>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: (value : $2600, rest : list<$2600>) -> $2602 $2601(yy: $2600,yyyy: list<$2600>), yyyy: list<$2600>.mappeekmappeek: (ys : list<$2600>) -> $2602 list<$2601>)
      Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
  mappeekmappeek: (ys : list<$2600>) -> $2602 list<$2601>(xsxs: list<$2600>)

// Apply a function `f` to each element of the input list in sequence where takes
// both the index of the current element, the element itself, and the tail list as arguments.
pub fun map-indexed-peekstd/core/list/map-indexed-peek: forall<a,b,e> (xs : list<a>, f : (idx : int, value : a, rest : list<a>) -> e b) -> e list<b>(xsxs: list<$2662> : liststd/core/types/list: V -> V<aa: V>, ff: (idx : int, value : $2662, rest : list<$2662>) -> $2664 $2663 : (idx : intstd/core/types/int: V, value : aa: V, rest : liststd/core/types/list: V -> V<aa: V> ) -> ee: E bb: V)result: -> 2723 list<2722> : ee: E liststd/core/types/list: V -> V<bb: V>
  fun mapidxmapidx: (ys : list<$2662>, i : int) -> $2664 list<$2663>(ysys: list<$2662>,ii: int)result: -> $2664 list<$2663>
    match ysys: list<$2662>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $2662,yyyy: list<$2662>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(ff: (idx : int, value : $2662, rest : list<$2662>) -> $2664 $2663(ii: int,yy: $2662,yyyy: list<$2662>), mapidxmapidx: (ys : list<$2662>, i : int) -> $2664 list<$2663>(yyyy: list<$2662>,ii: int+std/core/int/(+): (x : int, y : int) -> $2664 int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001))
      Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
  mapidxmapidx: (ys : list<$2662>, i : int) -> $2664 list<$2663>(xsxs: list<$2662>,0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000)

// Reverse a list.
pub fip fun reversestd/core/list/reverse: forall<a> (xs : list<a>) -> list<a>(xsxs: list<$1074> : liststd/core/types/list: V -> V<aa: V>)result: -> total list<1092> : liststd/core/types/list: V -> V<aa: V>
  reverse-appendstd/core/list/reverse-append: (xs : list<$1074>, tl : list<$1074>) -> list<$1074>( xsxs: list<$1074>, Nilstd/core/types/Nil: forall<a> list<a> )

// Efficiently reverse a list `xs` and append it to `tl`:
// `reverse-append(xs,tl) == reverse(xs) ++ tl
pub fip fun reverse-appendstd/core/list/reverse-append: forall<a> (xs : list<a>, tl : list<a>) -> list<a>( xsxs: list<$1053> : liststd/core/types/list: V -> V<aa: V>, tltl: list<$1053> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<1069> : liststd/core/types/list: V -> V<aa: V>
  reverse-accstd/core/list/reverse-acc: (acc : list<$1053>, ys : list<$1053>) -> list<$1053>(tltl: list<$1053>,xsxs: list<$1053>)

fip fun reverse-accstd/core/list/reverse-acc: forall<a> (acc : list<a>, ys : list<a>) -> list<a>(accacc: list<$1016> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$1016> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<1048> : liststd/core/types/list: V -> V<aa: V>
    match ysys: list<$1016>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1016,xxxx: list<$1016>) -> reverse-accstd/core/list/reverse-acc: (acc : list<$1016>, ys : list<$1016>) -> list<$1016>(Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1016,accacc: list<$1016>),xxxx: list<$1016>)
      _          -> accacc: list<$1016>

// Append two lists.
pub fip fun (++)std/core/list/(++): forall<a> (xs : list<a>, ys : list<a>) -> list<a>(xsxs: list<$1137> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$1137> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<1153> : liststd/core/types/list: V -> V<aa: V>
  appendstd/core/list/append: (xs : list<$1137>, ys : list<$1137>) -> list<$1137>(xsxs: list<$1137>,ysys: list<$1137>)

// Append two lists.
pub fip fun appendstd/core/list/append: forall<a> (xs : list<a>, ys : list<a>) -> list<a>(xsxs: list<$1097> : liststd/core/types/list: V -> V<aa: V>, ysys: list<$1097> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<1132> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$1097>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1097,xxxx: list<$1097>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1097,appendstd/core/list/append: (xs : list<$1097>, ys : list<$1097>) -> list<$1097>(xxxx: list<$1097>,ysys: list<$1097>))
    Nilstd/core/types/Nil: forall<a> list<a> -> ysys: list<$1097>

// Fold a list from the right, i.e. `foldr([1,2],0,(+)) == 1+(2+0)`
// Note, `foldr` is less efficient than `foldl` as it reverses the list first.
pub fun foldrstd/core/list/foldr: forall<a,b,e> (xs : list<a>, z : b, f : (a, b) -> e b) -> e b(xsxs: list<$1214> : liststd/core/types/list: V -> V<aa: V>, zz: $1215 : bb: V, ff: ($1214, $1215) -> $1216 $1215 : (aa: V, bb: V) -> ee: E bb: V)result: -> 1257 1256 : ee: E bb: V
  xsxs: list<$1214>.reversestd/core/list/reverse: (xs : list<$1214>) -> $1216 list<$1214>.foldlstd/core/list/foldl: (xs : list<$1214>, z : $1215, f : ($1215, $1214) -> $1216 $1215) -> $1216 $1215(zz: $1215) fnfn: (x : $1215, y : $1214) -> $1216 $1215(xx: $1215,yy: $1214) ff: ($1214, $1215) -> $1216 $1215(yy: $1214,xx: $1215)

// Fold a list from the left, i.e. `foldl([1,2],0,(+)) == (0+1)+2`
// Since `foldl` is tail recursive, it is preferred over `foldr` when using an associative function `f`
pub fun foldlstd/core/list/foldl: forall<a,b,e> (xs : list<a>, z : b, f : (b, a) -> e b) -> e b(xsxs: list<$1158> : liststd/core/types/list: V -> V<aa: V>, zz: $1159 : bb: V, ff: ($1159, $1158) -> $1160 $1159 : (bb: V, aa: V) -> ee: E bb: V)result: -> 1204 1203 : ee: E bb: V
  match xsxs: list<$1158>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1158,xxxx: list<$1158>) -> foldlstd/core/list/foldl: (xs : list<$1158>, z : $1159, f : ($1159, $1158) -> $1160 $1159) -> $1160 $1159(xxxx: list<$1158>,ff: ($1159, $1158) -> $1160 $1159(zz: $1159,xx: $1158),ff: ($1159, $1158) -> $1160 $1159)
    Nilstd/core/types/Nil: forall<a> list<a>        -> zz: $1159

pub fun foldl1std/core/list/foldl1: forall<a,e> (xs : list<a>, f : (a, a) -> <exn|e> a) -> <exn|e> a(xsxs: list<$1267> : liststd/core/types/list: V -> V<aa: V>, ff: ($1267, $1267) -> <exn|$1268> $1267 : (aa: V,aa: V) -> <exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> aa: V)result: -> <exn|1314> 1313 : <exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> aa: V
  match xsxs: list<$1267>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1267,xxxx: list<$1267>) -> xxxx: list<$1267>.foldlstd/core/list/foldl: (xs : list<$1267>, z : $1267, f : ($1267, $1267) -> <exn|$1268> $1267) -> <exn|$1268> $1267(xx: $1267,ff: ($1267, $1267) -> <exn|$1268> $1267)
    Nilstd/core/types/Nil: forall<a> list<a>        -> throwstd/core/exn/throw: (message : string, info : ? exception-info) -> <exn|$1268> $1267("unexpected Nil in std/core/foldl1"literal: string
count= 33)

pub fun foldr1std/core/list/foldr1: forall<a,e> (xs : list<a>, f : (a, a) -> <exn|e> a) -> <exn|e> a(xsxs: list<$1321> : liststd/core/types/list: V -> V<aa: V>, ff: ($1321, $1321) -> <exn|$1322> $1321 : (aa: V,aa: V) -> <exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> aa: V)result: -> <exn|1350> 1349 : <exnstd/core/exn/exn: (E, V) -> V|std/core/types/effect-extend: (X, E) -> Eee: E> aa: V
  xsxs: list<$1321>.reversestd/core/list/reverse: (xs : list<$1321>) -> <exn|$1322> list<$1321>.foldl1std/core/list/foldl1: (xs : list<$1321>, f : ($1321, $1321) -> <exn|$1322> $1321) -> <exn|$1322> $1321(ff: ($1321, $1321) -> <exn|$1322> $1321)

// Create a list of `n` repeated elements `x`
pub fun replicatestd/core/list/replicate: forall<a> (x : a, n : int) -> list<a>( xx: $2733 : aa: V, nn: int : intstd/core/types/int: V )result: -> total list<2781> : liststd/core/types/list: V -> V<aa: V>
  if nn: int >std/core/int/(>): (x : int, y : int) -> bool 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
   then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2733, replicatestd/core/list/replicate: (x : $2733, n : int) -> list<$2733>(xx: $2733,pretend-decreasingstd/core/undiv/pretend-decreasing: (x : int) -> int(nn: int.decstd/core/int/dec: (i : int) -> int)))
   else Nilstd/core/types/Nil: forall<a> list<a>

// split a list at position `n`
pub fun splitstd/core/list/split: forall<a> (xs : list<a>, n : int) -> (list<a>, list<a>)( xsxs: list<$1357> : liststd/core/types/list: V -> V<aa: V>, nn: int : intstd/core/types/int: V )result: -> total (list<1392>, list<1392>) : (std/core/types/tuple2: (V, V) -> Vliststd/core/types/list: V -> V<aa: V>, liststd/core/types/list: V -> V<aa: V>)
  (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)xsxs: list<$1357>.takestd/core/list/take: (xs : list<$1357>, n : int) -> list<$1357>(nn: int), xsxs: list<$1357>.dropstd/core/list/drop: (xs : list<$1357>, n : int) -> list<$1357>(nn: int))std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)

pub fun spanstd/core/list/span: forall<a,e> (xs : list<a>, predicate : (a) -> e bool) -> e (list<a>, list<a>)( xsxs: list<$5052> : liststd/core/types/list: V -> V<aa: V>, predicatepredicate: ($5052) -> $5053 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 5195 (list<5194>, list<5194>) : ee: E (std/core/types/tuple2: (V, V) -> Vliststd/core/types/list: V -> V<aa: V>,liststd/core/types/list: V -> V<aa: V>)
  fun span-accspan-acc: forall<a> (ys : list<$5052>, acc : cctx<a,list<$5052>>) -> $5053 (a, list<$5052>)( ysys: list<$5052>, accacc: cctx<_5108,list<$5052>> )result: -> $5053 (_5108, list<$5052>)
    match ysys: list<$5052>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5052,yyyy: list<$5052>) -> if yy: $5052.predicatepredicate: ($5052) -> $5053 bool then yyyy: list<$5052>.span-accspan-acc: (ys : list<$5052>, acc : cctx<_5108,list<$5052>>) -> $5053 (_5108, list<$5052>)(accacc: cctx<_5108,list<$5052>> ++std/core/types/cctx/(++): (c1 : cctx<_5108,list<$5052>>, c2 : cctx<list<$5052>,list<$5052>>) -> $5053 cctx<_5108,list<$5052>> ctxctx: cctx<list<$5052>,list<$5052>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5052, holehole: list<$5052>)) else (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)accacc: cctx<_5108,list<$5052>> ++.std/core/types/cctx/(++.): (c : cctx<_5108,list<$5052>>, x : list<$5052>) -> $5053 _5108 [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>,ysys: list<$5052>)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)
      _ -> (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)accacc: cctx<_5108,list<$5052>> ++.std/core/types/cctx/(++.): (c : cctx<_5108,list<$5052>>, x : list<$5052>) -> $5053 _5108 [std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>, ysys: list<$5052>)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)
  xsxs: list<$5052>.span-accspan-acc: (ys : list<$5052>, acc : cctx<list<$5052>,list<$5052>>) -> $5053 (list<$5052>, list<$5052>)( ctxctx: ctx<list<$5052>> holehole: list<$5052> )

// Keep only those initial elements that satisfy `predicate`
pub fun take-whilestd/core/list/take-while: forall<a,e> (xs : list<a>, predicate : (a) -> e bool) -> e list<a>( xsxs: list<$5202> : liststd/core/types/list: V -> V<aa: V>, predicatepredicate: ($5202) -> $5203 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 5254 list<5253> : ee: E liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$5202>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5202,xxxx: list<$5202>) -> if xx: $5202.predicatepredicate: ($5202) -> $5203 bool then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5202, xxxx: list<$5202>.take-whilestd/core/list/take-while: (xs : list<$5202>, predicate : ($5202) -> $5203 bool) -> $5203 list<$5202>(predicatepredicate: ($5202) -> $5203 bool) ) else Nilstd/core/types/Nil: forall<a> list<a>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Drop all initial elements that satisfy `predicate`
pub fun drop-whilestd/core/list/drop-while: forall<a,e> (xs : list<a>, predicate : (a) -> e bool) -> e list<a>( xsxs: list<$1397> : liststd/core/types/list: V -> V<aa: V>, predicatepredicate: ($1397) -> $1398 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 1439 list<1438> : ee: E liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$1397>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1397,xxxx: list<$1397>) -> if xx: $1397.predicatepredicate: ($1397) -> $1398 bool then xxxx: list<$1397>.drop-whilestd/core/list/drop-while: (xs : list<$1397>, predicate : ($1397) -> $1398 bool) -> $1398 list<$1397>(predicatepredicate: ($1397) -> $1398 bool) else xsxs: list<$1397>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Retain only those elements of a list that satisfy the given predicate `pred`.
// For example: `filter([1,2,3],odd?) == [1,3]`
pub fun filterstd/core/list/filter: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e list<a>( xsxs: list<$1446> : liststd/core/types/list: V -> V<aa: V>, predpred: ($1446) -> $1447 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 1505 list<1504> : ee: E liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$1446>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1446,xxxx: list<$1446>) -> if predpred: ($1446) -> $1447 bool(xx: $1446) then Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1446,xxxx: list<$1446>.filterstd/core/list/filter: (xs : list<$1446>, pred : ($1446) -> $1447 bool) -> $1447 list<$1446>(predpred: ($1446) -> $1447 bool)) else xxxx: list<$1446>.filterstd/core/list/filter: (xs : list<$1446>, pred : ($1446) -> $1447 bool) -> $1447 list<$1446>(predpred: ($1446) -> $1447 bool)
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Remove those elements of a list that satisfy the given predicate `pred`.
// For example: `remove([1,2,3],odd?) == [2]`
pub fun removestd/core/list/remove: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e list<a>( xsxs: list<$2786> : liststd/core/types/list: V -> V<aa: V>, predpred: ($2786) -> $2787 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 2822 list<2821> : ee: E liststd/core/types/list: V -> V<aa: V>
  xsxs: list<$2786>.filterstd/core/list/filter: (xs : list<$2786>, pred : ($2786) -> $2787 bool) -> $2787 list<$2786>( fnfn: (x : $2786) -> $2787 bool(xx: $2786) !std/core/types/bool/(!): (b : bool) -> $2787 boolpredpred: ($2786) -> $2787 bool(xx: $2786) )

// Partition a list in two lists where the first list contains
// those elements that satisfy the given predicate `pred`.
// For example: `partition([1,2,3],odd?) == ([1,3],[2])`
pub fun partitionstd/core/list/partition: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e (list<a>, list<a>)( xsxs: list<$2992> : liststd/core/types/list: V -> V<aa: V>, ^predpred: ($2992) -> $2993 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 3032 (list<3031>, list<3031>) : ee: E (std/core/types/tuple2: (V, V) -> Vliststd/core/types/list: V -> V<aa: V>,liststd/core/types/list: V -> V<aa: V>)
  partition-accstd/core/list/partition-acc: (xs : list<$2992>, pred : ($2992) -> $2993 bool, acc1 : ctx<list<$2992>>, acc2 : ctx<list<$2992>>) -> $2993 (list<$2992>, list<$2992>)(xsxs: list<$2992>, predpred: ($2992) -> $2993 bool, ctxctx: ctx<list<$2992>> holehole: list<$2992>, ctxctx: ctx<list<$2992>> holehole: list<$2992>)

fun partition-accstd/core/list/partition-acc: forall<a,e> (xs : list<a>, pred : (a) -> e bool, acc1 : ctx<list<a>>, acc2 : ctx<list<a>>) -> e (list<a>, list<a>)(xsxs: list<$2829> : liststd/core/types/list: V -> V<aa: V>, ^predpred: ($2829) -> $2830 bool : aa: V -> ee: E boolstd/core/types/bool: V, acc1acc1: ctx<list<$2829>> : ctxstd/core/types/ctx: V -> V<liststd/core/types/list: V -> V<aa: V>>, acc2acc2: ctx<list<$2829>> : ctxstd/core/types/ctx: V -> V<liststd/core/types/list: V -> V<aa: V>>)result: -> 2985 (list<2984>, list<2984>): ee: E (std/core/types/tuple2: (V, V) -> Vliststd/core/types/list: V -> V<aa: V>, liststd/core/types/list: V -> V<aa: V>)
  match xsxs: list<$2829>
    Nilstd/core/types/Nil: forall<a> list<a> -> (std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)acc1acc1: ctx<list<$2829>> ++.std/core/types/cctx/(++.): (c : cctx<list<$2829>,list<$2829>>, x : list<$2829>) -> $2830 list<$2829> Nilstd/core/types/Nil: forall<a> list<a>, acc2acc2: ctx<list<$2829>> ++.std/core/types/cctx/(++.): (c : cctx<list<$2829>,list<$2829>>, x : list<$2829>) -> $2830 list<$2829> Nilstd/core/types/Nil: forall<a> list<a>)std/core/types/Tuple2: forall<a,b> (fst : a, snd : b) -> (a, b)
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2829,xxxx: list<$2829>) -> if predpred: ($2829) -> $2830 bool(xx: $2829)
      then partition-accstd/core/list/partition-acc: (xs : list<$2829>, pred : ($2829) -> $2830 bool, acc1 : ctx<list<$2829>>, acc2 : ctx<list<$2829>>) -> $2830 (list<$2829>, list<$2829>)(xxxx: list<$2829>,predpred: ($2829) -> $2830 bool,acc1acc1: ctx<list<$2829>> ++std/core/types/cctx/(++): (c1 : cctx<list<$2829>,list<$2829>>, c2 : cctx<list<$2829>,list<$2829>>) -> $2830 cctx<list<$2829>,list<$2829>> ctxctx: cctx<list<$2829>,list<$2829>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2829,holehole: list<$2829>),acc2acc2: ctx<list<$2829>>)
      else partition-accstd/core/list/partition-acc: (xs : list<$2829>, pred : ($2829) -> $2830 bool, acc1 : ctx<list<$2829>>, acc2 : ctx<list<$2829>>) -> $2830 (list<$2829>, list<$2829>)(xxxx: list<$2829>,predpred: ($2829) -> $2830 bool,acc1acc1: ctx<list<$2829>>,acc2acc2: ctx<list<$2829>> ++std/core/types/cctx/(++): (c1 : cctx<list<$2829>,list<$2829>>, c2 : cctx<list<$2829>,list<$2829>>) -> $2830 cctx<list<$2829>,list<$2829>> ctxctx: cctx<list<$2829>,list<$2829>> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $2829,holehole: list<$2829>))

// Retain only those elements of a list that satisfy the given predicate `pred`.
// For example: `filterMap([1,2,3],fn(i) { if i.odd? then Nothing else Just(i*i) }) == [4]`
pub fun filter-mapstd/core/list/filter-map: forall<a,b,e> (xs : list<a>, pred : (a) -> e maybe<b>) -> e list<b>( xsxs: list<$1512> : liststd/core/types/list: V -> V<aa: V>, predpred: ($1512) -> $1514 maybe<$1513> : aa: V -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 1589 list<1588> : ee: E liststd/core/types/list: V -> V<bb: V>
  match xsxs: list<$1512>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1512,xxxx: list<$1512>) -> match predpred: ($1512) -> $1514 maybe<$1513>(xx: $1512)
      Nothingstd/core/types/Nothing: forall<a> maybe<a> -> xxxx: list<$1512>.filter-mapstd/core/list/filter-map: (xs : list<$1512>, pred : ($1512) -> $1514 maybe<$1513>) -> $1514 list<$1513>(predpred: ($1512) -> $1514 maybe<$1513>)
      Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(yy: $1513) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $1513,xxxx: list<$1512>.filter-mapstd/core/list/filter-map: (xs : list<$1512>, pred : ($1512) -> $1514 maybe<$1513>) -> $1514 list<$1513>(predpred: ($1512) -> $1514 maybe<$1513>))

// Find the first element satisfying some predicate
pub fun findstd/core/list/find: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e maybe<a>( xsxs: list<$1679> : liststd/core/types/list: V -> V<aa: V>, predpred: ($1679) -> $1680 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 1731 maybe<1730> : ee: E maybestd/core/types/maybe: V -> V<aa: V>
  xsxs: list<$1679>.foreach-whilestd/core/list/foreach-while: (xs : list<$1679>, action : ($1679) -> $1680 maybe<$1679>) -> $1680 maybe<$1679> fnfn: (x : $1679) -> $1680 maybe<$1679>(xx: $1679)
    if predpred: ($1679) -> $1680 bool(xx: $1679) then Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $1679) else Nothingstd/core/types/Nothing: forall<a> maybe<a>

// Find the first element satisfying some predicate and return it.
pub fun find-maybestd/core/list/find-maybe: forall<a,b,e> (xs : list<a>, pred : (a) -> e maybe<b>) -> e maybe<b>( xsxs: list<$1738> : liststd/core/types/list: V -> V<aa: V>, predpred: ($1738) -> $1740 maybe<$1739> : aa: V -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 1779 maybe<1778> : ee: E maybestd/core/types/maybe: V -> V<bb: V>
  xsxs: list<$1738>.foreach-whilestd/core/list/foreach-while: (xs : list<$1738>, action : ($1738) -> $1740 maybe<$1739>) -> $1740 maybe<$1739>(predpred: ($1738) -> $1740 maybe<$1739>)

// Lookup the first element satisfying some predicate
pub fun lookupstd/core/list/lookup: forall<a,b,e> (xs : list<(a, b)>, pred : (a) -> e bool) -> e maybe<b>( xsxs: list<($3039, $3040)> : liststd/core/types/list: V -> V<(std/core/types/tuple2: (V, V) -> Vaa: V,bb: V)>, predpred: ($3039) -> $3041 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 3169 maybe<3168> : ee: E maybestd/core/types/maybe: V -> V<bb: V>
  xsxs: list<($3039, $3040)>.foreach-whilestd/core/list/foreach-while: (xs : list<($3039, $3040)>, action : (($3039, $3040)) -> $3041 maybe<$3040>) -> $3041 maybe<$3040> fnfn: (kv : ($3039, $3040)) -> $3041 maybe<$3040>(kvkv: ($3039, $3040))
    if predpred: ($3039) -> $3041 bool(kvkv: ($3039, $3040).fststd/core/types/tuple2/fst: (tuple2 : ($3039, $3040)) -> $3041 $3039) then Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(kvkv: ($3039, $3040).sndstd/core/types/tuple2/snd: (tuple2 : ($3039, $3040)) -> $3041 $3040) else Nothingstd/core/types/Nothing: forall<a> maybe<a>


// Convert a `:maybe` type to a list type.
pub fun maybe/liststd/core/list/maybe/list: forall<a> (m : maybe<a>) -> list<a>( mm: maybe<$1789> : maybestd/core/types/maybe: V -> V<aa: V> )result: -> total list<1820> : liststd/core/types/list: V -> V<aa: V>
  match mm: maybe<$1789>
    Nothingstd/core/types/Nothing: forall<a> maybe<a> -> Nilstd/core/types/Nil: forall<a> list<a>
    Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $1789) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1789,Nilstd/core/types/Nil: forall<a> list<a>)

fun index-of-accstd/core/list/index-of-acc: forall<a,e> (xs : list<a>, pred : (a) -> e bool, idx : int) -> e int( xsxs: list<$3179> : liststd/core/types/list: V -> V<aa: V>, predpred: ($3179) -> $3180 bool : aa: V -> ee: E boolstd/core/types/bool: V, idxidx: int : intstd/core/types/int: V )result: -> 3225 int : ee: E intstd/core/types/int: V
  match xsxs: list<$3179>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3179,xxxx: list<$3179>) -> if predpred: ($3179) -> $3180 bool(xx: $3179) then idxidx: int else index-of-accstd/core/list/index-of-acc: (xs : list<$3179>, pred : ($3179) -> $3180 bool, idx : int) -> $3180 int(xxxx: list<$3179>,predpred: ($3179) -> $3180 bool,idxidx: int+std/core/int/(+): (x : int, y : int) -> $3180 int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001)
    Nilstd/core/types/Nil: forall<a> list<a>        -> -1literal: int
dec  = -1
hex8 = 0xFF
bit8 = 0b11111111


// Returns the index of the first element where `pred` holds, or `-1` if no such element exists.
pub fun index-ofstd/core/list/index-of: forall<a,e> (xs : list<a>, pred : (a) -> e bool) -> e int( xsxs: list<$3232> : liststd/core/types/list: V -> V<aa: V>, predpred: ($3232) -> $3233 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 3255 int : ee: E intstd/core/types/int: V
  index-of-accstd/core/list/index-of-acc: (xs : list<$3232>, pred : ($3232) -> $3233 bool, idx : int) -> $3233 int( xsxs: list<$3232>, predpred: ($3232) -> $3233 bool, 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 )

// Invoke `action` for each element of a list
pub fun foreachstd/core/list/foreach: forall<a,e> (xs : list<a>, action : (a) -> e ()) -> e ()( xsxs: list<$3262> : liststd/core/types/list: V -> V<aa: V>, actionaction: ($3262) -> $3263 () : (aa: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 3305 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  match xsxs: list<$3262>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3262,xxxx: list<$3262>) -> { actionaction: ($3262) -> $3263 ()(xx: $3262); xxxx: list<$3262>.foreachstd/core/list/foreach: (xs : list<$3262>, action : ($3262) -> $3263 ()) -> $3263 ()(actionaction: ($3262) -> $3263 ()) }
    Nilstd/core/types/Nil: forall<a> list<a>        -> (std/core/types/Unit: ())std/core/types/Unit: ()

// Invoke `action` for each element of a list while `action` return `Nothing`
pub fun foreach-whilestd/core/list/foreach-while: forall<a,b,e> (xs : list<a>, action : (a) -> e maybe<b>) -> e maybe<b>( xsxs: list<$1599> : liststd/core/types/list: V -> V<aa: V>, actionaction: ($1599) -> $1601 maybe<$1600> : (aa: V) -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 1663 maybe<1662> : ee: E maybestd/core/types/maybe: V -> V<bb: V>
  match xsxs: list<$1599>
    Nilstd/core/types/Nil: forall<a> list<a>        -> Nothingstd/core/types/Nothing: forall<a> maybe<a>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $1599,xxxx: list<$1599>) ->
      match actionaction: ($1599) -> $1601 maybe<$1600>(xx: $1599)
        Nothingstd/core/types/Nothing: forall<a> maybe<a> -> xxxx: list<$1599>.foreach-whilestd/core/list/foreach-while: (xs : list<$1599>, action : ($1599) -> $1601 maybe<$1600>) -> $1601 maybe<$1600>(actionaction: ($1599) -> $1601 maybe<$1600>)
        justjust: maybe<$1600>    -> justjust: maybe<$1600>

// Invoke `action` on each element of a list while `action` returns `Just`
pub fun map-whilestd/core/list/map-while: forall<a,b,e> (xs : list<a>, action : (a) -> e maybe<b>) -> e list<b>( xsxs: list<$3316> : liststd/core/types/list: V -> V<aa: V>, actionaction: ($3316) -> $3318 maybe<$3317> : (aa: V) -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 3383 list<3382> : ee: E liststd/core/types/list: V -> V<bb: V>
  match xsxs: list<$3316>
    Nilstd/core/types/Nil: forall<a> list<a>        -> Nilstd/core/types/Nil: forall<a> list<a>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3316,xxxx: list<$3316>) ->
      match actionaction: ($3316) -> $3318 maybe<$3317>(xx: $3316)
        Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(yy: $3317) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $3317,xxxx: list<$3316>.map-whilestd/core/list/map-while: (xs : list<$3316>, action : ($3316) -> $3318 maybe<$3317>) -> $3318 list<$3317>(actionaction: ($3316) -> $3318 maybe<$3317>))
        Nothingstd/core/types/Nothing: forall<a> maybe<a> -> Nilstd/core/types/Nil: forall<a> list<a>


// Invoke `action` for each element of a list, passing also the position of the element.
pub fun foreach-indexedstd/core/list/foreach-indexed: forall<a,e> (xs : list<a>, action : (int, a) -> e ()) -> e ()( xsxs: list<$3393> : liststd/core/types/list: V -> V<aa: V>, actionaction: (int, $3393) -> $3394 () : (intstd/core/types/int: V,aa: V) -> ee: E (std/core/types/unit: V)std/core/types/unit: V )result: -> 3521 () : ee: E (std/core/types/unit: V)std/core/types/unit: V
  var ii: local-var<$3404,int> := 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000
  xsxs: list<$3393>.foreachstd/core/list/foreach: (xs : list<$3393>, action : ($3393) -> <local<$3404>|$3394> ()) -> <local<$3404>|$3394> () fnfn: (x : $3393) -> <local<$3404>|$3394> ()(xx: $3393)
    val jj: int = ii: int
?hdiv=iev@3439 // don't dereference `i` inside the inject
    actionaction: (int, $3393) -> $3394 ()(jj: int,xx: $3393)
    ii: local-var<$3404,int> :=std/core/types/local-set: (v : local-var<$3404,int>, assigned : int) -> <local<$3404>|$3394> () ii: int
?hdiv=iev@3491+std/core/int/(+): (x : int, y : int) -> <local<$3404>|$3394> int1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001

// Insert a separator `sep`  between all elements of a list `xs` .
pub fun interspersestd/core/list/intersperse: forall<a> (xs : list<a>, sep : a) -> list<a>( xsxs: list<$3528> : liststd/core/types/list: V -> V<aa: V>, sepsep: $3528 : aa: V )result: -> total list<3597> : liststd/core/types/list: V -> V<aa: V>
  fun beforebefore: (ys : list<$3528>) -> list<$3528>(ysys: list<$3528>)result: -> total list<$3528>
    match ysys: list<$3528>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $3528,yyyy: list<$3528>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(sepsep: $3528,Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $3528,beforebefore: (ys : list<$3528>) -> list<$3528>(yyyy: list<$3528>)))
      Nilstd/core/types/Nil: forall<a> list<a>        -> Nilstd/core/types/Nil: forall<a> list<a>
  match xsxs: list<$3528>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3528,xxxx: list<$3528>)  -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $3528, xxxx: list<$3528>.beforebefore: (ys : list<$3528>) -> list<$3528>)
    Nilstd/core/types/Nil: forall<a> list<a>         -> Nilstd/core/types/Nil: forall<a> list<a>

// Concatenate all strings in a list
fun joinsepstd/core/list/joinsep: (xs : list<string>, sep : string) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V>, sepsep: string : stringstd/core/types/string: V )result: -> total string : stringstd/core/types/string: V
  match xsxs: list<string>
    Nilstd/core/types/Nil: forall<a> list<a>                 -> ""literal: string
count= 0
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: string,Nilstd/core/types/Nil: forall<a> list<a>)         -> xx: string
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: string,Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: string,Nilstd/core/types/Nil: forall<a> list<a>)) | sepsep: string.is-emptystd/core/string/is-empty: (s : string) -> bool -> xx: string ++std/core/types/(++): (x : string, y : string) -> string yy: string
    _                   -> xsxs: list<string>.vectorstd/core/vector/list/vector: (xs : list<string>) -> vector<string>.joinstd/core/string/vectorsep/join: (v : vector<string>, sep : string) -> string(sepsep: string)

// Concatenate all strings in a list
pub fun concat/joinstd/core/list/concat/join: (xs : list<string>) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V> )result: -> total string : stringstd/core/types/string: V
  match xsxs: list<string>
    Nilstd/core/types/Nil: forall<a> list<a>                 -> ""literal: string
count= 0
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: string,Nilstd/core/types/Nil: forall<a> list<a>)         -> xx: string
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: string,Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: string,Nilstd/core/types/Nil: forall<a> list<a>)) -> xx: string ++std/core/types/(++): (x : string, y : string) -> string yy: string
    _                   -> xsxs: list<string>.vectorstd/core/vector/list/vector: (xs : list<string>) -> vector<string>.joinstd/core/string/vector/join: (v : vector<string>) -> string()

// Concatenate all strings in a list using a specific separator
pub fun joinsep/joinstd/core/list/joinsep/join: (xs : list<string>, sep : string) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V>, sepsep: string : stringstd/core/types/string: V )result: -> total string : stringstd/core/types/string: V
  xsxs: list<string>.joinsepstd/core/list/joinsep: (xs : list<string>, sep : string) -> string(sepsep: string)

// Concatenate all strings in a list in reverse order
pub fun reverse-joinstd/core/list/reverse-join: (xs : list<string>) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V> )result: -> total string : stringstd/core/types/string: V
  xsxs: list<string>.reversestd/core/list/reverse: (xs : list<string>) -> list<string>.joinstd/core/list/concat/join: (xs : list<string>) -> string

// Append `end` to each string in the list `xs` and join them all together.\
// `join-end([],end) === ""`\
// `join-end(["a","b"],"/") === "a/b/"`
pub fun join-endstd/core/list/join-end: (xs : list<string>, end : string) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V>, endend: string : stringstd/core/types/string: V)result: -> total string : stringstd/core/types/string: V
  match xsxs: list<string>
    Nilstd/core/types/Nil: forall<a> list<a> -> ""literal: string
count= 0
    _   -> xsxs: list<string>.joinsepstd/core/list/joinsep: (xs : list<string>, sep : string) -> string(endend: string) ++std/core/types/(++): (x : string, y : string) -> string endend: string

// Concatenate all lists in a list (e.g. flatten the list). (tail-recursive)
pub fun concatstd/core/list/concat: forall<a> (xss : list<list<a>>) -> list<a>( xssxss: list<list<$5302>> : liststd/core/types/list: V -> V<liststd/core/types/list: V -> V<aa: V>> )result: -> total list<5381> : liststd/core/types/list: V -> V<aa: V>
  fun concat-preconcat-pre: forall<a> (ys : list<a>, zss : list<list<a>>) -> list<a>( ysys: list<$5303> : liststd/core/types/list: V -> V<aa: V>, zsszss: list<list<$5303>> : liststd/core/types/list: V -> V<liststd/core/types/list: V -> V<aa: V>> )result: -> total list<5359> : liststd/core/types/list: V -> V<aa: V>
    match ysys: list<$5303>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5303,yyyy: list<$5303>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5303,concat-preconcat-pre: (ys : list<$5303>, zss : list<list<$5303>>) -> list<$5303>(yyyy: list<$5303>,zsszss: list<list<$5303>>))
      Nilstd/core/types/Nil: forall<a> list<a> -> match zsszss: list<list<$5303>>
        Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zszs: list<$5303>,zzszzs: list<list<$5303>>) -> concat-preconcat-pre: (ys : list<$5303>, zss : list<list<$5303>>) -> list<$5303>(zszs: list<$5303>,zzszzs: list<list<$5303>>)
        Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
  concat-preconcat-pre: (ys : list<$5302>, zss : list<list<$5302>>) -> list<$5302>([std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>,xssxss: list<list<$5302>>)

// Concatenate the result lists from applying a function to all elements.
pub fun flatmapstd/core/list/flatmap: forall<a,b,e> (xs : list<a>, f : (a) -> e list<b>) -> e list<b>( xsxs: list<$5386>: liststd/core/types/list: V -> V<aa: V>, ff: ($5386) -> $5388 list<$5387> : aa: V -> ee: E liststd/core/types/list: V -> V<bb: V> )result: -> 5456 list<5455> : ee: E liststd/core/types/list: V -> V<bb: V>
  fun flatmap-preflatmap-pre: (ys : list<$5387>, zs : list<$5386>) -> $5388 list<$5387>( ysys: list<$5387>, zszs: list<$5386> )result: -> $5388 list<$5387>
    match ysys: list<$5387>
      Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5387,yyyy: list<$5387>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5387,flatmap-preflatmap-pre: (ys : list<$5387>, zs : list<$5386>) -> $5388 list<$5387>(yyyy: list<$5387>,zszs: list<$5386>))
      Nilstd/core/types/Nil: forall<a> list<a> -> match zszs: list<$5386>
        Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(zz: $5386,zzzz: list<$5386>) -> flatmap-preflatmap-pre: (ys : list<$5387>, zs : list<$5386>) -> $5388 list<$5387>(ff: ($5386) -> $5388 list<$5387>(zz: $5386),zzzz: list<$5386>)
        Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>
  flatmap-preflatmap-pre: (ys : list<$5387>, zs : list<$5386>) -> $5388 list<$5387>([std/core/types/Nil: forall<a> list<a>]std/core/types/Nil: forall<a> list<a>,xsxs: list<$5386>)

// Concatenate the `Just` result elements from applying a function to all elements.
pub fun flatmap-maybestd/core/list/flatmap-maybe: forall<a,b,e> (xs : list<a>, f : (a) -> e maybe<b>) -> e list<b>( xsxs: list<$5466> : liststd/core/types/list: V -> V<aa: V>, ff: ($5466) -> $5468 maybe<$5467> : aa: V -> ee: E maybestd/core/types/maybe: V -> V<bb: V> )result: -> 5543 list<5542> : ee: E liststd/core/types/list: V -> V<bb: V>
  match xsxs: list<$5466>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5466,xxxx: list<$5466>) -> match ff: ($5466) -> $5468 maybe<$5467>(xx: $5466)
      Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(yy: $5467) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5467, xxxx: list<$5466>.flatmap-maybestd/core/list/flatmap-maybe: (xs : list<$5466>, f : ($5466) -> $5468 maybe<$5467>) -> $5468 list<$5467>(ff: ($5466) -> $5468 maybe<$5467>))
      Nothingstd/core/types/Nothing: forall<a> maybe<a> -> xxxx: list<$5466>.flatmap-maybestd/core/list/flatmap-maybe: (xs : list<$5466>, f : ($5466) -> $5468 maybe<$5467>) -> $5468 list<$5467>(ff: ($5466) -> $5468 maybe<$5467>)
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Concatenate a list of `:maybe` values
pub fun concat-maybestd/core/list/concat-maybe: forall<a> (xs : list<maybe<a>>) -> list<a>( xsxs: list<maybe<$5553>> : liststd/core/types/list: V -> V<maybestd/core/types/maybe: V -> V<aa: V>> )result: -> total list<5607> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<maybe<$5553>>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: maybe<$5553>,xxxx: list<maybe<$5553>>) -> match xx: maybe<$5553>
      Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(yy: $5553) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(yy: $5553, xxxx: list<maybe<$5553>>.concat-maybestd/core/list/concat-maybe: (xs : list<maybe<$5553>>) -> list<$5553>)
      Nothingstd/core/types/Nothing: forall<a> maybe<a> -> xxxx: list<maybe<$5553>>.concat-maybestd/core/list/concat-maybe: (xs : list<maybe<$5553>>) -> list<$5553>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nilstd/core/types/Nil: forall<a> list<a>

// Return the last element of a list (or `Nothing` for the empty list)
pub fun laststd/core/list/last: forall<a> (xs : list<a>) -> maybe<a>( xsxs: list<$5612> : liststd/core/types/list: V -> V<aa: V> )result: -> total maybe<5655> : maybestd/core/types/maybe: V -> V<aa: V>
  match xsxs: list<$5612>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5612,Nilstd/core/types/Nil: forall<a> list<a>) -> Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $5612)
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(_,xxxx: list<$5612>)  -> laststd/core/list/last: (xs : list<$5612>) -> maybe<$5612>(xxxx: list<$5612>)
    Nilstd/core/types/Nil: forall<a> list<a>         -> Nothingstd/core/types/Nothing: forall<a> maybe<a>

// Return the list without its last element.
// Return an empty list for an empty list.
pub fun initstd/core/list/init: forall<a> (xs : list<a>) -> list<a>( xsxs: list<$5660> : liststd/core/types/list: V -> V<aa: V> )result: -> total list<5698> : liststd/core/types/list: V -> V<aa: V>
  match xsxs: list<$5660>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5660, xxxx: list<$5660> as Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>) -> Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5660,initstd/core/list/init: (xs : list<$5660>) -> list<$5660>(xxxx: list<$5660>))
    _ -> Nilstd/core/types/Nil: forall<a> list<a>

// Get (zero-based) element `n`  of a list. Return a `:maybe` type.
pub fun @index( xsxs: list<$5703> : liststd/core/types/list: V -> V<aa: V>, nn: int : intstd/core/types/int: V )result: -> total maybe<5784> : maybestd/core/types/maybe: V -> V<aa: V>
  match xsxs: list<$5703>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5703,xxxx: list<$5703>) -> if nn: int>std/core/int/(>): (x : int, y : int) -> bool0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 then xxxx: list<$5703>[nn: int -std/core/int/(-): (x : int, y : int) -> int 1literal: int
dec  = 1
hex8 = 0x01
bit8 = 0b00000001]   // == @index(xx,n-1)
                  elif nn: int==std/core/int/(==): (x : int, y : int) -> bool0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 then Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(xx: $5703)
                  else Nothingstd/core/types/Nothing: forall<a> maybe<a>
    Nilstd/core/types/Nil: forall<a> list<a> -> Nothingstd/core/types/Nothing: forall<a> maybe<a>

// Do all elements satisfy a predicate ?
pub fun allstd/core/list/all: forall<a,e> (xs : list<a>, predicate : (a) -> e bool) -> e bool( xsxs: list<$5796> : liststd/core/types/list: V -> V<aa: V>, predicatepredicate: ($5796) -> $5797 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 5836 bool : ee: E boolstd/core/types/bool: V
  match xsxs: list<$5796>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5796,xxxx: list<$5796>) -> if predicatepredicate: ($5796) -> $5797 bool(xx: $5796) then xxxx: list<$5796>.allstd/core/list/all: (xs : list<$5796>, predicate : ($5796) -> $5797 bool) -> $5797 bool(predicatepredicate: ($5796) -> $5797 bool) else Falsestd/core/types/False: bool
    Nilstd/core/types/Nil: forall<a> list<a> -> Truestd/core/types/True: bool

// Are there any elements in a list that satisfy a predicate ?
pub fun anystd/core/list/any: forall<a,e> (xs : list<a>, predicate : (a) -> e bool) -> e bool( xsxs: list<$5843> : liststd/core/types/list: V -> V<aa: V>, predicatepredicate: ($5843) -> $5844 bool : aa: V -> ee: E boolstd/core/types/bool: V )result: -> 5883 bool : ee: E boolstd/core/types/bool: V
  match xsxs: list<$5843>
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: $5843,xxxx: list<$5843>) -> if predicatepredicate: ($5843) -> $5844 bool(xx: $5843) then Truestd/core/types/True: bool else xxxx: list<$5843>.anystd/core/list/any: (xs : list<$5843>, predicate : ($5843) -> $5844 bool) -> $5844 bool(predicatepredicate: ($5843) -> $5844 bool)
    Nilstd/core/types/Nil: forall<a> list<a> -> Falsestd/core/types/False: bool

// Return the sum of a list of integers
pub fun sumstd/core/list/sum: (xs : list<int>) -> int( xsxs: list<int> : liststd/core/types/list: V -> V<intstd/core/types/int: V> )result: -> total int : intstd/core/types/int: V
  xsxs: list<int>.foldlstd/core/list/foldl: (xs : list<int>, z : int, f : (int, int) -> int) -> int( 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000, fnfn: (x : int, y : int) -> int(xx: int,yy: int) { xx: int +std/core/int/(+): (x : int, y : int) -> int yy: int } )

// Returns the smallest element of a list of integers (or `default` (=`0`) for the empty list)
pub fun minimumstd/core/list/minimum: (xs : list<int>, default : ? int) -> int( xsxs: list<int> : liststd/core/types/list: V -> V<intstd/core/types/int: V>, defaultdefault: ? int : intstd/core/types/int: V = 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 )result: -> total int : intstd/core/types/int: V
  match xsxs: list<int>
    Nilstd/core/types/Nil: forall<a> list<a> -> defaultdefault: int
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: int,xxxx: list<int>) -> xxxx: list<int>.foldlstd/core/list/foldl: (xs : list<int>, z : int, f : (int, int) -> int) -> int( xx: int, minstd/core/int/min: (i : int, j : int) -> int )

// Returns the largest element of a list of integers (or `default` (=`0`) for the empty list)
pub fun maximumstd/core/list/maximum: (xs : list<int>, default : ? int) -> int( xsxs: list<int> : liststd/core/types/list: V -> V<intstd/core/types/int: V>, defaultdefault: ? int : intstd/core/types/int: V = 0literal: int
dec  = 0
hex8 = 0x00
bit8 = 0b00000000 )result: -> total int : intstd/core/types/int: V
  match xsxs: list<int>
    Nilstd/core/types/Nil: forall<a> list<a> -> defaultdefault: int
    Consstd/core/types/Cons: forall<a> (head : a, tail : list<a>) -> list<a>(xx: int,xxxx: list<int>) -> xxxx: list<int>.foldlstd/core/list/foldl: (xs : list<int>, z : int, f : (int, int) -> int) -> int( xx: int, maxstd/core/int/max: (i : int, j : int) -> int )


// Split a string into a list of lines
pub fun linesstd/core/list/lines: (s : string) -> list<string>( ss: string : stringstd/core/types/string: V )result: -> total list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V>
  ss: string.splitstd/core/string/sep/split: (s : string, sep : string) -> list<string>("\n"literal: string
count= 1)

// Join a list of strings with newlines
pub fun unlinesstd/core/list/unlines: (xs : list<string>) -> string( xsxs: list<string> : liststd/core/types/list: V -> V<stringstd/core/types/string: V> )result: -> total string : stringstd/core/types/string: V
  xsxs: list<string>.joinstd/core/list/joinsep/join: (xs : list<string>, sep : string) -> string("\n"literal: string
count= 1)

// Apply a function `f` to each character in a string
pub fun string/mapstd/core/list/string/map: forall<e> (s : string, f : (char) -> e char) -> e string( ss: string : stringstd/core/types/string: V, ff: (char) -> $2120 char : charstd/core/types/char: V -> ee: E charstd/core/types/char: V )result: -> 2171 string : ee: E stringstd/core/types/string: V
  ss: string.liststd/core/string/list: (s : string) -> $2120 list<char>.mapstd/core/list/map: (xs : list<char>, f : (char) -> $2120 char) -> $2120 list<char>(ff: (char) -> $2120 char).stringstd/core/string/listchar/string: (cs : list<char>) -> $2120 string // todo: optimize