de Rigo, D. (2012). Merging functional paradigm ideas with semantic array programming: the module "func_let" of the Mastrave modelling library. In: Semantic Array Programming with Mastrave - Introduction to Semantic Computational Modelling. http://mastrave.org/doc/mtv_m/func_let

Merging functional paradigm ideas with semantic array programming: the module "func_let" of the Mastrave modelling library

Daniele de Rigo

The file func_let.m is part of Mastrave.

Mastrave is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Mastrave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Mastrave. If not, see http://www.gnu.org/licenses/.

Function declaration

continuation = func_let( func              ,
continuation = [] )



Description

Module for supporting functional semantic array programming and in particular continuation-passing style with optional semantic constraints (planned).

Data parallelism is inherently present in several large-scale (e.g. regional, continental scale) applications of environmental modelling. At large scale, environmental data are usually available as geographically referenced collections of atomic information.

For example, spatial raster layers are matrices of values each element of them referring to a certain spatial location. Also complex data such as time series of spatially distributed measures are often suitable for conceptually compact data-transformations, despite often those transformations are nontrivial to implement.

Multi-dimensional arrays, heterogeneous collections of uneven arrays might typically benefit from conciseness and reliability of semantic array programming as implemented by the Mastrave modelling library.

This module allows algorithms composed by trees of sub-algorithms to be expressed even more concisely by means of extended anonymous functions which can support internal array-based state transitions along with array continuation-passing style. This style is an array-based design pattern which is inspired by the classic one originated from the functional programming paradigm.

Functional semantic array programming codelets for array data-transformations can be assigned to function handles and also nestified for implementig complex functional behaviours.

Input arguments


func               ::cellfunhandle::
Semantic function handle of cell-array of semantic
function handles.
Semantic function handles are not intended to be
invokable function handles.  Instead, they are meant
as a concise way for expressing semantically enhanced
relationships between variables and expressions,
also suitable to be parsed and interpreted.

Each semantic function handle must follow a schema,
the easiest instantiation of which is:
@( varname ) is (  expression  )
which simply represents an assignment:
varname     =    expression
varname  can be an arbitrary valid variable name,
except for reserved names (i.e. variable names
beginning with "_mtv_" and ending with "_" ) which
are not allowed.
expression  can be an arbitrary valid expression
possibly involving previously assigned variables.
Alternatively, the operator  "is"  could be replaced
with the equivalent operator "_" .

Multiple assignments can be denoted as mutually
independent so that they could in principle be
executed in parallel (i.e. the order of execution
of the assignments should not matter):
@( var1 , var2 ) is (  expr1 ,  expr2  )

Dynamic assignments (i.e. execution-order dependent
assignments) can be denoted with consecutive
semantic function handles:
{
@( var1 ) is (  expr1  ),
@( var2 ) is (  expr2  )
}

Multiple output arguments of a given function can
be assigned by using the notation:
@( var1 , var2 ) are (  function_handle  )
whose non-functional version would be:
[  var1 , var2  ] =  function_handle ()

continuation       ::struct::
Structure whose fields represent variables in the
form:
continuation. var_name  =  var_value
e.g. generated by using  @vars2struct .
If passed as empty array  [] , it is converted in an
empty struct.
If omitted, its default value is [] .



Example of usage


% Basic usage
c = func_let( @(x)       is ( 3 )            )
c = func_let( @(x,y)     is ( 3, pi )        )
c = func_let( @(x,y,foo) is ( 3, pi, 'bar' ) )

% Managing multiple output arguments of a function

% Equivalent to:
%    maxval = max([0 pi -2 1])
c = func_let( @(maxval)     is  (    max([0 pi -2 1]) ) )
c = func_let( @(maxval)     are ( @()max([0 pi -2 1]) ) )

% Equivalent to:
%    [ maxval, pos ] = max([0 pi -2 1])
c = func_let( @(maxval,pos) are ( @()max([0 pi -2 1]) ) )

% Wrong formats
c = func_let( @(x,y)    func( 3, pi )   )
c = func_let( @(x,y) is + 2             )
c = func_let( @(x,y) is     ( 3, pi )+2 )

% Passing multiple assignments
c = func_let( {@(x)is( 1+1), @(y)is(x*10) } )
% Using a better coding style
c = func_let( {
@(x)_( [1:5] + 1 )
@(y)_( x * 10 )
} )

% Passing a reified variable state (continuation-passing style)
c2 = func_let( { @(z)_( y(end:-1:1) * 10 ) } ,c )

% Motivational example
% Plotting remote datasets using an anonymous function
plt = @(data1,data2)func_let( {
@(grd   )is( @get_reference_data          )
@(d1,d2 )is( grd( data1 ), grd( data2 )   )
@(y     )is( [    d1(:,1),      d2(:,1) ] )
@(ret   )is( mplot_vline( y )             )
},              vars2struct                  );

c12 = plt( 'Gauss1' , 'Gauss2' );
c23 = plt( 'Gauss2' , 'Gauss3' );


See also:
mstream, mblk_fun

Keywords:
continuation-passing, functional, anonymous-function

Version: 0.4.5

Support

The Mastrave modelling library is committed to provide reusable and general - but also robust and scalable - modules for research modellers dealing with computational science.  You can help the Mastrave project by providing feedbacks on unexpected behaviours of this module.  Despite all efforts, all of us - either developers or users - (should) know that errors are unavoidable.  However, the free software paradigm successfully highlights that scientific knowledge freedom also implies an impressive opportunity for collectively evolve the tools and ideas upon which our daily work is based.  Reporting a problem that you found using Mastrave may help the developer team to find a possible bug.  Please, be aware that Mastrave is entirely based on voluntary efforts: in order for your help to be as effective as possible, please read carefully the section on reporting problems.  Thank you for your collaboration.

Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Daniele de Rigo