"description":"The `map` function applies the input function `func` to each element of the\ninput lists, and outputs a list containing the _outputs_ from those function applications.",
"description":"The `map` function applies the function `func` to each corresponding element of the input sequences,\nand outputs a _list_ of the same type containing the outputs from those function applications.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`,\nfor which the corresponding element types are, respectively, `A`, `(buff 1)`, `(string-ascii 1)` and `(string-utf8 1)`.\nThe `func` argument must be a literal function name.\nAlso, note that, no matter what kind of sequences the inputs are, the output is always a list.",
"input_type":"Function(A, B) -> B, sequence_A, B",
"output_type":"B",
"output_type":"B",
"signature":"(fold func list initial-value)",
"signature":"(fold func sequence_A initial_B)",
"description":"The `fold` special form applies the input function `func` to each element of the\ninput list _and_ the output of the previous application of the `fold` function. When invoked on\nthe first list element, it uses the `initial-value` as the second input. `fold` returns the last\nvalue returned by the successive applications. Note that the first argument is not evaluated thus\nhas to be a literal function name.",
"description":"The `fold` function condenses `sequence_A` into a value of type\n`B` by recursively applies the function `func` to each element of the\ninput sequence _and_ the output of a previous application of `func`.\n\n`fold` uses `initial_B` in the initial application of `func`, along with the\nfirst element of `sequence_A`. The resulting value of type `B` is used for the\nnext application of `func`, along with the next element of `sequence_A` and so\non. `fold` returns the last value of type `B` returned by these successive\napplications `func`.\n\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`,\nfor which the corresponding element types are, respectively, `A`, `(buff 1)`, `(string-ascii 1)` and `(string-utf8 1)`.\nThe `func` argument must be a literal function name.\n",
"description":"The `concat` function takes two buffers or two lists with the same entry type,\nand returns a concatenated buffer or list of the same entry type, with max_len = max_len_a + max_len_b.",
"description":"The `concat` function takes two sequences of the same type,\nand returns a concatenated sequence of the same type, with the resulting\nsequence_len = sequence1_len + sequence2_len.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`.\n",
"description":"The `as-max-len?` function takes a length N (must be a literal) and a buffer or list argument, which must be typed as a list\nor buffer of length M and outputs that same list or buffer, but typed with max length N.\n\nThis function returns an optional type with the resulting sequence. If the input sequence is less than\nor equal to the supplied max-len, it returns `(some <sequence>)`, otherwise it returns `none`.",
"description":"The `as-max-len?` function takes a sequence argument and a uint-valued, literal length argument.\nThe function returns an optional type. If the input sequence length is less than\nor equal to the supplied max_length, this returns `(some sequence)`, otherwise it returns `none`.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`.\n",
"description":"The `len` function returns the length of a given buffer or list.",
"description":"The `len` function returns the length of a given sequence.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`.\n ",
"description":"The `element-at` function returns the element at `index` in the provided sequence.\nIf `index` is greater than or equal to `(len sequence)`, this function returns `none`.\nFor strings and buffers, this function will return 1-length strings or buffers.",
"description":"The `element-at` function returns the element at `index` in the provided sequence.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`,\nfor which the corresponding element types are, respectively, `A`, `(buff 1)`, `(string-ascii 1)` and `(string-utf8 1)`.\n",
"description":"The `index-of` function returns the first index at which `item` can be\nfound in the provided sequence (using `is-eq` checks).\n\nIf this item is not found in the sequence (or an empty string/buffer is supplied), this\nfunction returns `none`.",
"description":"The `index-of` function returns the first index at which `item` can be\nfound, using `is-eq` checks, in the provided sequence.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`,\nfor which the corresponding element types are, respectively, `A`, `(buff 1)`, `(string-ascii 1)` and `(string-utf8 1)`.\nIf the target item is not found in the sequence (or if an empty string or buffer is\nsupplied), this function returns `none`.\n",
"description":"The `filter` function applies the input function `func` to each element of the\ninput list, and returns the same list with any elements removed for which the `func` returned `false`.",
"description":"The `filter` function applies the input function `func` to each element of the\ninput sequence, and returns the same sequence with any elements removed for which `func` returned `false`.\nApplicable sequence types are `(list A)`, `buff`, `string-ascii` and `string-utf8`,\nfor which the corresponding element types are, respectively, `A`, `(buff 1)`, `(string-ascii 1)` and `(string-utf8 1)`.\nThe `func` argument must be a literal function name.\n",
PR Robot
3 years ago
Patrick Gray