--- layout: default title: "Giving" parent: Normal ancestor: Funcons-beta --- [Funcons-beta] : [Giving.cbs] ----------------------------- ### Giving

[
  Entity given-value
  Funcon initialise-giving
  Funcon give
  Funcon given
  Funcon no-given
  Funcon left-to-right-map
  Funcon interleave-map
  Funcon left-to-right-repeat
  Funcon interleave-repeat
  Funcon left-to-right-filter
  Funcon interleave-filter
  Funcon fold-left
  Funcon fold-right
]

Meta-variables
  T, T′ <: values
  T^? <: values^?

Entity
  given-value(_:values^?) |- _ ---> _

The given-value entity allows a computation to refer to a single previously-computed V:values. The given value ( ) represents the absence of a current given value.

Funcon
  initialise-giving(X:( )=>T′) : ( )=>T′
   ~> no-given(X)

initialise-giving(X) ensures that the entities used by the funcons for giving are properly initialised.

Funcon
  give(_:T, _:T=>T′) : =>T′

give(X, Y) executes X, possibly referring to the current given value, to compute a value V. It then executes Y with V as the given value, to compute the result.

Rule
  given-value(V) |- Y ---> Y′
  ------------------------------------------------
  given-value(_?) |- give(V:T, Y) ---> give(V, Y′)
Rule
  give(_:T, W:T′) ~> W

Funcon
  given : T=>T

given refers to the current given value.

Rule
  given-value(V:values) |- given ---> V
Rule
  given-value( ) |- given ---> fail

Funcon
  no-given(_:( )=>T′) : ( )=>T′

no-given(X) computes X without references to the current given value.

Rule
         given-value( ) |- X ---> X′
  ------------------------------------------------
  given-value(_?) |- no-given(X) ---> no-given(X′)
Rule
  no-given(U:T′) ~> U

#### Mapping Maps on collection values can be expressed directly, e.g., list(left-to-right-map(F, list-elements(L))).

Funcon
  left-to-right-map(_:T=>T′, _:(T)^*) : =>(T′)^*

left-to-right-map(F, V^*) computes F for each value in V^* from left to right, returning the sequence of resulting values.

Rule
  left-to-right-map(F, V:T, V^*:(T)^*)
    ~> left-to-right(give(V, F), left-to-right-map(F, V^*))
Rule
  left-to-right-map(_, ( )) ~> ( )

Funcon
  interleave-map(_:T=>T′, _:(T)^*) : =>(T′)^*

interleave-map(F, V^*) computes F for each value in V^* interleaved, returning the sequence of resulting values.

Rule
  interleave-map(F, V:T, V^*:(T)^*)
    ~> interleave(give(V, F), interleave-map(F, V^*))
Rule
  interleave-map(_, ( )) ~> ( )

Funcon
  left-to-right-repeat(_:integers=>T′, _:integers, _:integers) : =>(T′)^*

left-to-right-repeat(F, M, N) computes F for each value from M to N sequentially, returning the sequence of resulting values.

Rule
  is-less-or-equal(M, N) == true
  -------------------------------------------------------------------------
  left-to-right-repeat(F, M:integers, N:integers)
    ~> left-to-right(give(M, F), left-to-right-repeat(F, int-add(M, 1), N))
Rule
  is-less-or-equal(M, N) == false
  ----------------------------------------------
  left-to-right-repeat(_, M:integers, N:integers) ~> ( )

Funcon
  interleave-repeat(_:integers=>T′, _:integers, _:integers) : =>(T′)^*

interleave-repeat(F, M, N) computes F for each value from M to N interleaved, returning the sequence of resulting values.

Rule
  is-less-or-equal(M, N) == true
  -------------------------------------------------------------------
  interleave-repeat(F, M:integers, N:integers)
    ~> interleave(give(M, F), interleave-repeat(F, int-add(M, 1), N))
Rule
  is-less-or-equal(M, N) == false
  -------------------------------------------
  interleave-repeat(_, M:integers, N:integers) ~> ( )

#### Filtering Filters on collections of values can be expressed directly, e.g., list(left-to-right-filter(P, list-elements(L))) to filter a list L.

Funcon
  left-to-right-filter(_:T=>booleans, _:(T)^*) : =>(T)^*

left-to-right-filter(P, V^*) computes P for each value in V^* from left to right, returning the sequence of argument values for which the result is true.

Rule
  left-to-right-filter(P, V:T, V^*:(T)^*)
   ~> left-to-right(when-true(give(V, P), V), left-to-right-filter(P, V^*))
Rule
  left-to-right-filter(_) ~> ( )

Funcon
  interleave-filter(_:T=>booleans, _:(T)^*) : =>(T)^*

interleave-filter(P, V^*) computes P for each value in V^* interleaved, returning the sequence of argument values for which the result is true.

Rule
  interleave-filter(P, V:T, V^*:(T)^*)
   ~> interleave(when-true(give(V, P), V), interleave-filter(P, V^*))
Rule
  interleave-filter(_) ~> ( )

#### Folding

Funcon
  fold-left(_:tuples(T,T′)=>T, _:T, _:(T′)^*) : =>T

fold-left(F, A, V^*) reduces a sequence V^* to a single value by folding it from the left, using A as the initial accumulator value, and iteratively updating the accumulator by giving F the pair of the accumulator value and the first of the remaining arguments.

Rule
  fold-left(_, A:T, ( )) ~> A
Rule
  fold-left(F, A:T, V:T′, V^*:(T′)^*) ~> fold-left(F, give(tuple(A, V), F), V^*)

Funcon
  fold-right(_:tuples(T,T′)=>T′, _:T′, _:(T)^*) : =>T′

fold-right(F, A, V^*) reduces a sequence V^* to a single value by folding it from the right, using A as the initial accumulator value, and iteratively updating the accumulator by giving F the pair of the the last of the remaining arguments and the accumulator value.

Rule
  fold-right(_, A:T′, ( )) ~> A
Rule
  fold-right(F, A:T′, V^*:(T)^*, V:T) ~> give(tuple(V, fold-right(F, A, V^*)), F)

____ From the [PLanCompS Project] | [CBS-beta issues...] | [Suggest an improvement...] [Giving.cbs]: Giving.cbs "CBS SOURCE FILE" [Funcons-beta]: /CBS-beta/docs/Funcons-beta "FUNCONS-BETA" [Unstable-Funcons-beta]: /CBS-beta/docs/Unstable-Funcons-beta "UNSTABLE-FUNCONS-BETA" [Languages-beta]: /CBS-beta/docs/Languages-beta "LANGUAGES-BETA" [Unstable-Languages-beta]: /CBS-beta/docs/Unstable-Languages-beta "UNSTABLE-LANGUAGES-BETA" [CBS-beta]: /CBS-beta "CBS-BETA" [PLanCompS Project]: https://plancomps.github.io "PROGRAMMING LANGUAGE COMPONENTS AND SPECIFICATIONS PROJECT HOME PAGE" [CBS-beta issues...]: https://github.com/plancomps/CBS-beta/issues "CBS-BETA ISSUE REPORTS ON GITHUB" [Suggest an improvement...]: mailto:plancomps@gmail.com?Subject=CBS-beta%20-%20comment&Body=Re%3A%20CBS-beta%20specification%20at%20Computations/Normal/Giving/Giving.cbs%0A%0AComment/Query/Issue/Suggestion%3A%0A%0A%0ASignature%3A%0A "GENERATE AN EMAIL TEMPLATE"