talaria-bibtex 0.5 (latest)

Predefined bibtex fields and helper functions.

include Field_types.self

type pages =

| Loc of int
| Interv of int * int

type name = {

lastname : string;
firstname : string;

}

type kind =

| Article
| Inproceedings
| Book
| Talk
| Poster

type state =

| Published
| Accepted
| Submitted
| WIP
(*
Publication status
*)

Talaria-bibtex exposes its own orec namespace

include Orec.Namespace.S

include Orec.Bijection.S

type ('a, 'b) bijection = {

to_ : 'a -> 'b;
from : 'b -> 'a;

}

Bijection record

val flip : ('a, 'b) bijection -> ('b, 'a) bijection

Bijection inversion

val (%) : ('a, 'b) bijection -> ('c, 'a) bijection -> ('c, 'b) bijection

Bijection composition

type t

The type of record within the namespace

type 'info field_action

The type of a field getter or updater

type 'info get = (('a, 'mut) Orec.Type_data.getter * 'res) field_action constraint 'info = < x : 'a ; mut : 'mut ; ret : 'res >

Aliases for the field types

type 'a field = < x : 'a ; mut : Orec.Type_data.imm ; ret : 'a option > get

type 'a mut_field = < x : 'a ; mut : Orec.Type_data.mut ; ret : 'a option > get

type 'a exn_field = < x : 'a ; mut : Orec.Type_data.imm ; ret : 'a > get

type 'a exn_mut_field = < x : 'a ; mut : Orec.Type_data.mut ; ret : 'a > get

type ('param, 't) update = ('param Orec.Type_data.updater * 't) field_action

val empty : t

The empty record

val create : (Orec.Type_data.only Orec.Type_data.const, t) update list -> t

Create a new open record from a list of field updater : create [ field1 ^= value1; field2 ^= value2; ... ] Only const updater make sense in this context, since there is no fields present.

val new_field : unit -> 'ty field

Creation of a new fields. Note that the type 'ty is weakly polymorphic once the field created. However, in this specific use case, it seems reasonable to annotate the field type by using one of the field type aliases.

val new_field_mut : unit -> 'ty mut_field

val new_field_exn : unit -> 'ty exn_field

val new_field_exn_mut : unit -> 'ty exn_mut_field

val put : < x : 'ty.. > get -> 'ty -> (_ Orec.Type_data.const, t) update

Constant field updater: record.%{ field ^= v } sets the value of field to v and is equivalent to record.%{ put field v }

val (^=) : < x : 'ty.. > get -> 'ty -> (_ Orec.Type_data.const, t) update

val fmap : 
  < x : 'ty.. > get ->
  ('ty -> 'ty) ->
  ('a Orec.Type_data.fn, t) update

Field map: record.%{field |= f } or record.%{ fmap field f } are equivalent to record.%{ field ^= f record.%{field} } if the field exists, and do nothing otherwise

val (|=) : 
  < x : 'ty.. > get ->
  ('ty -> 'ty) ->
  ('a Orec.Type_data.fn, t) update

Field combinator orec.%{ x & y } is orec.%{x}.%{y}

val (&) : 
  (Orec.Type_data.any, t) update ->
  (Orec.Type_data.any, t) update ->
  (Orec.Type_data.any, t) update

val and_then : 
  (Orec.Type_data.any, t) update ->
  (Orec.Type_data.any, t) update ->
  (Orec.Type_data.any, t) update

val copy : 
  < x : 'ty ; mut : Orec.Type_data.mut.. > get ->
  ('a Orec.Type_data.fn, t) update

Copy a mutable field

val delete : < .. > get -> ('a Orec.Type_data.del, t) update

Delete a field, if the field does not exist, do nothing

val get : < ret : 'ret.. > get -> t -> 'ret

getter, updater and setter for t

val update : (Orec.Type_data.any, t) update -> t -> t

val set : < x : 'ty ; mut : Orec.Type_data.mut.. > get -> 'ty -> t -> unit

Operator version of get+update and set

val (.%{}) : t -> (_ * 'ret) field_action -> 'ret

(.%{} ) operator:

record.%{field} returns the value of the field
record.%{field ^= value} returns a functional update of record
record.%{field |= f} is equivalent to record.{ field ^= f record.{field} }
record.%{delete field} returns an updated version of record without this field

val (.%{}<-) : t -> < x : 'ty ; mut : Orec.Type_data.mut.. > get -> 'ty -> unit

val transmute : 
  < x : 'a ; mut : 'm.. > as 'x get ->
  ('a, 'b) bijection ->
  < x : 'b ; mut : 'm ; ret : 'b option > get

Use the type equality implied by the bijection 'a⟺'b to create a new 'b field getter from an 'a field getter. The new field getter uses option access

val (@:) : 
  < x : 'a ; mut : 'm.. > as 'x get ->
  ('a, 'b) bijection ->
  < x : 'b ; mut : 'm ; ret : 'b option > get

Operator version of transmute

val transmute_exn : 
  < x : 'a ; mut : 'm.. > as 'x get ->
  ('a, 'b) bijection ->
  < x : 'b ; mut : 'm ; ret : 'b > get

exception based version of transmute

val (@:!) : 
  < x : 'a ; mut : 'm.. > as 'x get ->
  ('a, 'b) bijection ->
  < x : 'b ; mut : 'm ; ret : 'b > get

Operator version of transmute_exn

type 'a named_field = {

name : string;
f : 'a field;
conv : ('a, string) bijection;

}

A bibtex field consists of an orec field, a name and a translation between the raw text of the field towards a typed field

exception Unknown_attribute of string * string

The exception Unknown_attribute is raised whenever a type dkey fails to parse its contents to its underlying type.

val str : 'a named_field -> string field

Create a string view from a named_field

val named_field : name:string -> ('a, string) bijection -> 'a named_field

Field creation helper

Predefined field kind

val str_field : name:string -> string named_field

val int_field : name:string -> int named_field

module StrSet : Set.S with type elt = string

module Database : Map.S with type key = string

val strset_field : name:string -> StrSet.t named_field

List of predefined fields

val uid : string named_field

val kind : kind named_field

val title : string named_field

val authors : name list named_field

val year : int named_field

val journal : string named_field

val booktitle : string named_field

val volume : int named_field

val number : int named_field

val pages : pages named_field

val doi : string list named_field

val arxiv : string named_field

val tags : StrSet.t named_field

val src : StrSet.t named_field

val state : state named_field

val abstract : string named_field

val location : string named_field

val conference : string named_field

val raw : string Database.t field

val default_keys : string field Database.t

The default typed keys when parsing bibtex file

Direct access functions

val get_uid : t -> string

Both uid and kind are compulsory

val get_kind : t -> kind

val get_state : t -> state

state default to WIP when the field is absent

type entry = t

Type alias

type data = entry Database.t

type raw_entry = {

uid : string;
kind : string;
raw : string Database.t;

}

Raw database and entries

val check : ?with_keys:string field Database.t -> raw_entry Database.t -> data

package talaria-bibtex

Predefined field kind

List of predefined fields

Direct access functions