Один из главных отососов в современных языках программирования - это отсутсвие во многих из них поддержки keyword arguments.

Эта хуйня существенно повышает читаемость и, как следствие, качество кода.

В некоторых ЯП, в которых есть встроеные литералы для словарей проблема может решаться ими.
В остальных - это мрак, отсос и говно.

Как ни странно, божественная статическая типизация тут не роляет совершенно. Ведь очень легко перепутать аргументы с одинаковыми типами местами и потом долго ломать голову какого Х не работает. В случае keyword args достаточно поверхностного осмотра кода, чтобы понять что не так.

https://gist.github.com/lexszero/03b959b70ba31b3441d7
Костыль для профайлинга башеговна.

[I]l…@n…d ~ > cat 1.sh 
#!/bin/bash
echo foo
sleep 1
echo bar

[I]l…@n…d ~ > bash_dbg 1.sh 
foo
bar
1453349630.074218273    + bash -x 1.sh
 0.001578295    + echo foo
 0.000074152    + sleep 1
 1.003924465    + echo bar
 0.000391305    + set +x

Total:  1.005968217

GPU text rendering with vector textures.
http://wdobbie.com/post/gpu-text-rendering-with-vector-textures/
demo

Вот тут кто-то [наговнил] либу для параллелизма для Rust:

let total_price = stores.par_iter()
.map(|store| store.compute_price(&list))
.sum()


Конечно мало сделать параллелизм простым, его надо сделать ещё и безопасным. Rayon гарантирует, что использование его API никогда не приведёт к гонке данных.

Мне вот интересно, неужели в rust нет способа захватить ref на Weak Box и таким образом выстрелить себе в ногу (ну или организовать race condition).

Не слишком ли громкое заявление?

Олсо, реквестирую подобных либ для плюсцов.

https://github.com/eudoxia0/magma
Осторожно, наркомания. Костыльсет для сишки с модными фичами типа лямбд, лени, ADT, какого-то вывода типов и всего что можно написать на лисповой макре.

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?

cat ~/bin/420

!/bin/bash

while :; do
d=date
grep '4.*2.*0' <<< "$d" >/dev/null && {
notify-send -u critical "It's 4:20 time" "$d"
sleep 60
} || {
sleep 1
}
done

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

#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


Охуенно выразительно и красиво. Спасибо статической типизации.

struct Node<T> { 
    prev: Raw<T>, 
    next: Link<T>, 
    elem: T, 
} 

type Link<T> = Option<Box<Node<T>>>; 

struct Raw<T> { 
    ptr: *mut Node<T>, 
} 

pub struct LinkedList<T> { 
     len: usize, 
     head: Link<T>, 
     tail: Raw<T>, 
} 

есть либа, которую загружаю через dlopen, можно ли как-то подменить внешний символ, который будет использоваться в этой либе? конкретно я хочу, чтобы всё что внутри либы использовало кастомный malloc, а вот всё что снаружи — обычный

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

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

yay отличная книжка чтобы освежить память и накидать пару несложных нейронок на своем уютном маня-язычке.

http://neuralnetworksanddeeplearning.com/