package feat-core

You can search for identifiers within the package.

in-package search v0.2.0

package feat-core

feat-core
- FeatCore
  - BigIntSig
    
    BASIC
    
    EXTENDED
  - Enum
    
    Make
    
    IFSeq
  - EnumSig
    
    ENUM
    
    IFSeq
  - IFSeq
    
    Make
    
    R
    
    Z
  - IFSeqList
  - IFSeqObj
    
    Make
    
    Z
  - IFSeqSig
    
    IFSEQ_BASIC
    
    IFSEQ_EXTENDED
  - IFSeqSyn
    
    Make
    
    Z
  - RandomBigInt
    
    Make
    
    R
    
    Z
  - RandomSig
    
    S

Legend:
Library
Module
Module type
Parameter
Class
Class type

include IFSeqSig.IFSEQ_BASIC with type index = int and type 'a seq = 'a list

type 'a seq = 'a list

'a seq is the type of sequences whose elements have type 'a.

Constructors.

val empty : 'a seq

empty is a sequence of length zero.

val zero : 'a seq

zero is a synonym for empty.

val singleton : 'a -> 'a seq

singleton x is a sequence of length one whose single element is x.

val one : 'a -> 'a seq

one is a synonym for singleton.

val rev : 'a seq -> 'a seq

rev xs is the reverse of the sequence xs.

val sum : 'a seq -> 'a seq -> 'a seq

sum s1 s2 is the concatenation of the sequences s1 and s2.

val (++) : 'a seq -> 'a seq -> 'a seq

(++) is a synonym for sum.

val product : 'a seq -> 'b seq -> ('a * 'b) seq

product s1 s2 is the Cartesian product of the sequences s1 and s2. Its length is the product of the lengths of s1 and s2. The first pair component is considered most significant.

val (**) : 'a seq -> 'b seq -> ('a * 'b) seq

( ** ) is a synonym for product.

val map : ('a -> 'b) -> 'a seq -> 'b seq

map phi s is the image of the sequence s through the function phi. If the user wishes to work with sequences of pairwise distinct elements, then phi should be injective. If furthermore the user wishes to work with sequences that enumerate all elements of a type, then phi should be surjective.

val up : int -> int -> int seq

up i j is the sequence of the integers from i included up to j excluded.

type index = int

The type index is the type of integers used to represent indices and lengths.

val length : 'a seq -> index

length s is the length of the sequence s.

val get : 'a seq -> index -> 'a

get s i is the i-th element of the sequence s. The index i must be comprised between zero included and length s excluded.

val foreach : 'a seq -> ('a -> unit) -> unit

foreach s k iterates over all elements of the sequence s. Each element in turn is passed to the loop body k.

val to_seq : 'a seq -> 'a Seq.t -> 'a Seq.t

to_seq s k produces an explicit representation of the sequence s as a sequence in the sense of OCaml's standard library module Seq. This sequence is prepended in front of the existing sequence k.