14.4.113  Tupblebasex

The standard library Tuplebasex api defines the interface for the pkg::tuplebasex package.

The Tuplebasex api is implemented by the tuplebasex package.

The Tuplebasex api source code is in src/lib/src/tuplebasex.api. The above information is manually maintained and may contain errors.

api {
    Tuplebase X;
    Atom X;
    Duple X = (Atom(X ) , Atom(X ));
    Triple X = (Atom(X ) , Atom(X ) , Atom(X ));
        package ds
          : api {   package key
                      : api {
                            Key X;
                            compare : (Key(X ) , Key(X )) -> Order;};;
                Item X = key::Key(X );
                Set X;
                empty : Set(X );
                singleton : Item(X ) -> Set(X );
                add : (Set(X ) , Item(X )) -> Set(X );
                add' : (Item(X ) , Set(X )) -> Set(X );
                add_list : (Set(X ) , List(Item(X ) )) -> Set(X );
                drop : (Set(X ) , Item(X )) -> Set(X );
                member : (Set(X ) , Item(X )) -> Bool;
                is_empty : Set(X ) -> Bool;
                equal : (Set(X ) , Set(X )) -> Bool;
                compare : (Set(X ) , Set(X )) -> Order;
                is_subset : (Set(X ) , Set(X )) -> Bool;
                vals_count : Set(X ) -> Int;
                vals_list : Set(X ) -> List(Item(X ) );
                union : (Set(X ) , Set(X )) -> Set(X );
                intersection : (Set(X ) , Set(X )) -> Set(X );
                difference : (Set(X ) , Set(X )) -> Set(X );
                map : (Item(X ) -> Item(X )) -> Set(X ) -> Set(X );
                apply : (Item(X ) -> Void) -> Set(X ) -> Void;
                fold_forward : ((Item(X ) , Y) -> Y) -> Y -> Set(X ) -> Y;
                fold_backward : ((Item(X ) , Y) -> Y) -> Y -> Set(X ) -> Y;
                partition : (Item(X ) -> Bool) -> Set(X ) -> (Set(X ) , Set(X ));
                filter : (Item(X ) -> Bool) -> Set(X ) -> Set(X );
                exists : (Item(X ) -> Bool) -> Set(X ) -> Bool;
                find : (Item(X ) -> Bool) -> Set(X ) -> Null_Or(Item(X ) );
                all_invariants_hold : Set(X ) -> Bool;};;
        package ts
          : api {   package key
                      : api {
                            Key X;
                            compare : (Key(X ) , Key(X )) -> Order;};;
                Item X = key::Key(X );
                Set X;
                empty : Set(X );
                singleton : Item(X ) -> Set(X );
                add : (Set(X ) , Item(X )) -> Set(X );
                add' : (Item(X ) , Set(X )) -> Set(X );
                add_list : (Set(X ) , List(Item(X ) )) -> Set(X );
                drop : (Set(X ) , Item(X )) -> Set(X );
                member : (Set(X ) , Item(X )) -> Bool;
                is_empty : Set(X ) -> Bool;
                equal : (Set(X ) , Set(X )) -> Bool;
                compare : (Set(X ) , Set(X )) -> Order;
                is_subset : (Set(X ) , Set(X )) -> Bool;
                vals_count : Set(X ) -> Int;
                vals_list : Set(X ) -> List(Item(X ) );
                union : (Set(X ) , Set(X )) -> Set(X );
                intersection : (Set(X ) , Set(X )) -> Set(X );
                difference : (Set(X ) , Set(X )) -> Set(X );
                map : (Item(X ) -> Item(X )) -> Set(X ) -> Set(X );
                apply : (Item(X ) -> Void) -> Set(X ) -> Void;
                fold_forward : ((Item(X ) , Y) -> Y) -> Y -> Set(X ) -> Y;
                fold_backward : ((Item(X ) , Y) -> Y) -> Y -> Set(X ) -> Y;
                partition : (Item(X ) -> Bool) -> Set(X ) -> (Set(X ) , Set(X ));
                filter : (Item(X ) -> Bool) -> Set(X ) -> Set(X );
                exists : (Item(X ) -> Bool) -> Set(X ) -> Bool;
                find : (Item(X ) -> Bool) -> Set(X ) -> Null_Or(Item(X ) );
                all_invariants_hold : Set(X ) -> Bool;};;
    make_atom : Void -> Atom(X );
    make_string_atom : String -> Atom(X );
    make_float_atom : Float -> Atom(X );
    make_other_atom : X -> Atom(X );
    string_of : Atom(X ) -> Null_Or(String );
    float_of : Atom(X ) -> Null_Or(Float );
    other_of : Atom(X ) -> Null_Or(X );
    empty_tuplebase : Tuplebase(X );
    put_duple : (Tuplebase(X ) , Duple(X )) -> Tuplebase(X );
    put_triple : (Tuplebase(X ) , Triple(X )) -> Tuplebase(X );
    drop_duple : (Tuplebase(X ) , Duple(X )) -> Tuplebase(X );
    drop_triple : (Tuplebase(X ) , Triple(X )) -> Tuplebase(X );
    get_duples : Tuplebase(X ) -> ds::Set(X );
    get_duples1 : (Tuplebase(X ) , Atom(X )) -> Null_Or(ds::Set(X ) );
    get_duples2 : (Tuplebase(X ) , Atom(X )) -> Null_Or(ds::Set(X ) );
    has_duple : (Tuplebase(X ) , Duple(X )) -> Bool;
    get_triples : Tuplebase(X ) -> ts::Set(X );
    get_triples1 : (Tuplebase(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    get_triples2 : (Tuplebase(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    get_triples3 : (Tuplebase(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    get_triples12 : (Tuplebase(X ) , Atom(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    get_triples13 : (Tuplebase(X ) , Atom(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    get_triples23 : (Tuplebase(X ) , Atom(X ) , Atom(X )) -> Null_Or(ts::Set(X ) );
    has_triple : (Tuplebase(X ) , Triple(X )) -> Bool;
    atoms_apply : Tuplebase(X ) -> (Atom(X ) -> Void) -> Void;};