Nock.Jets (Anoma v0.29.0)

Jets for the Nock interpreter, taking a gate core. Not fully general.

Summary

Functions

abs(core)

action_delta(core)

add(core)

bex(core)

calculate_core_param(core_index, gate_index, parent_layer)

calculate_mug_of_core(index_in_core, parent_layer)

We calculate the mug of a given core at a given gate.

calculate_mug_of_layer(layer)

We calculate the mug of a given layer at any given gate.

calculate_mug_of_param_core(index_in_core, core_index, parent_layer)

Like calculate_mug_of_core/2 except we work over a parameterized core.

calculate_mug_of_param_layer(core_index, parent_layer)

Like calculate_mug_of_layer/1 except we work over a parameterized core.

cmp(core)

cue(core)

dec(core)

delta_add(core)

delta_sub(core)

dif(core)

div(core)

dul(core)

fra(core)

gte(core)

gth(core)

jam(core)

lsh(core)

lte(core)

lth(core)

make_delta(core)

met(core)

mix(core)

mod(core)

mul(core)

nend(core)

pro(core)

rem(core)

rsh(core)

sample(arg1)

shax(core)

sign(core)

sign_detatched(core)

sub(core)

sum(core)

sun(core)

syn(core)

verify(core)

verify_detatched(core)

Functions

abs(core)

@spec abs(Noun.t()) :: :error | {:ok, Noun.t()}

action_delta(core)

@spec action_delta(Noun.t()) :: :error | {:ok, Noun.t()}

add(core)

@spec add(Noun.t()) :: :error | {:ok, Noun.t()}

bex(core)

@spec bex(Noun.t()) :: :error | {:ok, Noun.t()}

calculate_core_param(core_index, gate_index, parent_layer)

@spec calculate_core_param(
  non_neg_integer(),
  non_neg_integer(),
  non_neg_integer()
) :: :error | {:ok, Noun.t()}

calculate_mug_of_core(index_in_core, parent_layer)

@spec calculate_mug_of_core(non_neg_integer(), non_neg_integer()) :: non_neg_integer()

We calculate the mug of a given core at a given gate.

Parameters

index_in_core - the index of the gate itself
parent_layer - the layer of the standard library. This should be the same as the layer numbers found in anoma.hoon

Example

In the Hoon repl one should write

dojo> |commit %anoma
>=
dojo> =anoma -build-file /=anoma=/lib/anoma/hoon
dojo> =>  anoma  !=(sub)
[9 47 0 31]

Now in IEX

> Nock.Jets.calculate_mug_of_core(47, 1)
14801825384048474882

calculate_mug_of_layer(layer)

@spec calculate_mug_of_layer(non_neg_integer()) :: non_neg_integer()

We calculate the mug of a given layer at any given gate.

Parameters

parent_layer - the layer of the standard library. This should be the same as the layer numbers found in anoma.hoon

Example

In the Hoon repl one should write

dojo> |commit %anoma
>=
dojo> =anoma -build-file /=anoma=/lib/anoma/hoon
dojo> =>  anoma  !=(sub)
[9 47 0 31]

Now in IEX

> Nock.Jets.calculate_mug_of_layer(1)
17654928022549292273

This value should match Nock.@layer_1_contex_mug

calculate_mug_of_param_core(index_in_core, core_index, parent_layer)

@spec calculate_mug_of_param_core(
  non_neg_integer(),
  non_neg_integer(),
  non_neg_integer()
) :: non_neg_integer()

Like calculate_mug_of_core/2 except we work over a parameterized core.

Example

> Nock.Jets.calculate_mug_of_param_core(767, 10, 4)
12605872635346981159

For our standard library, so far only layer 4 is parameterized

calculate_mug_of_param_layer(core_index, parent_layer)

@spec calculate_mug_of_param_layer(non_neg_integer(), non_neg_integer()) ::
  non_neg_integer()

Like calculate_mug_of_layer/1 except we work over a parameterized core.

Example

> Nock.Jets.calculate_mug_of_param_layer(10, 4)
11284470320276584209

For our standard library, so far only layer 4 is parameterized

cmp(core)

@spec cmp(Noun.t()) :: :error | {:ok, Noun.t()}

cue(core)

@spec cue(Noun.t()) :: :error | {:ok, Noun.t()}

dec(core)

@spec dec(Noun.t()) :: :error | {:ok, Noun.t()}

delta_add(core)

@spec delta_add(Noun.t()) :: :error | {:ok, Noun.t()}

delta_sub(core)

@spec delta_sub(Noun.t()) :: :error | {:ok, Noun.t()}

dif(core)

@spec dif(Noun.t()) :: :error | {:ok, Noun.t()}

div(core)

@spec div(Noun.t()) :: :error | {:ok, Noun.t()}

dul(core)

@spec dul(Noun.t()) :: :error | {:ok, Noun.t()}

fra(core)

@spec fra(Noun.t()) :: :error | {:ok, Noun.t()}

gte(core)

@spec gte(Noun.t()) :: :error | {:ok, Noun.t()}

gth(core)

@spec gth(Noun.t()) :: :error | {:ok, Noun.t()}

jam(core)

@spec jam(Noun.t()) :: :error | {:ok, Noun.t()}

lsh(core)

@spec lsh(Noun.t()) :: :error | {:ok, Noun.t()}

lte(core)

@spec lte(Noun.t()) :: :error | {:ok, Noun.t()}

lth(core)

@spec lth(Noun.t()) :: :error | {:ok, Noun.t()}

make_delta(core)

@spec make_delta(Noun.t()) :: :error | {:ok, Noun.t()}

met(core)

@spec met(Noun.t()) :: :error | {:ok, Noun.t()}

mix(core)

@spec mix(Noun.t()) :: :error | {:ok, Noun.t()}

mod(core)

@spec mod(Noun.t()) :: :error | {:ok, Noun.t()}

mul(core)

@spec mul(Noun.t()) :: :error | {:ok, Noun.t()}

nend(core)

@spec nend(Noun.t()) :: :error | {:ok, Noun.t()}

pro(core)

@spec pro(Noun.t()) :: :error | {:ok, Noun.t()}

rem(core)

@spec rem(Noun.t()) :: :error | {:ok, Noun.t()}

rsh(core)

@spec rsh(Noun.t()) :: :error | {:ok, Noun.t()}

sample(arg1)

@spec sample(Noun.t()) :: :error | {:ok, Noun.t()}

shax(core)

@spec shax(Noun.t()) :: :error | {:ok, Noun.t()}

sign(core)

@spec sign(Noun.t()) :: :error | {:ok, binary()}

sign_detatched(core)

@spec sign_detatched(Noun.t()) :: :error | {:ok, binary()}

sub(core)

@spec sub(Noun.t()) :: :error | {:ok, Noun.t()}

sum(core)

@spec sum(Noun.t()) :: :error | {:ok, Noun.t()}

sun(core)

@spec sun(Noun.t()) :: :error | {:ok, Noun.t()}

syn(core)

@spec syn(Noun.t()) :: :error | {:ok, Noun.t()}

verify(core)

@spec verify(Noun.t()) :: :error | {:ok, binary()}

verify_detatched(core)

@spec verify_detatched(Noun.t()) :: :error | {:ok, 0 | 1}