package bap-bundle

You can search for identifiers within the package.

in-package search v0.2.0

package bap-bundle

bap-bundle
- Bap_bundle
  - Std
    
    Bundle
    
    Builder
    
    Manifest
    
    Fields
    
    Direct

Legend:
Library
Module
Module type
Parameter
Class
Class type

Program meta information.

type t = {

name : string;
(*
program name
*)
version : string;
(*
program version
*)
desc : string;
(*
one line description
*)
main : string;
(*
entry point
*)
author : string;
(*
program author
*)
date : float;
(*
last update date
*)
requires : string list;
(*
required libraries
*)
provides : string list;
(*
provided features
*)
url : string option;
(*
project URL
*)
license : string option;
(*
project license
*)
copyrights : string option;
(*
copyright holders
*)
tags : string list;
(*
bundle tags
*)
cons : string list;
(*
bundle constraints
*)

}

include Core_kernel.Bin_prot.Binable.S with type t := t

include Bin_prot.Binable.S_only_functions with type t := t

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : (int -> t) Bin_prot.Read.reader

This function only needs implementation if t exposed to be a polymorphic variant. Despite what the type reads, this does *not* produce a function after reading; instead it takes the constructor tag (int) before reading and reads the rest of the variant t afterwards.

val bin_shape_t : Bin_prot.Shape.t

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_t : t Bin_prot.Type_class.t

include Ppx_compare_lib.Comparable.S with type t := t

val compare : t -> t -> int

val cons : t -> string list

val tags : t -> string list

val copyrights : t -> string option

val license : t -> string option

val url : t -> string option

val provides : t -> string list

val requires : t -> string list

val date : t -> float

val author : t -> string

val main : t -> string

val desc : t -> string

val version : t -> string

val name : t -> string

module Fields : sig ... end

include Sexplib0.Sexpable.S with type t := t

val t_of_sexp : Sexplib0.Sexp.t -> t

val sexp_of_t : t -> Sexplib0.Sexp.t

val create : 
  ?author:string ->
  ?version:string ->
  ?main:string ->
  ?date:float ->
  ?desc:string ->
  ?requires:string list ->
  ?provides:string list ->
  ?url:string ->
  ?license:string ->
  ?copyrights:string ->
  ?tags:string list ->
  ?cons:string list ->
  string ->
  t

create name create a bundle for a program with a given name

include Core_kernel.Stringable with type t := t

val of_string : string -> t

val to_string : t -> string