module type Lang = sig
open Prelude
open StateCPSMonad
open Abstract

include T

(* useful to have these right here *)
(* types shared between code, direct and coderep *)
type ('pc,'p) cmonad_constraint = unit
    constraint
        'p = <state : 's list; answer : 'w abstract>
    constraint
        'pc = <answer : 'w; state : 's; ..>

type ('pc,'v) cmonad = ('p, 'v abstract) monad
    constraint _ = ('pc,'p) cmonad_constraint

type ('p, 'a) same01 =
    Same of ('a list abstract -> ('p, 'a list) cmonad)
  | Different of ('p, 'a list) cmonad * ('a abstract -> ('p,'a list) cmonad)


val retN : 'b abstract -> ('p, 'b) cmonad

val seq : 'b abstract -> 'c abstract -> 'c abstract
val seqL : 'b abstract -> 'c abstract -> 'd -> ('d -> 'c abstract -> 'e) -> 'e
val seqM :
  ('a -> ('b -> 'c -> 'c ) -> unit abstract) ->
  ('a -> ('e -> 'f -> 'f ) -> 'g abstract) ->
  'a -> ('a -> 'g abstract -> 'h) -> 'h

val seqMS :
  (< answer : 'b; state : 'c; .. > as 'a, 'd abstract) monad ->
  (< answer : 'b; state : 'c; .. >, 'e abstract) monad -> ('a, 'e abstract) monad
  (*('a -> ('b -> 'c -> 'd) -> 'e abstract) ->
  ('f -> ('g -> 'h -> 'i) -> 'j abstract) ->
  'k -> ('k -> 'm abstract -> 'n) -> 'o*)

val optSeq : 'b abstract -> 'b abstract option -> 'b abstract

val optSeqM : 
  ('a -> ('a -> 'e abstract -> 'e abstract) -> 'e abstract) ->
  ('a -> ('a -> 'g -> 'g) -> 'e abstract) option ->
  'a -> ('a -> 'e abstract -> 'e abstract) -> 'e abstract

val ifM :
  bool abstract ->
  ('b -> ('c -> 'd -> 'd) -> 'e abstract) ->
  ('b -> ('f -> 'g -> 'g) -> 'e abstract) ->
  'b -> ('b -> 'e abstract -> 'h) -> 'h
val ifL :
  bool abstract ->
  'a abstract ->
  'a abstract ->
  'a abstract
val rshiftM : ('a -> 'b) -> 'a -> ('a -> 'b -> 'c) -> 'c
val whenM :
  bool abstract ->
  ('b -> ('c -> 'd -> 'd) -> unit abstract) ->
  'b -> ('b -> unit abstract -> 'e) -> 'e
val loopM :
  int abstract ->
  int abstract ->
  (int abstract -> 'b -> ('c -> 'd -> 'd) -> 'e abstract) ->
  dir ->
  'b -> ('b -> unit abstract -> 'f) -> 'f
val whileM :
  bool abstract ->
  ('a -> ('b -> 'c -> 'c) -> 'e abstract) ->
  'a -> ('a -> unit abstract -> 'f) -> 'f
val matchOpt : 
'a option abstract -> 
'c abstract -> 
('a abstract -> 'c abstract) -> 
'c abstract
val matchM :
  'b option abstract ->
  ('b abstract -> 'c -> ('d -> 'e -> 'e) -> 'f abstract) ->
  ('c -> ('g -> 'h -> 'h) -> 'f abstract) ->
  'c -> ('c -> 'f abstract -> 'i) -> 'i
val genrecloop :
  (('b -> 'c) abstract ->
   'b abstract -> 'd -> ('e -> 'c abstract -> 'c abstract) -> 'c abstract) ->
  'b abstract -> 'd -> ('d -> 'c abstract -> 'g) -> 'g
val lift : 'a -> 'a abstract
val liftRef : 'b abstract -> 'b ref abstract
val liftGet : 'b ref abstract -> 'b abstract
val unitL : 'a -> ('a -> unit abstract -> 'c) -> 'c
module Pair :
  sig
    val unpair : ('b * 'c) abstract -> 'b abstract * 'c abstract
    val fst : ('b * 'c) abstract -> 'b abstract
    val fstM : ('b * 'c) abstract -> ('p, 'b) cmonad
    val snd : ('b * 'c) abstract -> 'c abstract
end
val liftPPair :
  (('b * 'c) * 'd) abstract -> 'b abstract * 'c abstract * 'd abstract
module Logic :
  sig
    val trueL : bool abstract
    val falseL : bool abstract
    val notL : bool abstract -> bool abstract
    val equalL : 'b abstract -> 'b abstract -> bool abstract
    val notequalL : 'b abstract -> 'b abstract -> bool
    abstract
    val andL : bool abstract -> bool abstract -> bool abstract
  end
module Size :
  sig
    val size : int -> int abstract
  end
module Idx :
  sig
    val zero : int abstract
    val one : int abstract
    val minusone : int abstract
    val succ : int abstract -> int abstract
    val pred : int abstract -> int abstract
    val less : 'b abstract -> 'b abstract -> bool abstract
    val ltoe : 'b abstract -> 'b abstract -> bool abstract
    val uminus : int abstract -> int abstract
    val add : int abstract -> int abstract -> int abstract
    val sub : int abstract -> int abstract -> int abstract
    val minusoneL : 'a -> ('a -> int abstract -> 'c) -> 'c
  end
module Maybe :
  sig
    val just : 'b abstract -> 'b option abstract
    val none : 'b option abstract
  end
(*
module MaybeM :
  sig
    val just : 'b abstract -> 's -> ('s -> 'v -> 'b option abstract) -> 'b option abstract
    val none : 's -> ('s -> 'v -> 'b option abstract) -> 'b option abstract
  end*)

module Tuple :
  sig
    val tup2 : 'b abstract -> 'c abstract -> ('b * 'c) abstract
    val tup3 :
      'b abstract -> 'c abstract -> 'd abstract -> ('b * 'c * 'd) abstract
    val tup4 : 'b abstract -> 'c abstract -> 'd abstract -> 
               'e abstract -> ('b * 'c * 'd * 'e) abstract
  end
module CList :
  sig
    val nil : 'b list abstract
    val cons : 'b abstract -> 'b list abstract -> 'b list abstract
    val length : 'b list abstract -> int abstract
    val nth : 'a list abstract -> int abstract -> 'a abstract
    val hd : 'a list abstract -> 'a abstract
    val tl : 'a list abstract -> 'a list abstract
    val append : 'a list abstract -> 'a list abstract -> 'a list abstract
    val matchList :
      'b list abstract ->
      'c abstract ->
      ('b abstract -> 'b list abstract -> 'c abstract) ->
      'c abstract
    val matchListM :
      'b list abstract ->
      ('p, 'c) cmonad ->
      ('b abstract -> 'b list abstract -> ('p, 'c) cmonad) ->
      ('p, 'c) cmonad
    val matchListTwoM :
      'b list abstract ->
      (('p,'b) same01) ->
      ('b abstract -> 'b abstract -> 'b list abstract -> ('p, 'b list) cmonad) ->
      ('p, 'b list) cmonad
  end
val cunit : unit abstract
val update :
  'b ref abstract -> ('b abstract -> 'b abstract) -> unit abstract
val assign : 'b ref abstract -> 'b abstract -> unit abstract
val apply : ('b -> 'c) abstract -> 'b abstract -> 'c abstract
val updateM :
  'b ref abstract -> ('b abstract -> 'b abstract) ->
  'c -> ('c -> unit abstract -> 'd) -> 'd
val assignM :
  'b ref abstract ->
  'b abstract -> 'c -> ('c -> unit abstract -> 'd) -> 'd
val applyM :
  ('b -> 'c) abstract -> 'b abstract -> 'd -> ('d -> 'c abstract -> 'e) -> 'e
module Transformers :
  sig
    val full_unroll :
      int -> int -> (int -> unit abstract) -> unit abstract
  end

val applyMaybe : ('a -> 'a) option -> 'a -> 'a

module Array1Dim : sig
  val init : int abstract -> 'a abstract -> 'a array abstract
  val swap : int array abstract -> (int*int) abstract -> int array abstract
  val get : 'a array abstract -> int abstract -> 'a abstract
  (* imperative interface *)
  val set : 'a array abstract -> int abstract -> 'a abstract -> unit abstract
  val length : 'a array abstract -> int abstract
  val blit : 'a array abstract -> int abstract -> 'a array abstract -> int abstract -> int abstract -> unit abstract
end

(* this has some annoying code duplication.  FIXME 
   the main reason seems to be circularity of definitions of various
   things (like the abstract type).  So it's not straightforward to do. *)
module BoolTag : sig
  type 'a tag = 'a * bool

  val tag : 'a abstract -> bool abstract -> 'a tag abstract
  val get_tag : 'a tag abstract -> bool abstract
  val process : 'a tag abstract -> 
        ((bool abstract -> ('b -> ('x -> 'y -> 'y) -> unit abstract)) option) ->
        ('a abstract -> ('b -> ('c -> 'd -> 'd) -> 'e abstract)) ->
        (unit        -> ('b -> ('f -> 'g -> 'g) -> 'e abstract)) ->
                        ('b -> ('b -> 'e abstract -> 'h) -> 'h)
end

(* this is rather specialized... *)
module OptTag : sig
  type 'a tag = 'a option

  val tag : 'a abstract -> bool abstract -> 'a tag abstract
  val get_tag : 'a tag abstract -> bool abstract
  val process : 'a tag abstract -> 
        ((bool abstract -> ('b -> ('x -> 'y -> 'y) -> unit abstract)) option) ->
        ('a abstract -> ('b -> ('c -> 'd -> 'd) -> 'e abstract)) ->
        (unit        -> ('b -> ('f -> 'g -> 'g) -> 'e abstract)) ->
                        ('b -> ('b -> 'e abstract -> 'h) -> 'h)
end

module Vector : sig
  val vec : 'a array abstract -> 'b abstract -> ('a, 'b) svec abstract
  val datum : ('a, 'b) svec abstract -> 'a array abstract
  val size : ('a, 'b) svec abstract -> 'b abstract
end

end