def do_prepare(self):
super(Map, self).do_prepare()
self.filter_expr = check_type(
self.filter_fn, types.FunctionType,
"Filter expression passed to a collection expression must be a "
"lambda or a function"
)(self.element_var)
self.take_while_expr = check_type(
self.take_while_pred, types.FunctionType,
"Take while expression passed to a collection expression must be a"
" lambda or a function"
)(self.element_var)
# If the element transformation function is actually the built-in
# identity function, try instead to get the source name of the loop
# variable from the other functions.
if self.element_var.source_name is None:
for fn in (self.filter_fn, self.take_while_pred):
if fn not in builtin_collection_functions:
argspec = inspect.getargspec(fn)
self.element_var.source_name = names.Name.from_lower(
argspec.args[0]
)
break
def do_prepare(self):
super(Map, self).do_prepare()
self.filter_expr = check_type(
self.filter_fn, types.FunctionType,
"Filter expression passed to a collection expression must be a "
"lambda or a function")(self.element_var)
self.take_while_expr = check_type(
self.take_while_pred, types.FunctionType,
"Take while expression passed to a collection expression must be a"
" lambda or a function")(self.element_var)
def do_prepare(self):
super(Map, self).do_prepare()
self.filter_expr = check_type(
self.filter_fn, types.FunctionType,
"Filter expression passed to a collection expression must be a "
"lambda or a function"
)(self.element_var)
self.take_while_expr = check_type(
self.take_while_pred, types.FunctionType,
"Take while expression passed to a collection expression must be a"
" lambda or a function"
)(self.element_var)
def construct(self):
array_1 = construct(self.array_1)
array_2 = construct(self.array_2)
# TODO: We don't use the type param to construct because construct will
# try to cast arrays to the base array type. Would be better if
# construct handled that correctly.
check_type(array_1.type, ArrayType)
check_type(array_2.type, ArrayType)
check_multiple([
(array_1.type == array_2.type,
"Got different array element types in concat: {} and {}".format(
array_1.type.element_type().name(),
array_2.type.element_type().name())),
])
return BuiltinCallExpr("Concat", array_1.type, [array_1, array_2],
"Concat_Result")
def construct(self):
array_1 = construct(self.array_1)
array_2 = construct(self.array_2)
# TODO: We don't use the type param to construct because construct will
# try to cast arrays to the base array type. Would be better if
# construct handled that correctly.
check_type(array_1.type, ArrayType)
check_type(array_2.type, ArrayType)
check_multiple([
(array_1.type == array_2.type,
"Got different array element types in concat: {} and {}".format(
array_1.type.element_type().name(),
array_2.type.element_type().name()
)),
])
return BuiltinCallExpr(
"Concat", array_1.type, [array_1, array_2], "Concat_Result"
)
def prepare_iter_function(
self,
what: str,
expr_fn: Union[Callable[[AbstractExpression], AbstractExpression],
Callable[[AbstractExpression, AbstractExpression],
AbstractExpression]]
) -> AbstractExpression:
"""
Validate an iteration function, whether it only takes the iteration
element or also the iteration index.
Return the abstract expression to evaluate for each iteration.
:param what: Purpose of this function. Used for diagnostics.
:param expr_fn: Function to prepare.
"""
check_type(
expr_fn,
types.FunctionType,
"{what} passed to a collection expression must be a lambda or a"
" function"
)
argspec = inspect.getargspec(expr_fn)
check_multiple([
(len(argspec.args) in (1, 2),
'Invalid collection iteration lambda: only one'
' or two parameters expected'),
(not argspec.varargs and not argspec.keywords,
'Invalid collection iteration lambda: no *args or **kwargs'),
(not argspec.defaults,
'Invalid collection iteration lambda: No default values allowed'
' for arguments')
])
# Get source names for the iteration variables
index_required = False
index_varname: Optional[str] = None
element_varname: Optional[str] = None
if len(argspec.args) == 2:
index_required = True
self.requires_index = True
index_varname = argspec.args[0]
element_varname = argspec.args[1]
else:
element_varname = argspec.args[0]
# We are interested in names from user sources: disregard names from
# the default functions function we define here.
if expr_fn in builtin_collection_functions:
index_varname = None
element_varname = None
# Make sure we have an iteration element variable
self.element_var = self.create_iteration_var(
self.element_var, "Item", element_varname
)
# Expand the function. If the index is required, make sure we have an
# iteration variable for it.
if index_required:
self.index_var = self.create_iteration_var(
self.index_var, "Index", index_varname, T.Int
)
expr = expr_fn(self.index_var, self.element_var) # type: ignore
else:
expr = expr_fn(self.element_var) # type: ignore
return unsugar(expr)