Generalised plusequals

10 comments

• flebron 11 hours ago

  The website asks what they do in Haskell. The answer is property modification and reading, as well as very powerful traversal constructs, use lenses (https://hackage.haskell.org/package/lens , tutorial at https://hackage.haskell.org/package/lens-tutorial-1.0.5/docs...).

  [-]

  • leontrolski 3 hours ago

    What would be the equivalent to this in Haskell (with or without lens):

        cat = Cat(age=3)
        l = [1, [2, cat], 4]
        alt l[1][1].age.=9
    

    That would give us l equal to:

        [1, [2, Cat(age=9)], 4]

• RodgerTheGreat 10 hours ago

  In Lil[0], this is how ordinary assignment syntax works. Implicitly defining a dictionary stored in a variable named "cat" with a field "age":

      cat.age:3
      # {"age":3}
  

  Defining "l" as in the example in the article. We need the "list" operator to enlist nested values so that the "," operator doesn't concatenate them into a flat list:

      l:1,(list 2,list cat),4
      # (1,(2,{"age":3}),4)
  

  Updating the "age" field in the nested dictionary. Lil's basic datatypes are immutable, so "l" is rebound to a new list containing a new dictionary, leaving any previous references undisturbed:

      l[1][1].age:9
      # (1,(2,{"age":9}),4)
      cat
      # {"age":3}
  

  There's no special "infix" promotion syntax, so that last example would be:

      l:l,5
      # (1,(2,{"age":9}),4,5)
  

  [0] http://beyondloom.com/tools/trylil.html
  [-]

  • leontrolski 3 hours ago

    This is surprising to me:

      l[1][1].age:9
      # (1,(2,{"age":9}),4)
    

    How come it doesn't return just:

      {"age":9}
    

    Or is there something totally different going on with references here? As in, how is this different to:

      l_inner = l[1][1]
      l_inner.age:9

• rokob 10 hours ago

  Yeah this looks like lenses at first glance

• hatthew 10 hours ago

  It seems like this is proposing syntactic sugar to make mutating and non-mutating operations be on equal footing.

  > The more interesting example is reassigning the deeply nested l to make the cat inside older, without mutating the original cat

  Isn't that mutating l, though? If you're concerned about mutating cat, shouldn't you be concerned about mutating l?

  [-]

  • two_handfuls 10 hours ago

    It doesn't mutate l exactly, it makes a new list slightly different from the original one and assigns it to l.

    That means if someone has a reference to the original l, they do not see the change (because l is immutable. Both of them).

    [-]

    • 6 hours ago
      [deleted]
    • hatthew 6 hours ago

      I think I am misunderstanding the behavior of the alt keyword

• beaumayns 10 hours ago

  q has the concept of amend, which is similar: https://code.kx.com/q4m3/6_Functions/#683-general-form-of-fu...

  It's quite handy, though the syntax for it is rather clunky compared to the rest of the language in my opinion.