[racket-dev] Math library initial commit almost ready; comments on issues welcome

I think this idea is worth exploring. Sam and Eli should implement it. 



On Oct 5, 2012, at 8:39 AM, Eli Barzilay wrote:

> Yesterday, Matthias Felleisen wrote:
>> 
>> I know 
>> 
>> What I mean is an _abstraction mechanism_ inside of TR. Possibly
>> something that nobody else has.
> 
> +18.59
> 
> And a quick reminder -- below is the ancient hack I once did for such
> things, maybe something like this would be easier now.  Possibly much
> easier: if a type is (foo ...) and `foo' is phase-1-bound to a macro
> (anything that is not a bound type), then just expand it -- so that in
> Neil's case the code could be:
> 
>  (define-syntax-rule (Xs->Xs T ...) (case-> (T -> T) ...))
>  (: foo : (Xs->Xs Zero Flonum Real Float-Complex Complex))
> 
> (Either way, this means that it's easy to create huge types, and
> therefore stressing TR's not-too-fast typechecker, but it sounds like
> not having an abstraction doesn't stand in Neil's way to write huge
> types anyway.)
> 
> 
> ------------------------------------------------------------------------
>  #lang typed-scheme
> 
>  (require (for-syntax scheme/base scheme/private/at-syntax))
> 
>  ;; (define-syntax (STX stx)
>  ;;   (syntax-case stx ()
>  ;;     [(_ expr) (at-syntax #'expr)]))
>  (define-syntax (:: stx)
>    (syntax-case stx (:)
>      [(_ name : x ...)
>       (with-syntax ([(x ...) (map at-syntax (syntax->list #'(x ...)))])
>         #`(: name : x ...))]))
> 
>  (define-for-syntax Number #'Number)
>  (define-for-syntax (T1 . -> . T2) #`(#,T1 -> #,T2))
> 
>  (:: twice : (let ([n (Number . -> . Number)])
>                (n . -> . n)))
>  (define (twice f) (lambda (x) (f (f x))))
>  ((twice add1) 10)
> 
> -- 
>          ((lambda (x) (x x)) (lambda (x) (x x)))          Eli Barzilay:
>                    http://barzilay.org/                   Maze is Life!