[Haskell] Proposal: Allow "\=" for field update in record update syntax

[S. Alexander Jacobson]

On Fri, 18 Feb 2005, Keean Schupke wrote:
> Its a pity template haskell cannot define infix operators, but you could use 
> TH like:
>
>   $update rec field fn
>
> which would expand to:
>
>   rec { field = fn (rec field)  }

That doesn't help you so much if you want to update more than 
one field at a time.  I think the best case syntax in this spirit is 
to define:

    x // f = f x
    infixl 6 //
    $(a field val) => \rec -> rec {field = val}
    $(u field fn) => \rec -> rec {field = fn (field rec)}

Which we would then be able to use like this:

    fun rec = rec // $(u field1 fn) . $(a field2 val)

But, I'm not sure that is superior to having the user explicitly 
derive u_ and a_ functions on the rectype which looks like this:

    $(deriveUpdate RecType)

    fun rec = rec // u_field1 fn . a_field2 val

Aside: Why doesn't TH allow infix?  Haskell doesn't allow operators 
that start with ':' so it would seem natural for TH to use those for 
infix.  Then we could have e.g. (:=) and (:\=) and end up with a 
syntax that looks like this:

   rec // field :\= fn . field2 := val

And that is BETTER than the Haskell syntax that I originally proposed. 
Are TH infix operators on the agenda?

-Alex-

______________________________________________________________
S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com





> Keean. 
> S. Alexander Jacobson wrote:
>
>> I don't know what it takes to get this sort of change into circulation, but 
>> I assume it starts with a clear and specific description of the problem, 
>> exploration of alternatives, and a specific proposed solution.  So here 
>> goes:
>> 
>> ----------
>> Proposal: Allow "\=" for field update in record update syntax
>> 
>> Specifically, intepret
>> 
>>    rec {field\=fn}
>> 
>> as
>> 
>>    rec {field = fn (field rec)}
>> 
>> Jusitification:
>> 
>> It is extremely common when updating records to be updating a field value 
>> based on its prior value rather than simply assigning a new value from 
>> nothing.  Unforunately the syntax supports the later clearly but makes the 
>> former awkward to read, understand, and debug:
>> 
>>    myFun db myType1 =
>>       db { tMyType1 = insert myType1 $ tMyType1 db
>>            nextId = 1 + (nextId db)
>>          }
>> 
>> One solution to this problem that does not involve changing syntax is to 
>> generate field update functions for every field of a type e.g.:
>> 
>>    update_tMyType1 f s = s {tMyType1= f $ myType1 s}
>>    update_nextId f s = s {nextId = f $ nextId s}
>> 
>> Once you have those functions, myFun looks much better:
>> 
>>    myFun db myType = update_nextId (+1) $ update_tMyType1 f db
>>      where f= insert myType1
>> 
>> But, generating the update_ functions is not programming; its just manual 
>> syntax generation.  And, even if you have template haskell to do it,
>> 
>>   * it is annoying to have to find/write the TH code to implement
>>   * update_ is incredibly verbose
>>   * shortening it risks proliferation of psuedo-syntax:
>>      u_tMyType, u__tMyType, or utMyType?
>>   * it adds clutter to have to call the TH for each record type, and
>>   * it pollutes the name space/increases risk of name collision
>> 
>> Rather than force the user to jump through these hoops, why not make the 
>> syntax flow naturally from the existing record update syntax? It makes 
>> sense to use \= for this task as it is the functional generalization of C 
>> or Java's += or *= . Then myFun would have the elegant and clear syntax:
>> 
>>     myFun db myType1 =db {tMyType1\=insert myType1, nextId\=(+1)}
>> 
>> -Alex-
>> 
>> 
>> ______________________________________________________________
>> S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com
>> _______________________________________________
>> Haskell mailing list
>> Haskell at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell
>
>