[racket] hack: implicit function arguments

scut = super cut

Like the hair cutting chain and like a better version of the srfi cut macro. 

Jay

Sent from my iPhone

On Aug 14, 2010, at 3:02 PM, Jon Rafkind <rafkind at cs.utah.edu> wrote:

> Your library looks cool.. definately has more features than what I made. What does 'scut' mean though? s-cut ?
> 
> On 08/14/2010 09:20 AM, Jay McCarthy wrote:
>> This is very similar to supercut:
>> 
>> http://github.com/jeapostrophe/exp/blob/master/scut.ss
>> 
>> scut allows you to put any expression inside it and it will turn it
>> into a function. The arguments come from use of _. If you have _i then
>> it will be the ith argument. If you have _string then the function
>> will take a "string" keyword argument. The function takes as many
>> arguments as the maximum i you use inside it. Finally, _... gives you
>> the rest arg. The bottom of that file has many examples, here are a
>> few:
>> 
>> ((scut _0) 1) =>  1
>> 
>>  ((scut (+ _0 (/ _1 _2)))
>>   1 2 3)
>>  =>  (+ 1 (/ 2 3))
>> 
>> ((scut (+ _lhs _lhs _rhs)) #:lhs 1 #:rhs 2)
>>  =>  4
>> 
>>  ((scut (apply + _0 _...))
>>   1 2 3)
>>  =>  6
>> 
>> On Fri, Aug 13, 2010 at 11:01 PM, Jon Rafkind<rafkind at cs.utah.edu>  wrote:
>>>  I came up with this little hack that lets you avoid giving an explicit
>>> argument list to functions. Arguments are discovered by usages of
>>> underscores followed by a number, like _1 and _2. Partly inspired by scala;
>>> sure to make your blood boil if you love hygiene.
>>> 
>>> ;;; usage
>>> (define/implicit foo1 (printf "~a ~a ~a\n" _8 _9 _8))
>>> (foo1 5 12)
>>> 
>>> ;;; code
>>> #lang racket/base
>>> 
>>> (require (for-syntax racket/base
>>>                     racket/list
>>>                     syntax/parse
>>>                     )
>>>         racket/stxparam)
>>> 
>>> (define-syntax-rule (implicits all thing ...)
>>>  (begin
>>>    (define-syntax-parameter thing (lambda (stx)
>>>                                  (raise-syntax-error #f (format "~a can only
>>> be used in a
>>>  define/implicit function" 'thing))))
>>>    ...
>>>    (provide thing ...)
>>>    (define-for-syntax all (list #'thing ...))))
>>> 
>>> (implicits all-implicits _1 _2 _3 _4 _5 _6 _7 _8 _9 _10)
>>> 
>>> (provide define/implicit lambda/implicit)
>>> (define-syntax (lambda/implicit stx)
>>>  (define (find-implicits stx)
>>>    (define-syntax-class implicit
>>>                         [pattern x:identifier
>>>                                  #:when (ormap (lambda (y)
>>>                                                  (free-identifier=? y #'x))
>>>                                                all-implicits)])
>>>    (remove-duplicates
>>>      (filter values
>>>              (syntax-parse stx
>>>                [x:implicit (list #'x)]
>>>                [(x ...) (apply append (map find-implicits (syntax->list #'(x
>>> ...))))]
>>>                [else (list #f)]))
>>>      free-identifier=?))
>>>  (syntax-parse stx
>>>    [(_ body ...)
>>>     (define implicit-arguments (find-implicits stx))
>>>     (with-syntax ([(new-arg ...) (generate-temporaries implicit-arguments)]
>>>                   [(implicit ...) implicit-arguments])
>>>       #'(lambda (new-arg ...)
>>>           (syntax-parameterize ([implicit (make-rename-transformer
>>> #'new-arg)] ...)
>>>                                body ...)))]))
>>> 
>>> (define-syntax-rule (define/implicit name body ...)
>>>                    (define name (lambda/implicit body ...)))
>>> 
>>> _________________________________________________
>>>  For list-related administrative tasks:
>>>  http://lists.racket-lang.org/listinfo/users
>>> 
>> 
>> 
>