marianoguerra/pure-py/value

marianoguerra/pure-py/value does not have a README file

Env

type Env = @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]

An environment: ρ. Immutable, because a closure captures one by value.

DefClosure

source

pub(all) struct DefClosure {
  env : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]
  region : Array[@marianoguerra/pure-py/ast.Stmt
Stmt]
  index : Int
} derive(@moonbitlang/core/debug.Debug
Debug)

LamClosure

source

pub(all) struct LamClosure {
  env : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]
  params : Array[String]
  body : @marianoguerra/pure-py/ast.Expr
Expr
} derive(@moonbitlang/core/debug.Debug
Debug)

MatchResult

source

pub(all) enum MatchResult {
  Match(@moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value])
  NoMatch
  MatchStuck(String)
} derive(@moonbitlang/core/debug.Debug
Debug)

Whether a pattern matched, and what it bound.

MatchResult::then

source

fn MatchResult::then(self : MatchResult, other : MatchResult) -> MatchResult

m ⊗ m': a match result composes by union of bindings, and no-match is absorbing.

Outcome

source

pub(all) enum Outcome {
  Val(Value)
  Aborts(Termination)
  Stuck(String)
} derive(@moonbitlang/core/debug.Debug
Debug)

The outcome of evaluating an expression: a value, an abort, or an operation the semantics leaves undefined.

Primitive

source

pub(all) enum Primitive {
  Print
  Len
  Range
  Exit
  Sqrt
  Exp
  Log
  Sin
  Cos
  Tan
  MathFloor
  MathCeil
  Opaque(String)
  Foreign(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The predefined functions of Figure 2.7.

Opaque is for the three members that are values only so that importing them binds something: typing.Any, typing.Callable and dataclasses.dataclass are never called.

StmtResult

source

pub(all) enum StmtResult {
  Assigns(@moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value])
  Returns(Value)
  ResultAborts(Termination)
  ResultStuck(String)
} derive(@moonbitlang/core/debug.Debug
Debug)

The result of evaluating a statement.

StmtResult::outcome

source

fn StmtResult::outcome(self : StmtResult) -> Outcome

outcome(r): a statement's result read as the outcome of calling it.

StmtResult::then

source

fn StmtResult::then(self : StmtResult, other : StmtResult) -> StmtResult

Sequential composition of results: assigns ρ ⊗ r.

Termination

source

pub(all) enum Termination {
  TypeError
  IndexError
  KeyError
  ZeroDivisionError
  AttributeError
  AssertionError(String?)
  SystemExit(@moonbitlang/core/bigint.BigInt
BigInt)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

How a run ends. Every kind but SystemExit is named after the exception the same program raises under Python.

Termination::name

source

fn Termination::name(self : Termination) -> String

The name Python prints for a termination, and the message after it.

Termination::to_text

source

fn Termination::to_text(self : Termination) -> String

AssertionError: message when there is one, the bare name otherwise -- the last line of the traceback Python prints.

Value

source

pub(all) enum Value {
  None
  Bool(Bool)
  Int(@moonbitlang/core/bigint.BigInt
BigInt)
  Float(Double)
  Str(String)
  List(Array[Value])
  Tuple(Array[Value])
  Dict(Array[(String, Value)])
  Lam(LamClosure)
  Def(DefClosure)
  Obj(@marianoguerra/pure-py/context.ClassEntry
ClassEntry, @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value])
  ModStub(String)
  Mod(String, @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value])
  Class(@marianoguerra/pure-py/context.ClassEntry
ClassEntry)
  Prim(Primitive)
} derive(@moonbitlang/core/debug.Debug
Debug)

Runtime values, environments and evaluation results: Figure 4.1.

Two things about this type are the whole shape of the language:

Nothing is mutable. A list, a tuple, a dictionary and an object are built once and never changed, so an environment can be shared by every closure that captures it and nothing has to be copied defensively.
Stuck is a result, not a crash. The semantics leaves some operations undefined, and Chapter 1 allows an implementation either to abort or to produce Python's answer. This one aborts, with the operation named, so that the conformance suite's dynamically excluded bucket is CHECKED rather than merely tolerated.

Value::kind_name

source

fn Value::kind_name(self : Value) -> String

What kind of value this is, for a message naming an undefined operation.

Value::repr

source

fn Value::repr(self : Value) -> String?

Value::str

source

fn Value::str(self : Value) -> String?

Python's str and repr of a value.

The two differ in exactly one place -- a string is itself under str and quoted under repr -- and print uses str while a container prints its elements with repr. Everything else is the same function.

A closure, a module, a class or a primitive has no printable form here. Python prints one with an address in it, which no implementation can reproduce, so printing one is an undefined operation and is reported as such rather than invented.

big_to_double

source

fn big_to_double(n : @moonbitlang/core/bigint.BigInt
BigInt) -> Double

A BigInt as a double, correctly rounded -- which is what Python's float(n) gives. MoonBit's BigInt has no conversion, so it goes through the decimal text, which parse_double rounds correctly.

binop

source

fn binop(op : @marianoguerra/pure-py/ast.Operator
Operator, a : Value, b : Value) -> Outcome

The operators: ⊙̂(v, v') and ⊖̂(v).

Arithmetic is Python's, with three things this port has to supply that MoonBit does not:

// and % floor. MoonBit's / and % on BigInt and Int64 truncate toward zero; Python's floor toward negative infinity, so the remainder takes the sign of the DIVISOR: -7 // 2 is -4 and 7 % -2 is -1.
bool is not a number. True + 1 and True < 2 are undefined, even though Python accepts both. That is the same rule that makes True == 1 undefined, and the conformance suite has a test for it.
An integer and a float compare exactly, not by converting the integer, so a large integer is not made equal to the double nearest it.

The spec leaves arithmetic as "as in Python" with one sentence added: TypeError where an operand is not a number. So "a" + "b" aborts here rather than concatenating. Nothing in the conformance suite reaches it, and the decision is written down rather than guessed at each call site.

compare

source

fn compare(op : @marianoguerra/pure-py/ast.CmpOp
CmpOp, a : Value, b : Value) -> Outcome

==, !=, in, not in and the four orderings.

contains

source

fn contains(haystack : Value, needle : Value) -> Bool?

Whether needle is in haystack: an element of a list or tuple, a key of a dictionary, a substring of a string.

contains_elems

source

fn contains_elems(xs : Array[Value], needle : Value) -> Bool?

elems

source

fn elems(v : Value) -> Array[Value]?

The elements of a list, a tuple or a string. A string's elements are its CODE POINTS, which is what Python iterates.

empty_env

source

fn empty_env() -> @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]

entries

source

fn entries(base : Array[(String, Value)], more : Array[(String, Value)]) -> Array[(String, Value)]

entries(δ, δ'): the left entries extended by the right ones in order.

env_of

source

fn env_of(entries : Array[(String, Value)]) -> @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]

eq

source

fn eq(a : Value, b : Value) -> Bool?

The functions on values of Annex A.3: equality, membership, elements, iteration, subscripting and the dictionary builders.

Equality is PARTIAL, and the order in which elements are compared is therefore observable: eq short-circuits at the first pair that decides the answer, so an undefined comparison later in a sequence does not make the whole comparison undefined. [1, "a"] == [1, 3] is stuck and [1, "a"] == [2, 3] is False, and the difference is deliberate.

Every function that can be undefined returns a Bool? or an Outcome; None and Stuck mean "no rule", not "false".

eq_elems

source

fn eq_elems(xs : Array[Value], ys : Array[Value]) -> Bool?

Elementwise equality, stopping at the first pair that decides it.

exact_integer

source

fn exact_integer(d : Double) -> @moonbitlang/core/bigint.BigInt
BigInt?

The integer a double exactly equals, or None when it is not one.

Read off the bit pattern rather than through decimal text, so it is exact at every magnitude: a double is mantissa * 2^exponent, and when it is integral the shift below loses nothing.

extend_env

source

fn extend_env(a : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value], b : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]) -> @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]

ρ ⊲ ρ': extension, which differs from override only on modules -- a loaded module is preferred to a stub of the same module, and two loadings of one module merge member by member.

extend_value

source

fn extend_value(a : Value, b : Value) -> Value

float_mod

source

fn float_mod(x : Double, y : Double) -> Double

Python's % on floats: the result takes the sign of the divisor.

floor_div

source

fn floor_div(x : @moonbitlang/core/bigint.BigInt
BigInt, y : @moonbitlang/core/bigint.BigInt
BigInt) -> @moonbitlang/core/bigint.BigInt
BigInt

Python's // on integers: floor, not truncation.

floor_mod

source

fn floor_mod(x : @moonbitlang/core/bigint.BigInt
BigInt, y : @moonbitlang/core/bigint.BigInt
BigInt) -> @moonbitlang/core/bigint.BigInt
BigInt

Python's % on integers: the remainder takes the sign of the divisor.

getitem

source

fn getitem(v : Value, key : Value) -> Outcome

Subscripting: a dictionary by a string key, a sequence by an integer index counting from the end when negative.

host_fn

source

fn host_fn(name : String) -> Value

A function the host supplies, as a value the guest can call.

The host puts one of these in a module (@eval.HostModule) and answers calls to it by name.

iter

source

fn iter(v : Value) -> Array[Value]?

What a generator draws from a value: the KEYS of a dictionary, and otherwise its elements.

order

source

fn order(a : Value, b : Value) -> Int?

Three-way comparison, None where the two values have no order.

Numbers with numbers, strings by code point, lists with lists and tuples with tuples lexicographically. A nan anywhere makes the pair unordered, which is how Python's comparisons all come out False.

override_env

source

fn override_env(a : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value], b : @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]) -> @moonbitlang/core/immut/hashmap.HashMap
HashMap[String, Value]

ρ ⊗ ρ': the right-hand side wins outright.

unop

source

fn unop(op : @marianoguerra/pure-py/ast.UnaryOp
UnaryOp, v : Value) -> Outcome

not, unary + and unary -.

update

source

fn update(entries : Array[(String, Value)], key : String, v : Value) -> Array[(String, Value)]

update(δ, w, v): the entries with w bound to v, in place if it was already there and appended otherwise.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Env

#DefClosure

#LamClosure

#MatchResult

#MatchResult::then

#Outcome

#Primitive

#StmtResult

#StmtResult::outcome

#StmtResult::then

#Termination

#Termination::name

#Termination::to_text

#Value

#Value::kind_name

#Value::repr

#Value::str

#big_to_double

#binop

#compare

#contains

#contains_elems

#elems

#empty_env

#entries

#env_of

#eq

#eq_elems

#exact_integer

#extend_env

#extend_value

#float_mod

#floor_div

#floor_mod

#getitem

#host_fn

#iter

#order

#override_env

#unop

#update

Source Files

Env

DefClosure

LamClosure

MatchResult

MatchResult::then

Outcome

Primitive

StmtResult

StmtResult::outcome

StmtResult::then

Termination

Termination::name

Termination::to_text

Value

Value::kind_name

Value::repr

Value::str

big_to_double

binop

compare

contains

contains_elems

elems

empty_env

entries

env_of

eq

eq_elems

exact_integer

extend_env

extend_value

float_mod

floor_div

floor_mod

getitem

host_fn

iter

order

override_env

unop

update