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

The bex arm for taking bex:anoma from the logics core environment.

Can be gotten by defining gate locally as:

=localbex => logics |= a=@ (bex a)

and then grabbing the arm of localbex.

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

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

Can be obtained by defining

=lcmp => logics |= [a=@s b=@s] (cmp [a b])

and computing

.* lcmp [0 2]

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

The counter arm.

Availiable through counter:logics core.

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

A cue arm for taking cue:anoma out of the logics core environment.

Can be gotten by defining gate locally as

=localcue => logics |= 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 => logics |= [a=@ b=@] (dif [a b])

and computing

.* ldif [0 2]

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

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

Can be obtained by defining

=ldul => logics |= [a=@s b=@] (dul [a b])

and computing

.* ldul [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 => logics |= [a=@s b=@s] (fra [a b])

and computing

.* lfra [0 2]

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

A cue arm for taking jam:anoma out of the logics core environment.

Can be gotten by defining gate locally as

=localjam => logics |= 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 => logics |= 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 => logics |= [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 logics core environment.

Can be gotten by defining gate locally as:

=localmat => logics |= 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 => logics |= a=@ met:block

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

The mix arm for taking mix:anoma from the logics core environment.

Can be gotten by defining gate locally as:

=localmix => logics |= [a=@ b=@] (mix [a b])

and then grabbing the arm of locamix.

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

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

Can be obtained by defining

=lnew => logics |= [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 => logics |= [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 => logics |= [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 => logics |= [a=@s b=@s] (pro [a b])

and computing

.* lpro [0 2]

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

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

Can be gotten by defining

=lrad => logics |= [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 => logics |= [a=@ b=@] (~(rads og a) b)

@spec rads_call(non_neg_integer(), non_neg_integer()) :: :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 => logics |= [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 => logics |= [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 => logics |= [rng=_og width=@] (raws:rng width)

and grabbing the arm with [0 2]

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

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

Can be obtained by defining

=lrem => logics |= [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 => logics |= a=@ rsh:block

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

The shax arm for taking shax:anoma from the logics core environment.

Can be gotten by defining gate locally as:

=localshax => logics |= a=@ (shax a)

and then grabbing the arm of localshax.

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

The sign arm for taking sign:anoma from the logics core environment.

Can be gotten by defining gate locally as:

=localsign => logics |= [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 logics core environment.

Can be gotten by defining gate locally as:

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

and then grabbing the arm of localsighdetached.

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

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

Can be gotten by defining locally

=l => logics |= [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 => logics |= [a=@s b=@s] (sum [a b])

and computing

.* lsum [0 2]

@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 => logics |= a=@ luend:block

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

The verify arm for taking verify:anoma from the logics core environment.

Can be gotten by defining gate locally as:

=localverify => logics |= [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 logics core environment.

Can be gotten by defining gate locally as:

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

and then grabbing the arm of localverifydetached.