cond

But I wouldn't say [each for each in [expensive_call(x) for x in seq] if cond(each)] is more readable than filter(cond, map(expensive_call, seq)) at least for functional-thinking minds.

You think of a for/if cond() break, and you need to rethink this on functional (and a lot of other things).

You could have used symbols: (define (cons x y) (lambda (method) (cond ((eq?

I've seen implicit rules about top-level expression being implicitely wrapped in parens you one can write defun fact (n) (cond..

Here's how `map` is defined in KLambda: (defun map (f l) (shen.map-h f l ())) (defun shen.map-h (f l accum) (cond ((= () l) (reverse accum)) ((cons?

Every time I see something like [fn(x) for x in xs for xs in xss if cond(xs)] I always think it's a loop, then an inner loop (and loops -> procedure...

} var myFruit = GetApple(); // type is Apple if (cond) myFruit = GetOrange(); // can't assign orange In this scenario you have to declare explicitly as Fruit.

Map/filter require nesting: (filter (map expensive_call X) cond) So do list comprehensions: [y for y in [expensive_call(x) for x in X] if cond(y)] Near as I can tell, the only difference is that list comprehensions also provide a syntactic sugar for the convenience function filter_then_map.

Actually only one line of code is enough for each of map/filter: def map(fn, seq): return [fn(each) for each in seq] def filter(cond: seq): return [each for each in seq if cond(each)] But seriously, what do you really gain by removing these two?

Doesn't look like anything more than a sexp reader; very limited (I am guessing a 1-2 day hack.) All it has are: atom, eq, car, cdr, cons, cond, lambda, define (for variables!) and defun.

Most of my string formatting is done for awful awful uses of printf-debugging, so I could use something like your dictionary to do "{var} failed to {cond}".format(**vars) and later I want to reformat it, I just change the string, but don't have to touch the format() arguments.

Args> decltype(auto) operator()(F1, F2 f2, Args&&...args) const { return f2(std::forward<Args>(args)...); } }; template<bool Cond> constexpr static_if_impl<Cond> static_if{}; template <class T, class...

The make_unique example given could be implemented in a similar manner with existing C++ features, and it would not require yet another complexity-inducing feature into C++: #include <memory> #include <type_traits> #include <utility> template<bool Cond> struct static_if_impl { template<typename F1, typename F2, typename...