https://blog.racket-lang.org/2017/10/racket-v6-11.html

Typed Racket supports refinement types and dependent function types. Previously
an experimental feature, refinement types allow types to describe more
interesting properties of values, especially integers. For example, this type
shows that the max function always produces a number at least as big as its
inputs:

(-> ([x : Integer] [y : Integer])
(Refine [z : Integer]
(and (>= z x) (>= z y))))


ADTs in Typed Racket with macros

Немного изящного (макроебства)[http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/] и в тайпед/ракетке можно юзать ADT с паттерн матчингом.
(Прямо как во взрослых крутых языках).

(define-datatype Expr
  (Value Number)
  (Add Expr Expr)
  (Subtract Expr Expr)
  (Multiply Expr Expr)
  (Divide Expr Expr))

(: evaluate (Expr -> Number))
(define (evaluate e)
  (match e
    [(Value x)      x                            ]
    [(Add a b)      (+ (evaluate a) (evaluate b))]
    [(Subtract a b) (- (evaluate a) (evaluate b))]
    [(Multiply a b) (* (evaluate a) (evaluate b))]
    [(Divide a b)   (/ (evaluate a) (evaluate b))]))

> (evaluate (Add (Value 1)

                 (Multiply (Divide (Value 1) (Value 2))
                           (Value 7))))
4 1/2

Интересно, ебанется ли кто-нить достаточно чтобы набыдлить какой-нить аналог хаскеля или scalaz?

Просто и элегантно.
Спасибо динамической типизации!

#lang racket
(require math)
(require racket/match)

(define (inverse func)
  (match func
    ['exp log]
    ['cos acos]
    [_ #f]))

(printf "Inv[~a](~a) = ~a\n" 'exp (exp 1) ((inverse 'exp) (exp 1)))
(printf "Inv[~a](~a) = ~a\n" 'cos 1       ((inverse 'cos) 1))

http://pasterack.org/pastes/74110

Inv[exp](2.718281828459045) = 1.0
Inv[cos](1) = 0


Новая ракетка вышла.

Roughly, hygienic macro expansion is desirable for the same reason as lexical scope: both enable local reasoning about binding so that program fragments compose reliably. The analogy suggests specifying hygienic macro expansion as a kind of translation into lexical-scope machinery. In that view, variables must be renamed to match the mechanisms of lexical scope as macro expansion proceeds. A specification of hygiene in terms of renaming accommodates simple binding forms well, but it becomes unwieldy for recursive definition contexts (Flatt et al. 2012, section 3.8), especially for contexts that allow a mixture of macro and non-macro definitions. The renaming approach is also difficult to implement compactly and efficiently in a macro system that supports “hygiene bending” operations, such as datum->syntax, because a history of renamings must be recorded for replay on an arbitrary symbol.

In a new macro expander for Racket, we discard the renaming approach and start with a generalized idea of macro scope, where lexical scope is just a special case of macro scope when applied to a language without macros. Roughly, every binding form and macro expansion creates a scope, and each fragment of syntax acquires a set of scopes that determines binding of identifiers within the fragment. In a language without macros, each scope set is identifiable by a single innermost scope. In a language with macros, identifiers acquire scope sets that overlap in more general ways.

http://www.cs.utah.edu/plt/scope-sets/index.html

The Racket Manifesto
http://www.ccs.neu.edu/home/matthias/manifesto/index.html

The creation of a programming language calls for guiding principles that point the developers to goals. This article spells out the three basic principles behind the 20-year development of Racket. First, programming is about stating and solving problems, and this activity normally takes place in a context with its own language of discourse; good programmers ought to formulate this language as a programming language. Hence, Racket is a programming language for creating new programming languages. Second, by following this language-oriented approach to programming, systems become multi-lingual collections of interconnected components. Each language and component must be able to protect its specific invariants. In support, Racket offers protection mechanisms to implement a full language spectrum, from C-level bit manipulation to soundly typed extensions. Third, because Racket considers programming as problem solving in the correct language, Racket also turns extra-linguistic mechanisms into linguistic constructs, especially mechanisms for managing resources and projects. The paper explains these principles and how Racket lives up to them, presents the evaluation framework behind the design process, and concludes with a sketch of Racket’s imperfections and opportunities for future improvements.

Поставил racket-mode. Вроде нормас.

Вчера кто-то, похожий на ляха, вышел на связь.

<chare> why should we use Racket over Haskell?
<bremner> maybe you shouldn't. What are you looking for?
<chare> so explain to me why use Racket over Haskel
<Jooles> chare, explain to me blue over yellow
<Jooles> it's not as simple as that
<chare> so explain why its not simple
<bremner> chare: c'mon, either engage, or stop trolling.
<chare> you guys are the experts on racket not me

YAY, racket 6.1.1 is out.

На лоре опять выходит на связь упоротый жаваскриптер со своими охуительными вопросами.

На этот раз он утверджает что поскольку в JS apply принимает дополнительный параметр - объект, this которого будет активным во время функции, которую вызывает apply, то это является более мощной АБОСРАКЦИЕЙ.

Хуйта канеш. От нечего делать накидал подобную херню в схемке. ths лексически биндится на передаваемый объект в теле функции.

#lang racket
(require syntax/parse/define)
(require racket/stxparam)

(define-syntax-parameter ths 
    (lambda (stx) (raise-syntax-error #f "Not used inside js-apply!" stx)))

(define-simple-macro (js-apply obj:expr fn:expr args...)
  (let ([this-obj obj])
    (syntax-parameterize ([ths (make-rename-transformer #'this-obj)])
             (apply fn args...))))


(js-apply (new (class object% 
         (super-new) 
         (init-field [x 10])))
      (lambda (y) (+ y (get-field x ths)))
      (list 1))

;; 11

Родилось в одним из диалогов с дедфудом.

Позволяет юзать синтаксис как у околохацкеля чтобы задавать значения и объявлять лямбдочки.
Для полноценной костылезации надо переопределять свой reader через #lang, что делать конечно лень.

;; gayfood.rkt
#lang racket

(require syntax/parse)
(require (for-syntax syntax/parse))
(provide (all-defined-out))

(begin-for-syntax
 (define-syntax-class gaylambda
   #:literals (->)
   (pattern (-> (arg:id ...) body:expr))))

(define-syntax (-> stx)
  (syntax-parse stx
                [f:gaylambda #'(lambda (f.arg ...) f.body)]))

(define-syntax (= stx)
  (syntax-parse stx
                #:literals (=)
                [(= a:id b:expr) #'(define a b)]))

;; test
#lang sweet-exp racket
require("gayfood.rkt")

{ closureLambda = {(i) -> {i * i}} }

printf("closureLambda(10) = ~a\n" closureLambda(10)) 

выводит 100, охуеть, правда?

Интервью с одним из авторов ракетки.
http://blog.cognitect.com/cognicast/061-matthew-flatt

Нашел одну херотень в ракетке.
Когда tox присылет асинхронно сообщения, то контрол editor иногда кидает эксепшеном что мол метод insert вызван на залоченом редакторе и идите нахуй:

sequence-contract-violation: negative: method insert cannot be called, except in states (unlocked)


Такое проявляется если tox начинает срать безостановочно кучей сообщений с мелким интервалом (спасибо штилетте)

Пока навернул такой костыль, но это жуткая ебанина, буду долбиться в их список рассылки за объяснениями.
```
(call/cc
(lambda (cc)
(with-handlers ([exn:fail?
(lambda (ex)
(sleep 1)
(cc))])

       (send editor insert message))))

Eduardo Costa writes:

Is there anything in the semantic of Python that makes it much more difficult to
implement a Python compiler than a Racket compiler?

Python is much more dynamic than Racket. As an illustration, look at a simple
operation: addition. In Racket,

(+ a b)

requires dispatching on the types of a and, from a finite (and small)
list of admitted candidates (fixnum, flonum, ...). Anything else is an error.

In Python,

a + b

is just syntactic sugar for

a.__add__(b)

which means (1) Look up the type of a, (2) look up 'add' in the
method dictionary of that type and its supertypes, (3) if not found,
look up 'radd' in the method dictionary of the type of b, (4) call
the resulting method. None of the intermediate lookups can be cached
because everything might be different the next time that operation is
executed: a and b can have different types, and the definition of
add for the types of a and b can have changed.

Konrad.

лан.

racket 6.0 вышел:

* новый пакетный манагер
* базавая установка распилена на > 200 пакетов
* компилятор JIT для arm
* значительный улучшения производительности в typed/racket
* Новый профайлер для контрактов сообщает как долго проверяются контракты.
(дохера важная фича кстати)

http://blog.racket-lang.org/2014/02/racket-v60.html