strymonas-pure 2.1.1 · OCaml Package

val ident : string

module I = OffshoringIR

val (>>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

type !'a tbase_desc = ..

type tbase_desc +=

| TBbool : bool tbase_desc
| TBint : int tbase_desc

type !'a tbase = {

desc : 'a tbase_desc;
ityp : I.typ;
zero : I.exp;
printf_fn : I.exp -> I.block;
deser : string -> 'a;

}

val make_printf : string -> I.exp list -> I.block

val tbool : bool tbase

val tint_ntyp : I.numtyp

val tint : int tbase

type !'a exp = 'a tbase * I.exp

val exp : 'a tbase -> I.exp -> 'a exp

val exp_app : 'a tbase -> I.OP.t -> I.exp list -> 'a exp

val tbase_init : 'a tbase -> 'a exp

val tbase_zero : 'a tbase -> 'a exp

val bool : bool -> bool exp

val unary_op : ('a tbase * I.OP.t * 'b tbase) -> 'a exp -> 'b exp

val binary_op : 
  ('a tbase * 'b tbase * I.OP.t * 'c tbase) ->
  'a exp ->
  'b exp ->
  'c exp

val not : bool exp -> bool exp

val (&&) : bool exp -> bool exp -> bool exp

val (||) : bool exp -> bool exp -> bool exp

val int : int -> int exp

val (~-) : int exp -> int exp

val (+) : int exp -> int exp -> int exp

val (-) : int exp -> int exp -> int exp

val (*) : int exp -> int exp -> int exp

val (/) : int exp -> int exp -> int exp

val (mod) : int exp -> int exp -> int exp

val logand : int exp -> int exp -> int exp

val logor : int exp -> int exp -> int exp

val (=) : int exp -> int exp -> bool exp

val (<) : int exp -> int exp -> bool exp

val (>) : int exp -> int exp -> bool exp

val (>=) : int exp -> int exp -> bool exp

val (<=) : int exp -> int exp -> bool exp

val cond : bool exp -> 'a exp -> 'a exp -> 'a exp

val imin : int exp -> int exp -> int exp

val imax : int exp -> int exp -> int exp

type !'a0 tys =

| TVoid : unit tys
| TBase : 'a tbase -> 'a tys

type !'a stm = 'a tys * I.block

val unit : unit stm

val stmt : I.stmt -> unit stm

val stmt_app : I.OP.t -> I.exp list -> unit stm

val seq : unit stm -> 'a stm -> 'a stm

val (@.) : unit stm -> 'a stm -> 'a stm

val seqs : unit stm list -> unit stm

val ret : 'a exp -> 'a stm

val print_int : int exp -> unit stm

val letl : 'a exp -> ('a exp -> 'w stm) -> 'w stm

val glet : 'a exp -> 'a exp

val if_ : bool exp -> unit stm -> unit stm -> unit stm

val if1 : bool exp -> unit stm -> unit stm

val while_ : bool exp -> unit stm -> unit stm

val for_ : 
  int exp ->
  upe:int exp ->
  ?guard:bool exp ->
  ?step:int exp ->
  (int exp -> unit stm) ->
  unit stm

type !'a mut = 'a tbase * I.varname

val dref : 'a mut -> 'a exp

val (:=) : 'a mut -> 'a exp -> unit stm

val incr : int mut -> unit stm

val decr : int mut -> unit stm

val newref : 'a exp -> ('a mut -> 'w stm) -> 'w stm

val newuref : 'a exp -> ('a mut -> 'w stm) -> 'w stm

type !'a arr = 'a tbase * int exp * I.varname

val array_get' : 'a arr -> int exp -> 'a exp

val array_len : 'a arr -> int exp

val array_set : 'a arr -> int exp -> 'a exp -> unit stm

val array_incr : 'a arr -> int exp -> 'a exp -> unit stm

val array_get : 'a arr -> int exp -> ('a exp -> 'w stm) -> 'w stm

val new_array : 'a tbase -> 'a exp array -> ('a arr -> 'w stm) -> 'w stm

val new_static_array : 
  'a tbase ->
  ('b -> 'a exp) ->
  'b array ->
  ('a arr -> 'w stm) ->
  'w stm

val new_uarray : 'a tbase -> int -> ('a arr -> 'w stm) -> 'w stm

val is_static : 'a exp -> bool

val is_fully_dynamic : 'a exp -> bool

val cloop : 
  ('a -> unit stm) ->
  bool exp option ->
  (('a -> unit stm) -> unit stm) ->
  unit stm

type !'sg ff = {

invoke : 'sg;

}

module type num = sig ... end

module type flonum = sig ... end

module type cmplxnum = sig ... end

module I64 : sig ... end

module F64 : sig ... end

module F32 : sig ... end

module C32 : sig ... end

type 'a proc_t = I.proc_t

val nullary_proc : 'a stm -> 'a proc_t

val arg_base : 
  ?name:string ->
  'a tbase ->
  ('a exp -> 'b proc_t) ->
  ('a -> 'b) proc_t

val arg_array : 
  ?name:string ->
  ?mutble:bool ->
  int exp ->
  'a tbase ->
  ('a arr -> 'b proc_t) ->
  ('a -> 'b) proc_t

val pp_prelude : Format.formatter -> unit

val pp_main : Format.formatter -> unit stm -> unit

val pp_proc : ?name:string -> Format.formatter -> 'a proc_t -> unit

val print_code : ?name:string -> 'a stm -> unit

val build_capture_output : 
  (Format.formatter -> unit) ->
  Scanf.Scanning.in_channel

val run_capture_output : unit stm -> Scanf.Scanning.in_channel

val run : 'a stm -> 'a

package strymonas-pure