`apply-partially` and hash tables

`apply-partially` and hash tables

[Joost Kremers]

Hi list,

A question that just came up: if I use `apply-partially` to create a
function that has a hash table as one of its fixed arguments, and then at
some later point add data to said hash table, it seems that this data is
visible to subsequent calls to the partially applied function:

```
(let* ((s #s(hash-table test equal data ("MGrt" "Mouton De Gruyter"
                                         "OTS" "Utrecht School of Linguistics UiL-OTS")))
       (fn (apply-partially #'parsebib--expand-strings s)))
  (puthash "BW" "Oxford: Blackwell Publishers" s)
  (funcall fn "BW"))
"Oxford: Blackwell Publishers"
```

`parsebib--expand-strings` is a function that (among other things) does a
hash table look-up. The entry ("BW" "Oxford: Blackwell Publishers") is
added to the hash table after the function is created, but it can obviously
still be found by it.

So my question: is this intended behaviour, something that I can rely on to
continue to work, or is this an artefact of the implementation that may
change at any time in the future?

TIA

-- 
Joost Kremers
Life has its moments

Re: `apply-partially` and hash tables

[tomas]

[-- Attachment #1: Type: text/plain, Size: 1417 bytes --]

On Sun, Oct 20, 2024 at 11:43:15AM +0200, Joost Kremers wrote:
> Hi list,
> 
> A question that just came up: if I use `apply-partially` to create a
> function that has a hash table as one of its fixed arguments, and then at
> some later point add data to said hash table, it seems that this data is
> visible to subsequent calls to the partially applied function:
> 
> ```
> (let* ((s #s(hash-table test equal data ("MGrt" "Mouton De Gruyter"
>                                          "OTS" "Utrecht School of Linguistics UiL-OTS")))
>        (fn (apply-partially #'parsebib--expand-strings s)))
>   (puthash "BW" "Oxford: Blackwell Publishers" s)
>   (funcall fn "BW"))
> "Oxford: Blackwell Publishers"
> ```
> 
> `parsebib--expand-strings` is a function that (among other things) does a
> hash table look-up. The entry ("BW" "Oxford: Blackwell Publishers") is
> added to the hash table after the function is created, but it can obviously
> still be found by it.
> 
> So my question: is this intended behaviour, something that I can rely on to
> continue to work, or is this an artefact of the implementation that may
> change at any time in the future?

This is an interesting question: it comes down to what can be considered
"immutable".

I guess a hash table doesn't count (as wouldn't a buffer, possibly a list
or any other object with a complex "inner life").

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

Re: `apply-partially` and hash tables

[Stefan Monnier via Users list for the GNU Emacs text editor]

> (let* ((s #s(hash-table test equal data ("MGrt" "Mouton De Gruyter"
>                                          "OTS" "Utrecht School of Linguistics UiL-OTS")))
>        (fn (apply-partially #'parsebib--expand-strings s)))
>   (puthash "BW" "Oxford: Blackwell Publishers" s)
>   (funcall fn "BW"))
> "Oxford: Blackwell Publishers"

Nothing to do with hash-tables:

    (let* ((l (list 'a 'b 'c))
           (f (apply-partially #'elt l)))
      (list (funcall f 0)
            (push 'new (nth 0 l))
            (funcall f 0)))


- Stefan

Re: `apply-partially` and hash tables

[Joost Kremers]

On Sun, Oct 20 2024, Stefan Monnier via Users list for the GNU Emacs text editor wrote:
>> (let* ((s #s(hash-table test equal data ("MGrt" "Mouton De Gruyter"
>>                                          "OTS" "Utrecht School of Linguistics UiL-OTS")))
>>        (fn (apply-partially #'parsebib--expand-strings s)))
>>   (puthash "BW" "Oxford: Blackwell Publishers" s)
>>   (funcall fn "BW"))
>> "Oxford: Blackwell Publishers"
>
> Nothing to do with hash-tables:
>
>     (let* ((l (list 'a 'b 'c))
>            (f (apply-partially #'elt l)))
>       (list (funcall f 0)
>             (push 'new (nth 0 l))
>             (funcall f 0)))

Yeah, I figured it wouldn't be limited to hash tables, that just happened
to be the case I ran into.

My question is the same, though: can it be relied upon?

-- 
Joost Kremers
Life has its moments

Re: `apply-partially` and hash tables

[Stefan Monnier]

> My question is the same, though: can it be relied upon?

It's fundamental to the notion of what is a *value* (as in "call by
value"), so yes, very much so.


        Stefan

Re: `apply-partially` and hash tables

[Rudolf Schlatte]

Stefan Monnier <monnier@iro.umontreal.ca> writes:

>> My question is the same, though: can it be relied upon?
>
> It's fundamental to the notion of what is a *value* (as in "call by
> value"), so yes, very much so.

The usual caveat for lists applies: prepending values to the front or
otherwise mutating the list will not work as expected in general, since
what you're holding is just a cons cell.  (This is an instance of the
"delete bug" where you have to write `(setq x (delete 'foo x))' instead
of just `(delete 'foo x)'.)

Re: `apply-partially` and hash tables

[Stefan Monnier via Users list for the GNU Emacs text editor]

Rudolf Schlatte [2024-10-20 21:12:33] wrote:
> Stefan Monnier <monnier@iro.umontreal.ca> writes:
>>> My question is the same, though: can it be relied upon?
>>
>> It's fundamental to the notion of what is a *value* (as in "call by
>> value"), so yes, very much so.
>
> The usual caveat for lists applies: prepending values to the front or
> otherwise mutating the list will not work as expected in general, since
> what you're holding is just a cons cell.  (This is an instance of the
> "delete bug" where you have to write `(setq x (delete 'foo x))' instead
> of just `(delete 'foo x)'.)

AFAICT this behavior is a direct result of that same fundamental
difference between a value and the thing it refers to, so not a caveat
at all.


        Stefan