all messages for Emacs-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
* `apply-partially` and hash tables
@ 2024-10-20  9:43 Joost Kremers
  2024-10-20  9:54 ` tomas
  2024-10-20 14:46 ` Stefan Monnier via Users list for the GNU Emacs text editor
  0 siblings, 2 replies; 7+ messages in thread
From: Joost Kremers @ 2024-10-20  9:43 UTC (permalink / raw)
  To: help-gnu-emacs

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



^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20  9:43 `apply-partially` and hash tables Joost Kremers
@ 2024-10-20  9:54 ` tomas
  2024-10-20 14:46 ` Stefan Monnier via Users list for the GNU Emacs text editor
  1 sibling, 0 replies; 7+ messages in thread
From: tomas @ 2024-10-20  9:54 UTC (permalink / raw)
  To: help-gnu-emacs

[-- 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 --]

^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20  9:43 `apply-partially` and hash tables Joost Kremers
  2024-10-20  9:54 ` tomas
@ 2024-10-20 14:46 ` Stefan Monnier via Users list for the GNU Emacs text editor
  2024-10-20 15:19   ` Joost Kremers
  1 sibling, 1 reply; 7+ messages in thread
From: Stefan Monnier via Users list for the GNU Emacs text editor @ 2024-10-20 14:46 UTC (permalink / raw)
  To: help-gnu-emacs

> (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




^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20 14:46 ` Stefan Monnier via Users list for the GNU Emacs text editor
@ 2024-10-20 15:19   ` Joost Kremers
  2024-10-20 17:04     ` Stefan Monnier
  0 siblings, 1 reply; 7+ messages in thread
From: Joost Kremers @ 2024-10-20 15:19 UTC (permalink / raw)
  To: Stefan Monnier via Users list for the GNU Emacs text editor
  Cc: Stefan Monnier

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



^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20 15:19   ` Joost Kremers
@ 2024-10-20 17:04     ` Stefan Monnier
  2024-10-20 19:12       ` Rudolf Schlatte
  0 siblings, 1 reply; 7+ messages in thread
From: Stefan Monnier @ 2024-10-20 17:04 UTC (permalink / raw)
  To: Joost Kremers; +Cc: Stefan Monnier via Users list for the GNU Emacs text editor

> 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




^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20 17:04     ` Stefan Monnier
@ 2024-10-20 19:12       ` Rudolf Schlatte
  2024-10-20 20:29         ` Stefan Monnier via Users list for the GNU Emacs text editor
  0 siblings, 1 reply; 7+ messages in thread
From: Rudolf Schlatte @ 2024-10-20 19:12 UTC (permalink / raw)
  To: help-gnu-emacs

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)'.)




^ permalink raw reply	[flat|nested] 7+ messages in thread

* Re: `apply-partially` and hash tables
  2024-10-20 19:12       ` Rudolf Schlatte
@ 2024-10-20 20:29         ` Stefan Monnier via Users list for the GNU Emacs text editor
  0 siblings, 0 replies; 7+ messages in thread
From: Stefan Monnier via Users list for the GNU Emacs text editor @ 2024-10-20 20:29 UTC (permalink / raw)
  To: help-gnu-emacs

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




^ permalink raw reply	[flat|nested] 7+ messages in thread

end of thread, other threads:[~2024-10-20 20:29 UTC | newest]

Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2024-10-20  9:43 `apply-partially` and hash tables Joost Kremers
2024-10-20  9:54 ` tomas
2024-10-20 14:46 ` Stefan Monnier via Users list for the GNU Emacs text editor
2024-10-20 15:19   ` Joost Kremers
2024-10-20 17:04     ` Stefan Monnier
2024-10-20 19:12       ` Rudolf Schlatte
2024-10-20 20:29         ` Stefan Monnier via Users list for the GNU Emacs text editor

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/emacs.git
	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.