@spec bex_arm() :: Noun.t()

The bex arm for taking bex:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localbex => resource-machine |= a=@ (bex a)

and then grabbing the arm of localbex.

@spec by_arm() :: Noun.t()

The gate representing a by core creation with a specified set.

Can be gotten by defining

=l => resource-machine |= a=(set) ~(. by a)

and getting it's arm with [0 2]

@spec cmp_arm() :: Noun.t()

I represent the cmp gate call as a 2-argument gate.

Can be obtained by defining

=lcmp => resource-machine |= [a=@s b=@s] (cmp [a b])

and computing

.* lcmp [0 2]

@spec copy_a_to_b() :: Noun.t()

Nock program for copying value from "a" to "b". Used in EShardBackend tests.

@spec counter_arm() :: Noun.t()

The counter arm.

Availiable through counter:logics core.

@spec crash_after_reserve_a() :: Noun.t()

Nock program that reserves write on 'a', then crashes. Used in EShardBackend tests.

@spec cue_arm() :: Noun.t()

A cue arm for taking cue:anoma out of the resource-machine core environment.

Can be gotten by defining gate locally as

=localcue => resource-machine |= a=@ (cue a)

and then grabbing the arm of localcue.

@spec dec_arm() :: Noun.t()

The decrement arm in the tests core.

Availiable through use-dec:tests core.

@spec dif_arm() :: Noun.t()

I represent the dif gate call as a 2-argument gate.

Can be obtained by defining

=ldif => resource-machine |= [a=@ b=@] (dif [a b])

and computing

.* ldif [0 2]

@spec dif_with_core() :: Noun.t()

I represent a dif gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (dif:a b)

and grabbing the arm with [0 2]

@spec dor_arm() :: Noun.t()

I represent the dor gate call.

Can be obtained by defining

=ldor => resource-machine |= [a= b=] (dor a b)

and computing

.* ldor [0 2]

@spec dor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full dor gate with specified sample and resource-machine context.

@spec dul_arm() :: Noun.t()

I represent the dul gate call as a 2-argument gate.

Can be obtained by defining

=ldul => resource-machine |= [a=@s b=@] (dul [a b])

and computing

.* ldul [0 2]

@spec duni_with_core() :: Noun.t()

I represent a duni gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (duni:a b)

and grabbing the arm with [0 2]

@spec factorial_arm() :: Noun.t()

I am the battery of the fib:tests gate of the anoma stadard library.

You can dump me by calling

.* fib:tests [0 2]

@spec fra_arm() :: Noun.t()

I represent the fra gate call as a 2-argument gate.

Can be obtained by defining

=lfra => resource-machine |= [a=@s b=@s] (fra [a b])

and computing

.* lfra [0 2]

@spec gor_arm() :: Noun.t()

I represent the gor gate call.

Can be obtained by defining

=lgor => resource-machine |= [a= b=] (gor a b)

and computing

.* lgor [0 2]

@spec gor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full gor gate with specified sample and resource-machine context.

@spec got_with_core() :: Noun.t()

I represent a got gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_by b=*] (got:a b)

and grabbing the arm with [0 2]

@spec has_with_core() :: Noun.t()

I represent a has gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (has:a b)

and grabbing the arm with [0 2]

@spec in_arm() :: Noun.t()

The gate representing an in core creation with a specified set.

Can be gotten by defining

=l => resource-machine |= a=(set) ~(. in a)

and getting it's arm with [0 2]

@spec int_with_core() :: Noun.t()

I represent an int gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (int:a b)

and grabbing the arm with [0 2]

@spec jam_arm() :: Noun.t()

A cue arm for taking jam:anoma out of the resource-machine core environment.

Can be gotten by defining gate locally as

=localjam => resource-machine |= a=@ (jam a)

and then grabbing the arm of localjam.

@spec lsh0() :: Noun.t()

I evaluate lsh at block size 0 and gate-input [2 6].

lsh(0) evaluates the gate of the block door at block size 0, [6 1 2 6] replaces the sample with [2 6].

@spec lsh1() :: Noun.t()

I evaluate lsh at block size 1 and gate-input [2 6].

lsh(1) evaluates the gate of the block door at block size 1, [6 1 2 6] replaces the sample with [2 6].

@spec lsh2() :: Noun.t()

I evaluate lsh at block size 1 and gate-input [2 6].

lsh(2) evaluates the gate of the block door at block size 2, [6 1 2 6] replaces the sample with [2 6].

@spec lsh(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =llsh => resource-machine |= a=@ lsh:block

@spec lte_arm() :: Noun.t()

I represent the lte gate call as a 2-argument gate.

Can be obtained by defining

=llte => resource-machine |= [a=@s b=@s] (lte [a b])

and computing

.* llte [0 2]

@spec mat_arm() :: Noun.t()

The mat arm for taking mat:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localmat => resource-machine |= a (mat a)

and then grabbing the arm of locamix.

@spec met0() :: Noun.t()

I evaluate met at block size 0 and gate-input 28.

met(0) evaluates the gate of the block door at block size 0, [6 1 28] replaces the sample with 28.

@spec met1() :: Noun.t()

I evaluate met at block size 1 and gate-input 28.

met(1) evaluates the gate of the block door at block size 1, [6 1 28] replaces the sample with 28.

@spec met2() :: Noun.t()

I evaluate met at block size 2 and gate-input 28.

met(2) evaluates the gate of the block door at block size 2, [6 1 28] replaces the sample with 28.

@spec met(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =lmet => resource-machine |= a=@ met:block

@spec mix_arm() :: Noun.t()

The mix arm for taking mix:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localmix => resource-machine |= [a=@ b=@] (mix [a b])

and then grabbing the arm of locamix.

@spec mor_arm() :: Noun.t()

I represent the mor gate call.

Can be obtained by defining

=lmor => resource-machine |= [a= b=] (mor a b)

and computing

.* lmor [0 2]

@spec mor_call(Noun.t(), Noun.t()) :: Noun.t()

I am the full mor gate with specified sample and resource-machine context.

@spec mput_with_core() :: Noun.t()

I represent a put gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_by b=(pair)] (put:a b)

and grabbing the arm with [0 2]

@spec mug_arm() :: Noun.t()

I represent the mug gate call.

Can be obtained by defining

=lmug => resource-machine |= a=* (mug a)

and computing

.* lmug [0 2]

@spec mug_call(Noun.t()) :: Noun.t()

I am the full mug gate with specified sample and resource-machine context.

@spec new_arm() :: Noun.t()

I represent the new gate call as a 2-argument gate.

Can be obtained by defining

=lnew => resource-machine |= [a=? b=@] (new [a b])

and computing

.* lnew [0 2]

@spec og_arm() :: Noun.t()

The gate representing an og core creation with a specified seed.

Can be gotten by defining

=l => resource-machine |= [seed=@] ~(. og seed)

and getting it's arm with [0 2]

@spec old_arm() :: Noun.t()

I represent the old gate call as a 2-argument gate.

Can be obtained by defining

=lold => resource-machine |= [a=@s] (old a)

and computing

.* lold [0 2]

@spec pro_arm() :: Noun.t()

I represent the pro gate call as a 2-argument gate.

Can be obtained by defining

=lpro => resource-machine |= [a=@s b=@s] (pro [a b])

and computing

.* lpro [0 2]

@spec put_with_core() :: Noun.t()

I represent a put gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=*] (put:in b)

and grabbing the arm with [0 2]

@spec rad_arm() :: Noun.t()

I represent the rad gate call as a 2-argument gate.

Can be gotten by defining

=lrad => resource-machine |= [a=@ b=@] (~(rad og a) b)

@spec rad_call(any(), non_neg_integer()) :: {:ok, Noun.t()}

I am function calling the rad gate of the og door with specified seed and range

@spec rads_arm() :: Noun.t()

I represent the rads gate call as a 2-argument gate.

Can be gotten by defining

=lrad => resource-machine |= [a=@ b=@] (~(rads og a) b)

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

I am function calling the rads gate of the og door with specified seed and range

@spec raw_arm() :: Noun.t()

I represent the raw gate call as a 2-argument gate.

Can be gotten by defining

=lraw => resource-machine |= [a=@ b=@] (~(raw og a) b)

@spec raw_call(Noun.t(), Noun.t()) :: {:ok, Noun.t()}

I am function calling the raw gate of the og door with specified seed and bitwidth.

@spec raws_arm() :: Noun.t()

I represent the raws gate call as a 2-argument gate.

Can be gotten by defining

=lraw => resource-machine |= [a=@ b=@] (~(raws og a) b)

@spec raws_call(Noun.t(), Noun.t()) :: {:ok, Noun.t()}

I am function calling the raws gate of the og door with specified seed and bitwidth.

@spec raws_with_core() :: Noun.t()

I represent a raws gate with a specified instantiated og core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [rng=_og width=@] (raws:rng width)

and grabbing the arm with [0 2]

@spec read_ab_write_c_sum() :: Noun.t()

Nock program for reading "a", "b", adding, and writing sum to "c". Used in EShardBackend tests.

@spec rem_arm() :: Noun.t()

I represent the rem gate call as a 2-argument gate.

Can be obtained by defining

=lrem => resource-machine |= [a=@s b=@s] (rem [a b])

and computing

.* lrem [0 2]

@spec rsh0() :: Noun.t()

I evaluate rsh at block size 0 and gate-input [2 40].

rsh(0) evaluates the gate of the block door at block size 0, [6 1 2 40] replaces the sample with [2 40].

@spec rsh1() :: Noun.t()

I evaluate rsh at block size 1 and gate-input [2 40].

rsh(1) evaluates the gate of the block door at block size 1, [6 1 2 40] replaces the sample with [2 40].

@spec rsh2() :: Noun.t()

I evaluate rsh at block size 2 and gate-input [2 40].

rsh(2) evaluates the gate of the block door at block size 2, [6 1 1 40] replaces the sample with [1 40].

@spec rsh(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =rsh => resource-machine |= a=@ rsh:block

@spec run_with_core() :: Noun.t()

I represent the run gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=gate] (run:a b)

and grabbing the arm with [0 2]

@spec shax_arm() :: Noun.t()

The shax arm for taking shax:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localshax => resource-machine |= a=@ (shax a)

and then grabbing the arm of localshax.

@spec sign_arm() :: Noun.t()

The sign arm for taking sign:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localsign => resource-machine |= [a=@ b=@] (sign [a b])

and then grabbing the arm of localsign.

@spec sign_detatched_arm() :: Noun.t()

The sign-detatched arm for taking sign-detached:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localsigndetached => resource-machine |= [a=@ b=@] (sign-detached [a b])

and then grabbing the arm of localsighdetached.

@spec silt_arm() :: Noun.t()

I represent the mor gate call.

Can be obtained by defining

=lsilt => resource-machine |= a=(list) (silt a)

and computing

.* lsilt [0 2]

@spec split_arm() :: Noun.t()

I represent a split gate call given an og core with seed.

Can be gotten by defining locally

=l => resource-machine |= [rng=_og] split:rng

and grabbing the arm with [0 2]

@spec sum_arm() :: Noun.t()

I represent the sum gate call as a 2-argument gate.

Can be obtained by defining

=lsum => resource-machine |= [a=@s b=@s] (sum [a b])

and computing

.* lsum [0 2]

@spec tap_by_with_core() :: Noun.t()

I represent a tap:by call with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_by tap:a

and grabbing the arm with [0 2]

@spec tap_in_with_core() :: Noun.t()

I represent a tap:in call with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_in tap:a

and grabbing the arm with [0 2]

@spec test_nock_program_tx1() :: :ok

I test a Nock program for writing 3 to "a".

I verify stage 1 (reservation/code split) and stage 2 (execution).

@spec test_nock_program_tx3() :: :ok

I test a Nock program for the sequence (read a, read b, add a and b, write result to c).

I verify stage 1 (reservation/code split) and stage 2 (execution with mock scry).

@spec uend0() :: Noun.t()

I evaluate uend at block size 0 and gate-input [5 80].

uend(0) evaluates the gate of the block door at block size 0, [6 1 5 80] replaces the sample with [5 80].

@spec uend1() :: Noun.t()

I evaluate uend at block size 1 and gate-input [3 80] and [4 80].

uend(1) evaluates the gate of the block door at block size 1, [6 1 3 80] replaces the sample with [3 80], [6 1 4 80] replaces the sample with [3 80]

@spec uend(Noun.t()) :: Noun.t()

I am an lash arm in the block door.

My index inside the door can be seen by asking to dump the logic of =luend => resource-machine |= a=@ luend:block

@spec uni_with_core() :: Noun.t()

I represent a uni gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= [a=_in b=(set)] (uni:a b)

and grabbing the arm with [0 2]

@spec verify_arm() :: Noun.t()

The verify arm for taking verify:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localverify => resource-machine |= [a=@ b=@] (verify [a b])

and then grabbing the arm of localverify.

@spec verify_detatched_arm() :: Noun.t()

The verify-detatched arm for taking verify-detached:anoma from the resource-machine core environment.

Can be gotten by defining gate locally as:

=localverifydetached => resource-machine |= [a=@ b=@ c=@] (verify-detached [a b])

and then grabbing the arm of localverifydetached.

@spec wyt_with_core() :: Noun.t()

I represent a wyt gate with a specified instantiated in core given as an extra argument.

Can be gotten by defining locally

=l => resource-machine |= a=_in wyt:a

and grabbing the arm with [0 2]