Python make_tuple_type 예제들

예제 #1

파일: test_escape_analysis.py 프로젝트: Tillsten/parakeet

from parakeet import Int64, make_tuple_type
from parakeet.analysis.escape_analysis import EscapeAnalysis
from parakeet.syntax import Tuple, Var, TypedFn, Assign, Return, TupleProj, zero_i64, one_i64
from parakeet.testing_helpers import run_local_tests


tuple_t = make_tuple_type((Int64, Int64))
nested_tuple_t = make_tuple_type((tuple_t, tuple_t))

a_var = Var("a", type=Int64)
b_var = Var("b", type=tuple_t)
c_var = Var("c", type=tuple_t)
d_var = Var("d", type=nested_tuple_t)
e_var = Var("e", type=nested_tuple_t)
body = [
    Assign(a_var, one_i64),
    Assign(b_var, Tuple(elts=(zero_i64, a_var), type=tuple_t)),
    Assign(c_var, Tuple(elts=(TupleProj(b_var, 0, type=Int64), a_var), type=tuple_t)),
    Assign(d_var, Tuple(elts=(b_var, b_var), type=nested_tuple_t)),
    Assign(e_var, Tuple(elts=(c_var, c_var), type=nested_tuple_t)),
    Return(d_var),
]
tenv = {"a": Int64, "b": tuple_t, "c": tuple_t, "d": nested_tuple_t, "e": nested_tuple_t}

fn = TypedFn(
    name="test_escape_analysis", type_env=tenv, input_types=(), arg_names=(), body=body, return_type=nested_tuple_t
)


def test_escape_analysis():
    escape_analysis = EscapeAnalysis()

예제 #2

파일: test_escape_analysis.py 프로젝트: iskandr/parakeet

from parakeet import Int64, make_tuple_type, make_array_type
from parakeet.analysis.escape_analysis import EscapeAnalysis
from parakeet.syntax import Tuple, Var, TypedFn, Assign, Return, Array, TupleProj, zero_i64, one_i64
from parakeet.testing_helpers import run_local_tests

array_t = make_array_type(Int64, 1)
tuple_t = make_tuple_type((Int64, array_t))
nested_tuple_t = make_tuple_type((tuple_t, tuple_t))
array_const = Array([one_i64], type=array_t)

a_int = Var("a_int", type=Int64)
b_array = Var("b_array", type=array_t)
c_tuple = Var("c_tuple", type=tuple_t)
d_tuple = Var("d_tuple", type=tuple_t)
e_nested_tuple = Var("e_nested_tuple", type=nested_tuple_t)
f_nested_tuple = Var("f_nested_tuple", type=nested_tuple_t)
body = [
    Assign(a_int, one_i64),
    Assign(b_array, array_const),
    Assign(c_tuple, Tuple(elts=(a_int, b_array), type=tuple_t)),
    Assign(d_tuple, Tuple(elts=(a_int, array_const), type=tuple_t)),
    Assign(e_nested_tuple, Tuple(elts=(c_tuple, c_tuple),
                                 type=nested_tuple_t)),
    Assign(f_nested_tuple, Tuple(elts=(d_tuple, d_tuple),
                                 type=nested_tuple_t)),
    Return(b_array)
]
tenv = {
    "a_int": Int64,
    "b_array": array_t,
    "c_tuple": tuple_t,

예제 #3

파일: test_escape_analysis.py 프로젝트: Abramovuch/parakeet

from parakeet import Int64, make_tuple_type, make_array_type
from parakeet.analysis.escape_analysis import EscapeAnalysis
from parakeet.syntax import Tuple, Var, TypedFn, Assign, Return, Array, TupleProj, zero_i64, one_i64
from parakeet.testing_helpers import run_local_tests   

 

array_t = make_array_type(Int64, 1)
tuple_t = make_tuple_type((Int64, array_t))
nested_tuple_t = make_tuple_type((tuple_t, tuple_t))
array_const = Array([one_i64], type = array_t)

a_int = Var("a_int", type = Int64)
b_array = Var("b_array", type = array_t)
c_tuple = Var("c_tuple", type = tuple_t)
d_tuple = Var("d_tuple", type = tuple_t)
e_nested_tuple = Var("e_nested_tuple", type= nested_tuple_t)
f_nested_tuple = Var("f_nested_tuple", type = nested_tuple_t)
body = [
  Assign(a_int, one_i64),  
  Assign(b_array, array_const), 
  Assign(c_tuple, Tuple(elts = (a_int, b_array), type = tuple_t)),
  Assign(d_tuple, Tuple(elts = (a_int, array_const), type = tuple_t)),
  Assign(e_nested_tuple, Tuple(elts = (c_tuple, c_tuple), type = nested_tuple_t)),
  Assign(f_nested_tuple, Tuple(elts = (d_tuple, d_tuple), type = nested_tuple_t)),  
  Return(b_array) 
]
tenv = { "a_int": Int64, 
         "b_array": array_t,