seq¶

In [ ]:
//// test

open testing

seq¶

seq¶

In [ ]:
type seq dim el = dim -> option el

try_item¶

In [ ]:
inl try_item n s =
    n |> s

from_list¶

In [ ]:
inl from_list list =
    fun n =>
        list
        |> listm'.try_item n
In [ ]:
//// test

listm.init 10i32 print_and_return
|> from_list
|> try_item 5i32
|> _assert_eq (Some 5i32)

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
print_and_return / x: 6
print_and_return / x: 7
print_and_return / x: 8
print_and_return / x: 9
__assert_eq / actual: US0_0 5 / expected: US0_0 5

map¶

In [ ]:
inl map fn s =
    fun n =>
        n
        |> s
        |> optionm.map fn
In [ ]:
//// test

listm.init 10i32 id
|> from_list
|> map ((*) 2)
|> try_item 5i32
|> _assert_eq (Some 10i32)

__assert_eq / actual: US0_0 10 / expected: US0_0 10

mapi¶

In [ ]:
inl mapi fn s =
    fun n =>
        n
        |> s
        |> optionm.map (fn n)
In [ ]:
//// test

listm.init 10i32 print_and_return
|> from_list
|> mapi fun i x => i + x
|> try_item 5i32
|> _assert_eq (Some 10i32)

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
print_and_return / x: 6
print_and_return / x: 7
print_and_return / x: 8
print_and_return / x: 9
__assert_eq / actual: US0_0 10 / expected: US0_0 10

choose¶

In [ ]:
inl choose forall dim {number} t u. (fn : t -> option u) (s : seq dim t) : seq dim u =
    fun n =>
        inl rec body fn s i i' =
            match i |> s with
            | None => None
            | Some x =>
                match x |> fn with
                | Some x when n = i' => Some x
                | Some _ => loop (i + 1) (i' + 1)
                | _ => loop (i + 1) i'
        and inl loop i i' =
            if n |> var_is |> not
            then body fn s i i'
            else
                inl fn = join fn
                inl s = join s
                join body fn s i i'
        loop 0 0
In [ ]:
//// test

listm.init 10i32 print_and_return
|> from_list
|> choose (fun x => if x % 2 = 0 then Some x else None)
|> try_item 1i32
|> _assert_eq (Some 2i32)

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
print_and_return / x: 6
print_and_return / x: 7
print_and_return / x: 8
print_and_return / x: 9
__assert_eq / actual: US0_0 2 / expected: US0_0 2

indexed¶

In [ ]:
inl indexed s =
    s
    |> mapi fun i x =>
        i, x
In [ ]:
//// test

listm.init 10i32 ((*) 2)
|> from_list
|> indexed
|> try_item 5i32
|> _assert_eq (Some (5i32, 10i32))

__assert_eq / actual: US0_0 (5, 10) / expected: US0_0 (5, 10)

zip¶

In [ ]:
inl zip n seq1 seq2 =
    seq1 n, seq2 n
In [ ]:
//// test

((listm.init 10i32 id |> from_list), (listm.init 10i32 ((*) 2) |> from_list))
||> zip 5i32
|> _assert_eq (Some 5, Some 10)

__assert_eq / actual: struct (US0_0 5, US0_0 10) / expected: struct (US0_0 5, US0_0 10)

zip_with¶

In [ ]:
inl zip_with fn seq1 seq2 =
    fun n =>
        fn (seq1 n) (seq2 n)
In [ ]:
//// test

((listm.init 10i32 id |> from_list), (listm.init 10i32 ((*) 2) |> from_list))
||> zip_with (optionm'.choose (+))
|> try_item 2i32
|> _assert_eq (Some 6)

__assert_eq / actual: US0_0 6 / expected: US0_0 6

fold¶

In [ ]:
inl fold fn init seq =
    inl rec loop acc n =
        match seq n with
        | Some x => loop (fn acc x) (n + 1)
        | None => acc
    loop init 0

inl fold_ fn init seq =
    let rec loop acc n =
        match seq n with
        | Some x => loop (fn acc x) (n + 1)
        | None => acc
    loop init 0

sum¶

In [ ]:
inl sum seq =
    seq |> fold (+) 0

inl sum_ seq =
    seq |> fold_ (+) 0
In [ ]:
//// test

listm.init 10i32 id
|> from_list
|> fun f (n : i32) => f n
|> sum
|> _assert_eq 45

__assert_eq / actual: 45 / expected: 45

to_list¶

In [ ]:
inl to_list seq =
    seq
    |> fold (fun acc x => x :: acc) []
    |> listm.rev

inl to_list_ seq =
    seq
    |> fold_ (fun acc x => x :: acc) []
    |> listm.rev
In [ ]:
//// test

listm.init 10i32 id
|> from_list
|> fun f (n : i32) => f n
|> to_list
|> _assert_eq (listm.init 10i32 id)

__assert_eq / actual: UH0_1
  (0,
   UH0_1
     (1,
      UH0_1
        (2,
         UH0_1
           (3,
            UH0_1
              (4, UH0_1 (5, UH0_1 (6, UH0_1 (7, UH0_1 (8, UH0_1 (9, UH0_0)))))))))) / expected: UH0_1
  (0,
   UH0_1
     (1,
      UH0_1
        (2,
         UH0_1
           (3,
            UH0_1
              (4, UH0_1 (5, UH0_1 (6, UH0_1 (7, UH0_1 (8, UH0_1 (9, UH0_0))))))))))

from_array¶

In [ ]:
inl from_array forall dim {number; int} el. (array : a dim el) : seq dim el =
    fun n =>
        if n >= length array
        then None
        else index array n |> Some
In [ ]:
//// test

a ;[ 1; 2; 3 ]
|> from_array
|> try_item 1i32
|> _assert_eq (Some 2i32)

__assert_eq / actual: US0_0 2 / expected: US0_0 2

to_array¶

In [ ]:
inl to_array seq =
    inl ar = a ;[] |> mut
    ((), seq)
    ||> fold fun _ x =>
        ar <- *ar ++ a ;[x]
    *ar

inl to_array_ seq =
    inl ar = a ;[] |> mut
    ((), seq)
    ||> fold_ fun _ x =>
        ar <- *ar ++ a ;[x]
    *ar
In [ ]:
//// test

listm.init 10i32 id
|> from_list
|> fun (x : i32 -> _) => x
|> to_array
|> _assert_eq (a ;[ 0; 1; 2; 3; 4; 5; 6; 7; 8; 9 ] : _ i32 _)

__assert_eq / actual: [|0; 1; 2; 3; 4; 5; 6; 7; 8; 9|] / expected: [|0; 1; 2; 3; 4; 5; 6; 7; 8; 9|]

take_while¶

In [ ]:
inl take_while cond seq =
    inl rec loop acc i =
        match seq i with
        | Some st when cond st i => loop (st :: acc) (i + 1)
        | _ => acc |> listm.rev
    loop [] 0
In [ ]:
//// test

listm.init 10i32 id
|> from_list
|> take_while (fun n (_ : i32) => n < 5)
|> listm'.sum
|> _assert_eq 10

__assert_eq / actual: 10 / expected: 10
In [ ]:
//// test

stream.new_finite_stream print_and_return 10i32
|> flip stream.try_item
|> take_while (fun n (_ : i32) => n < 5)
|> listm'.sum
|> _assert_eq 10

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
__assert_eq / actual: 10 / expected: 10

take_while_¶

In [ ]:
inl take_while_ cond seq =
    let rec loop acc i =
        match seq i with
        | Some st when cond st i => loop (st :: acc) (i + 1)
        | _ => acc |> listm.rev
    loop [] 0
In [ ]:
//// test

stream.new_infinite_stream_ print_and_return
|> flip stream.try_item
|> take_while_ (fun n (_ : i32) => n < 5i32)
|> listm'.sum
|> _assert_eq 10

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
__assert_eq / actual: 10 / expected: 10
In [ ]:
//// test

stream.new_infinite_stream_ print_and_return
|> stream.memoize
|> fun list =>
    inl list = list ()
    fun n =>
        list |> stream.try_item n
|> take_while_ (fun n (_ : i32) => n < 5i32)
|> listm'.sum
|> _assert_eq 10

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
__assert_eq / actual: 10 / expected: 10
In [ ]:
//// test

stream.new_finite_stream print_and_return 10i32
|> stream.memoize
|> fun list =>
    inl list = list ()
    fun n =>
        list |> stream.try_item n
|> take_while_ (fun n (_ : i32) => n < 5)
|> listm'.sum
|> _assert_eq 10

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
__assert_eq / actual: 10 / expected: 10

memoize¶

In [ ]:
inl memoize seq =
    inl state = mut []
    fun n =>
        match *state |> listm'.try_find (fun (n', _) => n' = n) with
        | Some (_, v) => v
        | None =>
            inl new_state = seq n
            state <- (n, new_state) :: *state
            new_state

inl memoize_ seq =
    inl state = mut []
    fun n =>
        match *state |> listm'.try_find_ (fun (n', _) => n' = n) with
        | Some (_, v) => v
        | None =>
            inl new_state = seq n
            state <- (n, new_state) :: *state
            new_state
In [ ]:
//// test

inl seq =
    fun n =>
        n |> print_and_return |> Some
    |> memoize_

seq
|> take_while_ (fun n (_ : i32) => n < 5)
|> listm'.sum
|> _assert_eq 10

seq
|> take_while_ (fun n _ => n < 5)
|> listm'.sum
|> _assert_eq 10

print_and_return / x: 0
print_and_return / x: 1
print_and_return / x: 2
print_and_return / x: 3
print_and_return / x: 4
print_and_return / x: 5
__assert_eq / actual: 10 / expected: 10
__assert_eq / actual: 10 / expected: 10

iterate¶

In [ ]:
inl iterate f x0 num_steps =
    inl rec loop x n =
        if n <= 0
        then x
        else loop (f x) (n - 1)
    loop x0 num_steps
In [ ]:
//// test

10i32 |> iterate ((*) 2) 1i32
|> _assert_eq 1024

__assert_eq / actual: 1024 / expected: 1024
In [ ]:
inl iterate_ f x0 num_steps =
    let rec loop x n =
        if n <= 0
        then x
        else loop (f x) (n - 1)
    loop x0 num_steps
In [ ]:
//// test

10i32 |> iterate_ ((*) 2) 1i32
|> _assert_eq 1024

__assert_eq / actual: 1024 / expected: 1024
In [ ]:
inl iterate' f x0 num_steps =
    listm.init num_steps id
    |> listm.fold (fun x _ => f x) x0
In [ ]:
//// test

10i32 |> iterate' ((*) 2) 1i32
|> _assert_eq 1024

__assert_eq / actual: 1024 / expected: 1024

find_last¶

In [ ]:
inl find_last forall item result. fold_fn fn target : option result =
    fold_fn (fun (item : item) (result : option result) =>
        match result with
        | None => fn item
        | result => result
    ) target (None : option result)

inl array_find_last forall item result. (fn : item -> option result) (target : a i32 item) : option result =
    find_last am.foldBack fn target

inl list_find_last forall item result. (fn : item -> option result) (target : list item) : option result =
    find_last listm.foldBack fn target

fsharp¶

seq'¶

In [ ]:
nominal seq' t = $"backend_switch `({ Fsharp : $"`t seq"; Python : t })"

new_seq¶

In [ ]:
inl new_seq fn : seq' _ =
    fun () =>
        $'seq {'
        fn |> indent
        $'}' : ()
    |> let'

of_array'¶

In [ ]:
inl of_array' forall dim t. (items : a dim t) : seq' t =
    backend_switch {
        Fsharp = fun () => $'seq { for i = 0 to !items.Length - 1 do yield !items.[i] }' : seq' t
        Python = fun () => $'!items ' : seq' t
    }
In [ ]:
//// test

(a ;[ "a"; "b" ] : _ i32 _)
|> of_array'
[ a, b ]
CheckClose
False
LastGenerated
<null>
v2
[ a, b ]
enum
<null>
pc
0
current
<null>
(values)
[ a, b ]

of_array¶

In [ ]:
inl of_array forall dim t. (items : a dim t) : seq' t =
    backend_switch {
        Fsharp = fun () => $'!items |> Seq.ofArray' : seq' t
        Python = fun () => $'!items ' : seq' t
    }
In [ ]:
//// test

(a ;[ "a"; "b" ] : _ i32 _)
|> of_array
[ a, b ]
f
Microsoft.FSharp.Collections.SeqModule+OfArray@1010[System.String]
source
[ a, b ]
(values)
[ a, b ]

of_array_base¶

In [ ]:
inl of_array_base forall t. (items : array_base t) : seq' t =
    a items
    |> fun x => x : _ int _
    |> of_array
In [ ]:
//// test

;[ "a"; "b" ]
|> of_array_base
[ a, b ]
f
Microsoft.FSharp.Collections.SeqModule+OfArray@1010[System.String]
source
[ a, b ]
(values)
[ a, b ]

to_array'¶

In [ ]:
inl to_array' forall dim t. (items : seq' t) : a dim t =
    backend_switch {
        Fsharp = fun () => items |> $'Seq.toArray' : a dim t
        Python = fun () => $'!items ' : a dim t
    }
In [ ]:
//// test

(a ;[ "a"; "b" ] : _ i32 _)
|> of_array'
|> to_array'
|> _assert_eq' (a ;[ "a"; "b" ] : _ i32 _)

__assert_eq' / actual: [|"a"; "b"|] / expected: [|"a"; "b"|]

of_list'¶

In [ ]:
inl of_list' forall t. (items : listm'.list' t) : seq' t =
    backend_switch {
        Fsharp = fun () => $'seq { for i = 0 to !items.Length - 1 do yield !items.[i] }' : seq' t
        Python = fun () => $'!items ' : seq' t
    }

to_list'¶

In [ ]:
inl to_list' forall t. (items : seq' t) : listm'.list' t =
    backend_switch {
        Fsharp = fun () => items |> $'Seq.toList' : listm'.list' t
        Python = fun () => $'!items ' : listm'.list' t
    }
In [ ]:
//// test

(a ;[ "a"; "b" ] : _ i32 _)
|> of_array
|> to_list'
|> listm'.unbox
|> _assert_eq ([ "a"; "b" ])

__assert_eq / actual: UH0_1 ("a", UH0_1 ("b", UH0_0)) / expected: UH0_1 ("a", UH0_1 ("b", UH0_0))

rev'¶

In [ ]:
inl rev'' forall t u. (items : t) : seq' u =
    backend_switch {
        Fsharp = fun () => items |> $'Seq.rev' : seq' u
        Python = fun () => $'reversed(!items)' : seq' u
    }

rust¶

fuse¶

In [ ]:
nominal fuse t =
    `(
        global "#if FABLE_COMPILER\n[<Fable.Core.Erase; Fable.Core.Emit(\"core::iter::Fuse<$0>\")>]\n#endif\ntype core_iter_Fuse<'T> = class end"
        $'' : $'core_iter_Fuse<`t>'
    )