metadsl_core

Core data types and replacements for metadsl

class metadsl_core.Abstraction(function, args, kwargs)[source]
args: List[object]
create(cls, var, body) = Abstraction.create[source]
create_variable(cls, variable) = Abstraction.create_variable[source]
static fix(fn)[source]

Fixed pointer operator, used to define recursive functions.

Return type

TypeVar(T)

from_fn(cls, fn) = Abstraction.from_fn[source]
function: Callable
kwargs: Dict[str, object]
unfix(self) = Abstraction.unfix[source]
class metadsl_core.Boolean(function, args, kwargs)[source]
and_(self, other) = Boolean.and_[source]
args: List[object]
create(cls, b) = Boolean.create[source]
false(cls) = Boolean.false[source]
function: Callable
if_(self, true, false) = Boolean.if_[source]
kwargs: Dict[str, object]
or_(self, other) = Boolean.or_[source]
true(cls) = Boolean.true[source]
class metadsl_core.Converter(function, args, kwargs)[source]
args: List[object]
convert(cls, value) = Converter.convert[source]
function: Callable
kwargs: Dict[str, object]
class metadsl_core.Either(function, args, kwargs)[source]
args: List[object]
function: Callable
kwargs: Dict[str, object]
left(cls, value) = Either.left[source]
match(self, left, right) = Either.match[source]
right(cls, value) = Either.right[source]
class metadsl_core.FunctionOne(function, args, kwargs)[source]

Function with one arg.

abstraction(self) = FunctionOne.abstraction[source]
args: List[object]
create(cls, name, val) = FunctionOne.create[source]
from_fn(cls, fn, name=metadsl_core.maybe.Maybe[str](Maybe.nothing, [], {})) = FunctionOne.from_fn[source]
from_fn_recursive(cls, fn) = FunctionOne.from_fn_recursive[source]
function: Callable
kwargs: Dict[str, object]
name(self) = FunctionOne.name[source]
unfix(self) = FunctionOne.unfix[source]
class metadsl_core.FunctionThree(function, args, kwargs)[source]

Function with three args.

abstraction(self) = FunctionThree.abstraction[source]
args: List[object]
create(cls, name, val) = FunctionThree.create[source]
from_fn(cls, fn) = FunctionThree.from_fn[source]
from_fn_recursive(cls, fn) = FunctionThree.from_fn_recursive[source]
function: Callable
kwargs: Dict[str, object]
name(self) = FunctionThree.name[source]
unfix(self) = FunctionThree.unfix[source]
class metadsl_core.FunctionTwo(function, args, kwargs)[source]

Function with two args.

abstraction(self) = FunctionTwo.abstraction[source]
args: List[object]
create(cls, name, val) = FunctionTwo.create[source]
from_fn(cls, fn) = FunctionTwo.from_fn[source]
from_fn_recursive(cls, fn) = FunctionTwo.from_fn_recursive[source]
function: Callable
kwargs: Dict[str, object]
name(self) = FunctionTwo.name[source]
unfix(self) = FunctionTwo.unfix[source]
class metadsl_core.FunctionZero(function, args, kwargs)[source]

Function with zero args.

args: List[object]
create(cls, name, val) = FunctionZero.create[source]
from_fn(cls, fn) = FunctionZero.from_fn[source]
function: Callable
kwargs: Dict[str, object]
name(self) = FunctionZero.name[source]
property value: metadsl_core.function.T
Return type

TypeVar(T)

class metadsl_core.Integer(function, args, kwargs)[source]
args: List[object]
eq(self, other) = Integer.eq[source]
fold(self, initial, fn) = Integer.fold[source]
from_int(cls, i) = Integer.from_int[source]
function: Callable
inc(self) = Integer.inc[source]
infinity(cls) = Integer.infinity[source]
kwargs: Dict[str, object]
one(cls) = Integer.one[source]
zero(cls) = Integer.zero[source]
class metadsl_core.Maybe(function, args, kwargs)[source]

An optional value.

args: List[object]
default(self, value) = Maybe.default[source]
flat_map(self, just) = Maybe.flat_map[source]
function: Callable
just(cls, value) = Maybe.just[source]
kwargs: Dict[str, object]
map(self, just) = Maybe.map[source]
match(self, nothing, just) = Maybe.match[source]
nothing(cls) = Maybe.nothing[source]
class metadsl_core.Pair(function, args, kwargs)[source]
args: List[object]
create(cls, left, right) = Pair.create[source]
function: Callable
kwargs: Dict[str, object]
left(self) = Pair.left[source]
right(self) = Pair.right[source]
set_left(self, left) = Pair.set_left[source]
set_right(self, right) = Pair.set_right[source]
property spread: Tuple[metadsl_core.pair.T, metadsl_core.pair.U]
Return type

Tuple[TypeVar(T), TypeVar(U)]

class metadsl_core.Selection(function, args, kwargs)[source]

A selection represents a mapping from a vector to a new vector, that includes some subset of the old values, but in new positions. Old values can be duplicated.

args: List[object]
create_indices(cls, indices) = Selection.create_indices[source]
create_slice(cls, start, stop, step) = Selection.create_slice[source]
create_slice_optional(cls, start, stop, step) = Selection.create_slice_optional[source]
function: Callable
kwargs: Dict[str, object]
length(self, old_length) = Selection.length[source]
new_to_old(self, idx) = Selection.new_to_old[source]
old_to_new(self, idx) = Selection.old_to_new[source]
class metadsl_core.Variable[source]

should only be equal to itself

class metadsl_core.Vec(function, args, kwargs)[source]

A tuple of homogonous types.

append(self, x) = Vec.append[source]
args: List[object]
create(cls, *items) = Vec.create[source]
create_fn(cls, length, fn) = Vec.create_fn[source]
drop(self, i) = Vec.drop[source]
empty(self) = Vec.empty[source]
first(self) = Vec.first[source]
fold(self, initial, fn) = Vec.fold[source]
function: Callable
kwargs: Dict[str, object]
length(self) = Vec.length[source]
lift_maybe(cls, vec) = Vec.lift_maybe[source]
map(self, fn) = Vec.map[source]
select(self, selection) = Vec.select[source]
set(self, i, value) = Vec.set[source]
set_selection(self, s, values) = Vec.set_selection[source]
take(self, i) = Vec.take[source]
metadsl_core.collapse_maybe(x)[source]
Return type

Maybe[TypeVar(T)]

metadsl_core.register_convert(item: T) T
metadsl_core.register_core(item: T) T
metadsl_core.register_ds(item: T) T