package linksem

You can search for identifiers within the package.

in-package search v0.2.0

package linksem

linksem

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Missing_pervasives`Source

Sourceval id0 : 'a -> 'a

Sourceval compare_byte : char -> char -> int

Source

val instance_Basic_classes_Ord_Missing_pervasives_byte_dict : 
  char Lem_basic_classes.ord_class

Sourceval hex_char_of_nibble : Nat_big_num.num -> char

Sourceval hex_string_of_byte : char -> string

Sourceval instance_Show_Show_Missing_pervasives_byte_dict : char Show.show_class

Sourceval natural_of_decimal_digit : char -> Nat_big_num.num option

Source

val natural_of_decimal_string_helper : 
  Nat_big_num.num ->
  char list ->
  Nat_big_num.num

Sourceval natural_of_decimal_string : string -> Nat_big_num.num

Sourceval hex_string_of_natural : Nat_big_num.num -> string

Sourceval natural_of_bool : bool -> Nat_big_num.num

Sourceval merge_by : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list

Source

val mapMaybei' : 
  (Nat_big_num.num -> 'a -> 'b option) ->
  Nat_big_num.num ->
  'a list ->
  'b list

mapMaybei f xs maps a function expecting an index (the position in the list * xs that it is currently viewing) and producing a maybe type across a list. * Elements that produce Nothing under f are discarded in the output, whilst * those producing Just e for some e are kept.

Sourceval mapMaybei : (Nat_big_num.num -> 'a -> 'b option) -> 'a list -> 'b list

Source

val partitionii' : 
  Nat_big_num.num ->
  Nat_big_num.num list ->
  'a list ->
  (Nat_big_num.num * 'a) list ->
  (Nat_big_num.num * 'a) list ->
  (Nat_big_num.num * 'a) list * (Nat_big_num.num * 'a) list

partitionii is xs returns a pair of lists: firstly those elements in xs that are at indices in is, and secondly the remaining elements. It preserves the order of elements in xs.

Sourceval filteri : Nat_big_num.num list -> 'a list -> 'a list

Sourceval filterii : Nat_big_num.num list -> 'a list -> (Nat_big_num.num * 'a) list

Sourceval partitioni : Nat_big_num.num list -> 'a list -> 'a list * 'a list

Source

val partitionii : 
  Nat_big_num.num list ->
  'a list ->
  (Nat_big_num.num * 'a) list * (Nat_big_num.num * 'a) list

Sourceval unzip3 : ('a * 'b * 'c) list -> 'a list * 'b list * 'c list

unzip3 ls takes a list of triples and returns a triple of lists.

Sourceval zip3 : 'a list -> 'b list -> 'c list -> ('a * 'b * 'c) list

zip3 ls takes a triple of lists and returns a list of triples.

null_byte is the null character a a byte.

Sourceval null_char : char

null_char is the null character.

println s prints s to stdout, adding a trailing newline.

prints s prints s to stdout, without adding a trailing newline.

errln s prints s to stderr, adding a trailing newline.

errs s prints s to stderr, without adding a trailing newline.

outln s prints s to stdout, adding a trailing newline.

outs s prints s to stdout, without adding a trailing newline.

Sourceval intercalate' : 'a -> 'a list -> 'a list -> 'a list

intercalate sep xs places sep between all elements of xs. * Made tail recursive and unrolled slightly to improve performance on large * lists.

Sourceval intercalate : 'a -> 'a list -> 'a list

Sourceval unlines : string list -> string

unlines xs concatenates a list of strings xs, placing each entry * on a new line.

Sourceval bracket : string list -> string

bracket xs concatenates a list of strings xs, separating each entry with a * space, and bracketing the resulting string.

Sourceval string_of_list : 'a Show.show_class -> 'a list -> string

string_of_list l produces a string representation of list l.

Source

val instance_Show_Show_list_dict : 
  'a Show.show_class ->
  'a list Show.show_class

split_string_on_char s c splits a string s into a list of substrings * on character c, otherwise returning the singleton list containing s * if c is not found in s. * * NOTE: quirkily, this doesn't discard separators (e.g. because NUL characters * are significant when indexing into string tables). FIXME: given this, is this * function really reusable? I suspect not.

Sourceval string_contains : string -> string -> bool

string_of_nat m produces a string representation of natural number m.

string_suffix i s returns all but the first i characters of s. * Fails if the index is negative, or beyond the end of the string.

Sourceval length : 'a list -> Nat_big_num.num

Sourceval takeRevAcc : Nat_big_num.num -> 'a list -> 'a list -> 'a list

Sourceval take0 : Nat_big_num.num -> 'a list -> 'a list

take cnt xs takes the first cnt elements of list xs. Returns a truncation * if cnt is greater than the length of xs.

Sourceval drop0 : Nat_big_num.num -> 'a list -> 'a list

drop cnt xs returns all but the first cnt elements of list xs. Returns an empty list * if cnt is greater than the length of xs.

string_prefix i s returns the first i characters of s. * Fails if the index is negative, or beyond the end of the string.

Source

val string_index_of' : 
  'a ->
  'a list ->
  Nat_big_num.num ->
  Nat_big_num.num option

string_index_of c s returns Just(i) where i is the index of the first * occurrence if c in s, if it exists, otherwise returns Nothing.

Source

val find_index_helper : 
  Nat_big_num.num ->
  ('a -> bool) ->
  'a list ->
  Nat_big_num.num option

Sourceval find_index0 : ('a -> bool) -> 'a list -> Nat_big_num.num option

Sourceval replicate_revacc : 'a list -> Nat_big_num.num -> 'a -> 'a list

Sourceval replicate0 : Nat_big_num.num -> 'a -> 'a list

Sourceval list_append : 'a list -> 'a list -> 'a list

Sourceval list_concat : 'a list list -> 'a list

Sourceval list_concat_map : ('a -> 'b list) -> 'a list -> 'b list

Source

val list_reverse_concat_map_helper : 
  ('a -> 'b list) ->
  'b list ->
  'a list ->
  'b list

Sourceval list_reverse_concat_map : ('a -> 'b list) -> 'a list -> 'b list

Sourceval list_take_with_accum : Nat_num.nat -> 'a list -> 'a list -> 'a list

Sourceval unsafe_string_take : Nat_big_num.num -> string -> string

Sourceval padding_and_maybe_newline : char -> Nat_big_num.num -> string -> string

padding_and_maybe_newline c w s creates enough of char c to pad string s to w characters, * unless s is of length w - 1 or greater, in which case it generates w copies preceded by a newline. * This style of formatting is used by the GNU linker in its link map output, so we * reproduce it using this function. Note that string s does not appear in the * output.

Sourceval space_padding_and_maybe_newline : Nat_big_num.num -> string -> string

space_padding_and_maybe_newline w s creates enoughspaces to pad string s to w characters, * unless s is of length w - 1 or greater, in which case it generates w copies preceded by a newline. * This style of formatting is used by the GNU linker in its link map output, so we * reproduce it using this function. Note that string s does not appear in the * output.

Sourceval padded_and_maybe_newline : char -> Nat_big_num.num -> string -> string

padded_and_maybe_newline w s pads string s to w characters, using char c * unless s is of length w - 1 or greater, in which case the padding consists of * w copies of c preceded by a newline. * This style of formatting is used by the GNU linker in its link map output, so we * reproduce it using this function.

Sourceval padding_to : char -> Nat_big_num.num -> string -> string

padding_to c w s creates enough copies of c to pad string s to w characters, * or 0 characters if s is of length w or greater. Note that string s does not appear in the * output.

Sourceval left_padded_to : char -> Nat_big_num.num -> string -> string

left_padded_to c w s left-pads string s to w characters using c, * returning it unchanged if s is of length w or greater.

Sourceval right_padded_to : char -> Nat_big_num.num -> string -> string

right_padded_to c w s right-pads string s to w characters using c, * returning it unchanged if s is of length w or greater.

Sourceval space_padded_and_maybe_newline : Nat_big_num.num -> string -> string

space_padded_and_maybe_newline w s pads string s to w characters, using spaces, * unless s is of length w - 1 or greater, in which case the padding consists of * w spaces preceded by a newline. * This style of formatting is used by the GNU linker in its link map output, so we * reproduce it using this function.

Sourceval left_space_padded_to : Nat_big_num.num -> string -> string

left_space_padded_to w s left-pads string s to w characters using spaces, * returning it unchanged if s is of length w or greater.

Sourceval right_space_padded_to : Nat_big_num.num -> string -> string

right_space_padded_to w s right-pads string s to w characters using spaces, * returning it unchanged if s is of length w or greater.

Sourceval left_zero_padded_to : Nat_big_num.num -> string -> string

left_zero_padded_to w s left-pads string s to w characters using zeroes, * returning it unchanged if s is of length w or greater.

hex parsing

Sourceval natural_of_char : char -> Nat_big_num.num

Sourceval natural_of_hex' : char list -> Nat_big_num.num

Sourceval natural_of_hex : string -> Nat_big_num.num

Sourceval assert_unwrap_maybe : 'a option -> 'a

package linksem

Module Missing_pervasivesSource

Module `Missing_pervasives`Source