Пример 1

Вызов op(object) возвращает все операнды:

op([a, b, c, [d, e], x + y])

op(a + b + c^d)

op(f(x1, x2, x3))

Пример 2

Вызов op(object, i) извлечения один операнд:

op([a, b, c, [d, e], x + y], 4)

op(a + b + c^d, 3)

op(f(x1, x2, x3), 2)

Пример 3

Вызов op(object, i..j) извлекает область значений операндов:

op([a, b, c, [d, e], x + y], 3..5)

op(a + b + c^d, 2..3)

op(f(x1, x2, x3), 2..3)

Область значений может включать 0-th операнд, если это существует:

op(a + b + c^d, 0..2)

op(f(x1, x2, x3), 0..2)

Пример 4

Вызов op(object, [i1, i2, ...]) задает подоперанды:

op([a, b, c, [d, e], x + y], [4, 1])

op(a + b + c^d, [3, 2])

op(f(x1, x2, x3 + 17), [3, 2])

Также диапазоны подоперандов могут быть указаны:

op([a, b, c, [d, e], x + y], [4..5, 2])

op(a + b + c^d, [2..3, 1])

op(f(x1, x2, x3 + 17), [2..3, 1])

Пример 5

Несуществующие операнды возвращены как FAIL:

op([a, b, c, [d, e], x + y], 8), op(a + b + c^d, 4),
op(f(x1, x2, x3), 4)

Пример 6

Для выражений типа DOM_EXPR, 0-th операнд является “оператором” соединение других операндов:

op(a + b + c, 0), op(a*b*c, 0), op(a^b, 0), op(a[1, 2], 0)

Для символьных вызовов функции это - имя функции:

op(f(x1, x2, x3), 0), op(sin(x + y), 0), op(besselJ(0, x), 0)

0-th операнд массива является последовательностью, состоящей из размерности массива и области значений для каждого индекса массива:

op(array(3..100), 0)

op(array(1..2, 1..3, 2..4), 0)

op(hfarray(3..100), 0)

op(hfarray(1..2, 1..3, 2..4), 0)

Никакой 0-th операнд не существует для других областей ядра:

op([1, 2, 3], 0), op({1, 2, 3}, 0), op(table(1 = y), 0)

Пример 7

Для областей библиотеки, op является сверхзагружаемым. Во-первых, новый доменный d задан через newDomain. "new" метод служит для создания элементов этого типа. Внутреннее представление области является списком всех аргументов этого "new" метод:

d := newDomain("d"):  d::new := () -> new(dom, [args()]):

"op" метод этой области задан. Это должно возвратить элементы отсортированной копии внутреннего списка, к которому получают доступ через extop:

d::op := proc(x, i = null())
           local internalList;
         begin
           internalList := extop(x, 1);
           op(sort(internalList), i)
         end_proc:

Путем перегрузки этот метод называется когда операнды объекта типа d требуются через op:

e := d(3, 7, 1):
op(e);
op(e, 2);
op(e, 1..2)

delete d, e:

Пример 8

Идентификаторы, целые числа, действительные числа с плавающей запятой, символьные строки и булевы константы являются “атомарными” объектами. Единственный операнд является самим объектом:

op(x), op(17), op(0.1234), op("Hello World!")

Для рациональных чисел операнды являются числителем и знаменателем:

op(17/3)

Для комплексных чисел операнды являются действительной частью и мнимой частью:

op(17 - 7/3*I)

Пример 9

Для наборов, op возвращает элементы согласно внутреннему порядку. Обратите внимание на то, что этот порядок может отличаться от упорядоченного расположения, с которым наборы распечатаны на экране:

s := {i^2 $ i = 1..19}

op(s)

Индексный доступ к элементам набора использует упорядоченное расположение, видимое на экране:

s[1], s[2], s[3]

Обратите внимание на то, что доступ к элементам набора через op намного быстрее, чем индексируемые вызовы:

s := {sqrt(i) $ i = 1..500}:
time([op(s)])/time([s[i] $ i = 1..nops(s)]);

delete s:

Пример 10

Операнды списка являются его записями:

op([a, b, c, [d, e]])

op([[a11, a12], [a21, a22]], [2, 1])

Пример 11

Внутренне, операнды массивов и hfarrays формируют “линейную” последовательность, содержащую все записи:

op(array(1..2, 1..2, [[11, 12], [21, 22]]))

op(hfarray(1..2, 1..2, [[11, 12], [21, 22]]))

Неопределенные записи возвращены как NIL:

op(array(1..2, 1..2))

Пример 12

Операнды таблицы состоят из уравнений, связывающих индексы и соответствующие записи:

T := table((1, 2) = x + y, "diff(sin)" = cos, a = b)

op(T)

delete T:

Пример 13

Последовательности выражения не сглажены:

op((a, b, c), 2)

Обратите внимание, однако, что аргументы передали op оценены. В следующем вызове, оценке x сглаживает этот объект:

x := hold((1, 2), (3, 4)):  op(x, 1)

Используйте val предотвратить упрощение x:

op(val(x), 1)

delete x:

Возвращаемые значения

последовательность операндов или требуемого операнда. FAIL возвращен, если никакой соответствующий операнд не существует.

Перегруженный

object