Skip to content

Partial application should be bound (like bound functions) #634

Description

@dead-claudia

It's really confusing to have code like this constantly throw TypeErrors:

class Walker
    (@visitors) ->

    walkList: (list) !->
        list
        |> filter (.type of @visitors)
        |> each @walk

    # more methods

The problem is this partial function:

(.type of @visitors)

It looks like it should be bound to the current instance, equivalent to this code:

(node) ~> node.type of @visitors  # bound

It's really equivalent to this, which was a rather unexpected gotcha:

(node) -> node.type of @visitors  # not bound

This gotcha is a little misleading. It feels like a small fix, but I don't know a lot about the internal compiler structure.

Activity

  1. igl commented on Dec 25, 2014

    @igl
    Contributor

    Aye. Those tiny implicit funcs should behave like es6-equal-rockets =>
    Another fix would probably be not using classes and shitthis at all.

  2. vendethiel commented on Dec 25, 2014

    @vendethiel
    Contributor

    Alright, I think I agree here.

  3. dead-claudia commented on Dec 25, 2014

    @dead-claudia
    ContributorAuthor

    My initial workaround was this:

    walkList: (list) !->
        {visitors} = @
        list
        |> filter (.type of visitors)
        |> each @walk

    I ultimately ended up working around it by using inner functions, which helped me refactor it to be more functional rather than CoffeeScript-ish OO.

    module.exports = (visitors, ast) !-->
       walkList = each walk, filter (.type of visitors)
    
       # more methods

    The semantics seem to be a bug, potentially a design oversight in the language, but the workaround eventually helped surface a bad smell in my code.

    I still say partial functions should be lexically bound (like ES6 arrow functions).

  4. added a commit that references this issue on Jan 7, 2016
    75c5226
  5. summivox commented on Jan 7, 2016

    @summivox
    Contributor

    Okay. After writing a patch that implements this behavior, I realized that it might not always be what you expect. Consider this:

    o = a: 1, f: (@a =)

    Here unbound this is intended.

    My feelings:

    • A bound this feels "right" and might be more common [citation needed], since these implicit functions are intended for writing quick inline lambdas (where you would assume bound this), not methods
    • Syntax to support both bound and unbound might be overkill? Crazy idea: pick another sigil for bound this
  6. added a commit that references this issue on Jan 31, 2016
    9f96f95
  7. added a commit that references this issue on Feb 1, 2016
    9bdd5df
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions