.. _stdlib_functional: ============================== Functional programming library ============================== The functional module implements a collection of high-order functions and patters to expose functional programming patters to Daslang. All functions and symbols are in "functional" module, use require to get access to it. :: require daslib/functional +++++++++++ Map, reduce +++++++++++ * :ref:`filter (var src: iterator\; blk: lambda\<(what:TT):bool\>) : auto ` * :ref:`filter (var src: iterator\; blk: function\<(what:TT):bool\>) : auto ` * :ref:`map (var src: iterator\; blk: lambda\<(what:TT):auto(QQ)\>) : auto ` * :ref:`map (var src: iterator\; blk: function\<(what:TT):auto(QQ)\>) : auto ` * :ref:`reduce (var it: iterator\; blk: lambda\<(left:TT;right:TT):TT\>) : auto ` * :ref:`reduce (var it: iterator\; blk: function\<(left:TT;right:TT):TT\>) : auto ` * :ref:`reduce (var it: iterator\; blk: block\<(left:TT;right:TT):TT\>) : auto ` * :ref:`sum (var it: iterator\) : auto ` * :ref:`any (it: auto) : auto ` * :ref:`any (var it: iterator\) : auto ` * :ref:`all (it: auto) : auto ` * :ref:`all (var it: iterator\) : auto ` * :ref:`cycle (var src: iterator\) : auto ` * :ref:`islice (var src: iterator\; start: int; stop: int) : auto ` * :ref:`repeat_ref (value: auto(TT); var total: int) : auto ` * :ref:`repeat (value: auto(TT); var count: int = 0) : auto ` * :ref:`not (x: auto) : auto ` * :ref:`echo (var x: auto; extra: string = "\n") : auto ` * :ref:`flatten (var it: iterator\) : auto ` * :ref:`sorted (var arr: array\) : auto ` * :ref:`sorted (var it: iterator\) : auto ` .. _function-functional_filter_iterator_ls_autoTT_gr__lambda_ls_what_c_TT_c_bool_gr_: .. das:function:: filter(src: iterator; blk: lambda<(what:TT):bool>) : auto iterates over `src` and yields only those elements for which `blk` returns true :Arguments: * **src** : iterator * **blk** : lambda<(what:TT):bool> .. _function-functional_filter_iterator_ls_autoTT_gr__function_ls_what_c_TT_c_bool_gr_: .. das:function:: filter(src: iterator; blk: function<(what:TT):bool>) : auto iterates over `src` and yields only those elements for which `blk` returns true :Arguments: * **src** : iterator * **blk** : function<(what:TT):bool> .. _function-functional_map_iterator_ls_autoTT_gr__lambda_ls_what_c_TT_c_autoQQ_gr_: .. das:function:: map(src: iterator; blk: lambda<(what:TT):auto(QQ)>) : auto iterates over `src` and yields the result of `blk` for each element :Arguments: * **src** : iterator * **blk** : lambda<(what:TT):auto(QQ)> .. _function-functional_map_iterator_ls_autoTT_gr__function_ls_what_c_TT_c_autoQQ_gr_: .. das:function:: map(src: iterator; blk: function<(what:TT):auto(QQ)>) : auto iterates over `src` and yields the result of `blk` for each element :Arguments: * **src** : iterator * **blk** : function<(what:TT):auto(QQ)> .. _function-functional_reduce_iterator_ls_autoTT_gr__lambda_ls_left_c_TT;right_c_TT_c_TT_gr_: .. das:function:: reduce(it: iterator; blk: lambda<(left:TT;right:TT):TT>) : auto iterates over `it` and yields the reduced (combined) result of `blk` for each element and previous reduction result :Arguments: * **it** : iterator * **blk** : lambda<(left:TT;right:TT):TT> .. _function-functional_reduce_iterator_ls_autoTT_gr__function_ls_left_c_TT;right_c_TT_c_TT_gr_: .. das:function:: reduce(it: iterator; blk: function<(left:TT;right:TT):TT>) : auto iterates over `it` and yields the reduced (combined) result of `blk` for each element and previous reduction result :Arguments: * **it** : iterator * **blk** : function<(left:TT;right:TT):TT> .. _function-functional_reduce_iterator_ls_autoTT_gr__block_ls_left_c_TT;right_c_TT_c_TT_gr_: .. das:function:: reduce(it: iterator; blk: block<(left:TT;right:TT):TT>) : auto iterates over `it` and yields the reduced (combined) result of `blk` for each element and previous reduction result :Arguments: * **it** : iterator * **blk** : block<(left:TT;right:TT):TT> .. _function-functional_sum_iterator_ls_autoTT_gr_: .. das:function:: sum(it: iterator) : auto iterates over `it` and yields the sum of all elements same as reduce(it, @(a,b) => a + b) :Arguments: * **it** : iterator .. _function-functional_any_auto: .. das:function:: any(it: auto) : auto iterates over `it` and yields true if any element is true :Arguments: * **it** : auto .. _function-functional_any_iterator_ls_autoTT_gr_: .. das:function:: any(it: iterator) : auto iterates over `it` and yields true if any element is true :Arguments: * **it** : iterator .. _function-functional_all_auto: .. das:function:: all(it: auto) : auto iterates over `it` and yields true if all elements are true :Arguments: * **it** : auto .. _function-functional_all_iterator_ls_autoTT_gr_: .. das:function:: all(it: iterator) : auto iterates over `it` and yields true if all elements are true :Arguments: * **it** : iterator .. _function-functional_cycle_iterator_ls_autoTT_gr_: .. das:function:: cycle(src: iterator) : auto endlessly iterates over `src` :Arguments: * **src** : iterator .. _function-functional_islice_iterator_ls_autoTT_gr__int_int: .. das:function:: islice(src: iterator; start: int; stop: int) : auto iterates over `src` and yields only the elements in the range [start,stop) :Arguments: * **src** : iterator * **start** : int * **stop** : int .. _function-functional_repeat_ref_autoTT_int: .. das:function:: repeat_ref(value: auto(TT); total: int) : auto yields `value` by reference `count` times :Arguments: * **value** : auto(TT) * **total** : int .. _function-functional_repeat_autoTT_int: .. das:function:: repeat(value: auto(TT); count: int = 0) : auto yields `value` `count` times :Arguments: * **value** : auto(TT) * **count** : int .. _function-functional_not_auto: .. das:function:: not(x: auto) : auto yeilds !x :Arguments: * **x** : auto .. _function-functional_echo_auto_string: .. das:function:: echo(x: auto; extra: string = "\n") : auto prints contents of the string to the output, with `extra` string appended :Arguments: * **x** : auto * **extra** : string .. _function-functional_flatten_iterator_ls_autoTT_gr_: .. das:function:: flatten(it: iterator) : auto iterates over `it`, than iterates over each element of each element of `it` and yields it :Arguments: * **it** : iterator .. _function-functional_sorted_array_ls_auto_gr_: .. das:function:: sorted(arr: array) : auto iterates over input and returns it sorted version :Arguments: * **arr** : array .. _function-functional_sorted_iterator_ls_autoTT_gr_: .. das:function:: sorted(it: iterator) : auto iterates over input and returns it sorted version :Arguments: * **it** : iterator +++++++ Queries +++++++ * :ref:`is_equal (a: auto; b: auto) : auto ` * :ref:`is_not_equal (a: auto; b: auto) : auto ` .. _function-functional_is_equal_auto_auto: .. das:function:: is_equal(a: auto; b: auto) : auto yields true if `a` and `b` are equal :Arguments: * **a** : auto * **b** : auto .. _function-functional_is_not_equal_auto_auto: .. das:function:: is_not_equal(a: auto; b: auto) : auto yields true if `a` and `b` are not equal :Arguments: * **a** : auto * **b** : auto