The new-op Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The new-op Reference Manual

This is the new-op Reference Manual, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 04:21:24 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

NEW-OP
======

Copyright (c) 2010-2018 Marco Antoniotti
All rights reserved.

NEW-OP is a small library that introduces a unified "constructor"
operator.  Although nothing new, the operator is called "new" and it
can be used to create any Common Lisp object starting from a type
description.

See the file COPYING for license information.

A NOTE ON FORKING
-----------------

Of course you are free to fork the project subject to the current
licensing scheme.  However, before you do so, I ask you to consider
plain old "cooperation" by asking me to become a developer.
It helps keeping the entropy level at an acceptable level.


Enjoy.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 new-op

Author

Marco Antoniotti

License

BSD

Description

The NEW-OP System.

A (not so) new NEW operator that subsumes all the ’make-...’ functions and methods of Common Lisp.

Source

new-op.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 new-op.asd

Location

new-op.asd

Systems

new-op (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.2 new-op/new-op-pkg.lisp

Parent

new-op (system)

Location

new-op-pkg.lisp

Packages

it.unimib.disco.ma.cl.ext.tac.new-op


Previous: , Up: Lisp files   [Contents][Index]

3.1.3 new-op/new-op.lisp

Dependency

new-op-pkg.lisp (file)

Parent

new-op (system)

Location

new-op.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

4.1 it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op-pkg.lisp (file)

Nicknames
Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Special variables

Special Variable: *coerce-array-elements-p*

If true array initial elements are coerced to the expected type.

The default is NIL.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Special Variable: *coerce-numbers-p*

If true numbers are coerced to the expected type (in number constructors).

The default is NIL.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Macros

Macro: newq WHAT &rest ARGUMENTS

The NEWQ macro is a convenience syntactic shortcut to the NEW function.

The macro expands into a call to NEW without evaluating the first argument.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Functions

Function: register-structure-constructor SC CONSTRUCTOR

Registers CONSTRUCTOR for structure class SC.

The CONSTRUCTOR will then be available to NEW whenever a SC needs to be created.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

5.1.4 Generic functions

Generic Function: new WHAT &rest ARGUMENTS

Generic ’construction’ function.

The NEW generic function is a single entry point for MAKE-INSTANCE, DEFSTRUCT and other constructors, e.g., for HASH-TABLEs and ARRAYs.

Methods for NEW can be defined specialized for new classes. Structure classes need to register their constuctor; see REGISTER-STRUCTURE-CONSTRUCTOR. Compound type specifiers must be specialized by defining methods for TYPE-CONS.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Methods
Method: new (WHAT (eql bit)) &rest ARGUMENTS
Method: new (WHAT (eql unsigned-byte)) &rest ARGUMENTS
Method: new (WHAT (eql signed-byte)) &rest ARGUMENTS
Method: new (WHAT cons) &rest ARGUMENTS

CONS Method.

This is the method that handles the compound type specifiers. It eventually calls TYPE-CONS, which is in charge of dealing with each compound type specifier.

In order to inform the NEW operator of a new compound type specifier it is thus sufficient to define an appropriate TYPE-CONS method.

Method: new (WHAT (eql hash-set)) &rest ARGUMENTS

HASH-SET Method.

A specialised method yielding a HASH-TABLE with BOOLEAN values. It can be invoked in two forms.
<pre>
new ’HASH-SET
&optional SEQUENCE-SET
&rest HASH-TABLE-STANDARD-ARGS
&key &allow-other-keys
</pre>
or
<pre>
new ’HASH-SET
&rest HASH-TABLE-STANDARD-ARGS
&key &allow-other-keys
</pre>

I.e., it dispatches on the first of the ARGUMENTS to decide whether it also has to ’fill’ the newly created hash table; in this last case, it behaves as a ’copy’ constructor for the hash-table skeleton, and then it substitutes the values or the resulting hash-table with T. If the first of the ARGUMENTS is a hash-table, the keywords are ignored. If it is a keyword then it is assumed that the call must resolve to a simple call to MAKE-HASH-TABLE. Otherwise, <sequence-set> must be an SEQUENCE of elements of the set.

The result is an hash table.

Method: new (WHAT (eql #<structure-class common-lisp:hash-table>)) &rest ARGUMENTS

HASH-TABLE Method.

The HASH-TABLE method admits a non-traditional syntax. It can be invoked in two forms.
<pre>
new ’HASH-TABLE
&optional PAIRS
&rest HASH-TABLE-STANDARD-ARGS
&key &allow-other-keys
</pre>
or
<pre>
new ’HASH-TABLE
&rest HASH-TABLE-STANDARD-ARGS
&key &allow-other-keys
</pre>

I.e., it dispatches on the first of the ARGUMENTS to decide whether it also has to ’fill’ the newly created hash table; in this last case, it behaves as a ’copy’ constructor. If the first of the ARGUMENTS is a hash-table, the keywords are ignored. If it is a keyword then it is assumed that the call must resolve to a simple call to MAKE-HASH-TABLE. Otherwise, <pairs> must be an A-LIST of pairs <pre>
(key . value)
</pre>
which are then fed into the newly created hash-table.

The result is an hash table.

Method: new (WHAT (eql #<built-in-class common-lisp:double-float>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:single-float>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:fixnum>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:integer>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:ratio>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:rational>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:float>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:real>)) &rest ARGUMENTS
Method: new (WHAT (eql #<built-in-class common-lisp:complex>)) &rest ARGUMENTS

COMPLEX Method.

The COMPLEX method applies the function COMPLEX to the arguments.

Method: new (WHAT (eql #<built-in-class common-lisp:number>)) &rest ARGUMENTS

NUMBER Method.

The NUMBER method just checks that the argument is a number and returns it.

Method: new (WHAT (eql #<structure-class common-lisp:pathname>)) &rest ARGUMENTS

PATHNAME Method.

The PATHNAME method dispatches on the first element of ARGUMENTS. If it is a KEYWORD, it assumes that MAKE-PATHNAME is to be called, applied to all the ARGUMENTS.
Otherwise it checks whether the first of ARGUMENTS ia a STRING, a STREAM or a PATHNAME, in which case is passes it to the function PATHNAME.

Method: new (WHAT (eql #<built-in-class common-lisp:symbol>)) &rest ARGUMENTS

SYMBOL Method.

The SYMBOL method has the following syntax.
<pre>
new ’symbol S &optional (PACKAGE *PACKAGE*) COPY-PROPERTIES </pre>
S can be a STRING or a SYMBOL. If it is a SYMBOL, S is first copied, using COPY-SYMBOL and COPY-PROPERTIES (cfr., COPY-SYMBOL in the CL Standard). If S is a STRING then MAKE-SYMBOL is initially called. If PACKAGE is NIL then a fresh, uninterned symbol is returned, otherwise the resulting symbol is IMPORTed in PACKAGE.

Method: new (WHAT (eql #<built-in-class common-lisp:character>)) &rest ARGUMENTS

CHARACTER Method.

Applies the function CHARACTER to the first of ARGUMENTS.

Method: new (WHAT (eql #<built-in-class common-lisp:list>)) &rest ARGUMENTS

LIST Method.

Applies the function VECTOR to the ARGUMENTS.

Method: new (WHAT (eql #<built-in-class common-lisp:string>)) &rest ARGUMENTS

STRING Method.

Applies the function STRING to the first of ARGUMENTS.

Method: new (WHAT (eql #<built-in-class common-lisp:vector>)) &rest ARGUMENTS

VECTOR Method.

Applies the function VECTOR to the ARGUMENTS.

Method: new (WHAT (eql #<built-in-class common-lisp:array>)) &rest ARGUMENTS

ARRAY Method.

Calls MAKE-ARRAY after having manipulated the ARGUMENTS.
The ’bare’ constructor for objects of ’type’ ARRAY actually behaves as having the following simple syntax:
<pre>
new ’array &optional INITIAL-CONTENTS &rest MAKE-ARRAY-keywords </pre>
I.e., the constructor figures out the dimensions of the INITIAL-CONTENTS before dispatching to MAKE-ARRAY.

Method: new (WHAT class) &rest ARGUMENTS around

CLASS Around Method.

This method helps dealing with some of the vagaries of the CL type system, e.g., COMPLEX and RATIONAL types with their relationship.

Method: new (WHAT built-in-class) &rest ARGUMENTS

BUILT-IN-CLASS Method.

Signals an ’undefined’ error. This method is a sink for the built-in classes which do not have a specialized method built with EQL.

Method: new (WHAT structure-class) &rest ARGUMENTS

STRUCTURE-CLASS Method.

Applies the constructor of the STRUCTURE-CLASS to the ARGUMENTS. The constructor must have been registered with REGISTER-STRUCTURE-CONSTRUCTOR to be applicable.

Method: new (WHAT standard-class) &rest ARGUMENTS

STANDARD-CLASS Method.

Applies MAKE-INSTANCE to the class and ARGUMENTS. This method is, to all effects, MAKE-INSTANCE in disguise.

Method: new (WHAT symbol) &rest ARGUMENTS

SYMBOL Method.

Dispatches on the class named by the argument.

Generic Function: type-cons TYPE-NAME SPEC ARGUMENTS

The TYPE-CONS Generic Function.

TYPE-CONS is the entry point to specialize in order to handle compound type specifiers. The only assumption is that a compound type specifier is a list with a symbol as first element, as described in Section 4.2.3 ’Type Specifiers’ of the ANSI CL Specification.

Each method dispatches on the TYPE-NAME, which is a symbol. SPEC is the CDR of the full type specifier and ARGUMENTS is the list of arguments passed to NEW.

TYPE-CONS is meant to be specialized but not called directly.

Examples:

;;; Suppose you had

(deftype matrix (n m &optional (base-type ’double-float))
‘(array ,base-type (,n ,m)))

;;; You may want to define something along these lines.

(defmethod type-cons ((what (eql ’matrix)) spec arguments) (destructuring-bind (n m &optional (base-type ’double-float)) spec
(assert (and (<= 0 n (1- array-dimension-limit))
(<= 0 m (1- array-dimension-limit))))
(apply #’make-array (list n m)
:element-type base-type
arguments)))

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Methods
Method: type-cons (WHAT (eql class)) SPEC ARGUMENTS
Method: type-cons (WHAT (eql structure)) SPEC ARGUMENTS
Method: type-cons (WHAT (eql hash-table)) SPEC ARGUMENTS

The HASH-TABLE Method.

It constructs a HASH-TABLE by handling a ’type specifier’ with a
syntax that makes the following call the NEW possible:
<pre>
(new ’(hash-table &rest HT-KEYS
&key
(TEST #’eql)
(SIZE (hash-table-size *default-dummy-hash-table*))
(REHASH-SIZE (hash-table-rehash-size *default-dummy-hash-table*)) (REHASH-THRESHOLD (hash-table-rehash-threshold *default-dummy-hash-table*)) &allow-other-keys)
&rest arguments)
</pre>
The defaults for each of the keyword arguments are implementation dependent.

Method: type-cons (WHAT (eql mod)) SPEC ARGUMENTS
Method: type-cons (WHAT (eql unsigned-byte)) SPEC ARGUMENTS
Method: type-cons (WHAT (eql signed-byte)) SPEC ARGUMENTS
Method: type-cons (WHAT symbol) SPEC ARGUMENTS
Method: type-cons (WHAT (eql complex)) SPEC ARGUMENTS
Method: type-cons (WHAT (eql array)) SPEC ARGUMENTS

ARRAY Method.

It constructs an array after having manipulated SPEC and ARGUMENTS; the overall effect is similar to the NEW ARRAY method.
The TYPE-CONS method allows NEW to use the following syntax: <pre>
new ’(array &optional
(ELEMENT-TYPE T)
DIMENSION-SPEC
&rest MAKE-ARRAY-kwds-1
&key
&allow-other-keys)
&optional
INITIAL-CONTENTS
&rest MAKE-ARRAY-kwds-2
&key
&allow-other-keys
</pre>

I.e., the constructor figures out the dimensions of the <initial-contents> before dispatching to MAKE-ARRAY. Further checks are made to ensure that the shape of <initial-contents> (if supplied) is acceptable.

MAKE-ARRAY-kwds-1 and MAKE-ARRAY-kwds-2 are the normal MAKE-ARRAY parameters. The actual call to MAKE-ARRAY is eventually of the form: <pre>
(apply ’make-array
COMPUTED-DIMENSIONS
(append
(and INITIAL-CONTENTS
(list :initial-contents INITIAL-CONTENTS)) MAKE-ARRAY-kwd-1
MAKE-ARRAY-kwd-2))
</pre>
Therefore, order among the MAKE-ARRAY keywords is important.
It should be noted that
<pre>
(array &optional (ELEMENT-TYPE T) DIMENSION-SPEC)
</pre>
is a valid, yet constrained, type specifier.

Method: type-cons (WHAT (eql vector)) SPEC ARGUMENTS

Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Special variables

Special Variable: *default-dummy-hash-table*
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Special Variable: *structure-constructors*
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Macros

Macro: check-optional-args-number ARGLIST MIN MAX &optional AFTER

Utility macro producing ASSERTs that check the number of arguments.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Macro: type-check PLACE TYPE

Checks that PLACE contains an object of type TYPE.

It works like CHECK-TYPE, but TYPE is evaluated. It also returns T if the check succeeds.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Functions

Function: check-numeric-interval-element N NUM-TYPE-NAME L U
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Function: compute-data-dimensions DATA &optional RANK ERROR-IF-UNEQUAL-P &aux NESTED-SEQUENCES

Computes the dimensions of DATA.

DATA is a sequence of nested sequences. RANK can be passed to limit the depth of the reconstruction; if NIL (the default) the dimensions are computed down to ’atoms’. ERROR-IF-UNEQUAL-P controls whether an error is signalled if the shape of DATA is ’ragged’. An error is also signalled if RANK is higher than the actual DATA rank.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Function: compute-dimensions RANK DATA
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Function: copy-hash-table HT

Copies and HASH-TABLE.

This function is implementation dependent. The basic behavior provided here just copies an hash-table with the standard components.

Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Function: find-structure-constructor SC &optional ERRORP
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Function: make-rational N &optional D
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Generic functions

Generic Function: interval-type-cons NUM-TYPE LOWER-BOUND UPPER-BOUND ARGUMENTS
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)

Methods
Method: interval-type-cons (NUM-TYPE (eql fixnum)) L U ARGUMENTS
Method: interval-type-cons (NUM-TYPE (eql rational)) L U ARGUMENTS
Method: interval-type-cons (NUM-TYPE symbol) L U ARGUMENTS before
Method: interval-type-cons (NUM-TYPE symbol) L U ARGUMENTS

Previous: , Up: Internal definitions   [Contents][Index]

5.2.5 Types

Type: numeric-real-types ()
Package

it.unimib.disco.ma.cl.ext.tac.new-op

Source

new-op.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   N  
Index Entry  Section

F
File, Lisp, new-op.asd: The new-op<dot>asd file
File, Lisp, new-op/new-op-pkg.lisp: The new-op/new-op-pkg<dot>lisp file
File, Lisp, new-op/new-op.lisp: The new-op/new-op<dot>lisp file

L
Lisp File, new-op.asd: The new-op<dot>asd file
Lisp File, new-op/new-op-pkg.lisp: The new-op/new-op-pkg<dot>lisp file
Lisp File, new-op/new-op.lisp: The new-op/new-op<dot>lisp file

N
new-op.asd: The new-op<dot>asd file
new-op/new-op-pkg.lisp: The new-op/new-op-pkg<dot>lisp file
new-op/new-op.lisp: The new-op/new-op<dot>lisp file

Jump to:   F   L   N  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   C   F   G   I   M   N   R   T  
Index Entry  Section

C
check-numeric-interval-element: Internal functions
check-optional-args-number: Internal macros
compute-data-dimensions: Internal functions
compute-dimensions: Internal functions
copy-hash-table: Internal functions

F
find-structure-constructor: Internal functions
Function, check-numeric-interval-element: Internal functions
Function, compute-data-dimensions: Internal functions
Function, compute-dimensions: Internal functions
Function, copy-hash-table: Internal functions
Function, find-structure-constructor: Internal functions
Function, make-rational: Internal functions
Function, register-structure-constructor: Exported functions

G
Generic Function, interval-type-cons: Internal generic functions
Generic Function, new: Exported generic functions
Generic Function, type-cons: Exported generic functions

I
interval-type-cons: Internal generic functions
interval-type-cons: Internal generic functions
interval-type-cons: Internal generic functions
interval-type-cons: Internal generic functions
interval-type-cons: Internal generic functions

M
Macro, check-optional-args-number: Internal macros
Macro, newq: Exported macros
Macro, type-check: Internal macros
make-rational: Internal functions
Method, interval-type-cons: Internal generic functions
Method, interval-type-cons: Internal generic functions
Method, interval-type-cons: Internal generic functions
Method, interval-type-cons: Internal generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, new: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions
Method, type-cons: Exported generic functions

N
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
new: Exported generic functions
newq: Exported macros

R
register-structure-constructor: Exported functions

T
type-check: Internal macros
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions
type-cons: Exported generic functions

Jump to:   C   F   G   I   M   N   R   T  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
S  
Index Entry  Section

*
*coerce-array-elements-p*: Exported special variables
*coerce-numbers-p*: Exported special variables
*default-dummy-hash-table*: Internal special variables
*structure-constructors*: Internal special variables

S
Special Variable, *coerce-array-elements-p*: Exported special variables
Special Variable, *coerce-numbers-p*: Exported special variables
Special Variable, *default-dummy-hash-table*: Internal special variables
Special Variable, *structure-constructors*: Internal special variables

Jump to:   *  
S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   I   N   P   S   T  
Index Entry  Section

I
it.unimib.disco.ma.cl.ext.tac.new-op: The it<dot>unimib<dot>disco<dot>ma<dot>cl<dot>ext<dot>tac<dot>new-op package

N
new-op: The new-op system
numeric-real-types: Internal types

P
Package, it.unimib.disco.ma.cl.ext.tac.new-op: The it<dot>unimib<dot>disco<dot>ma<dot>cl<dot>ext<dot>tac<dot>new-op package

S
System, new-op: The new-op system

T
Type, numeric-real-types: Internal types

Jump to:   I   N   P   S   T