jtbandes

protocol P {
    var dynamicTypeAsMember: P.Type { get }
}
struct T: P {}

extension P {
    var dynamicTypeAsMember: P.Type {
        return self.dynamicType
    }
}

jtbandes

func sequence<T>(_ initial: T, _ cond: (T) -> Bool, _ update: (inout T) -> ()) -> UnfoldSequence<T, T> {
  return sequence(state: initial, next: { (state: inout T) -> T? in
    guard cond(state) else { return nil }
    update(&state)
    return state
  })
}

for x in sequence(4, { $0 < 10 }, { $0 = $0 + 1 }) {
  print(x)

jtbandes

#include <iostream>
#include <regex>


template<typename StringT>
struct regex_searcher_t {
    
    using IterT = decltype(std::begin(std::declval<const StringT&>()));
//    using CharT = typename std::decay<decltype(*std::declval<IterT>())>::type;
    using CharT = typename std::iterator_traits<IterT>::value_type;

jtbandes

A summary of compiler crashers still open as of 2017/2/9. Thanks to @slavapestov for further diagnosis on several of these.

Fixed!

By @rudkx in swiftlang/swift#7481:

• struct A{let d}A(_,print()) 28654-hastype-e-expected-type-to-have-been-set.swift

• A(_{}struct A{var f 28590-exprtypes-e-isequal-e-gettype-expected-type-in-map-to-be-the-same-type-in-expres.swift

jtbandes

#include <iostream>
using namespace std;
template<int N, char C, char... Cs> struct repeatImpl : repeatImpl<N-1, C, C, Cs...> {};
template<char C, char... Cs> struct repeatImpl<0, C, Cs...> {
    static constexpr char cs[] = {Cs..., '\0'};
};
template<char C, char... Cs> constexpr char repeatImpl<0, C, Cs...>::cs[];

template<int N, char C> const char (& repeat())[N+1] {
    return repeatImpl<N, C>::cs;

jtbandes

extension String {
  func lazyComponents(separatedBy sep: Character) -> AnySequence<String> {
    return AnySequence<String> { [cv = self.characters] () -> AnyIterator<String> in
      var current = cv.startIndex
      var finished = false
      return AnyIterator<String> {
        if finished {
          return nil
        }

jtbandes

# Inspired by: https://www.futilitycloset.com/2017/04/17/a-poets-arsenal/
# Word lists from the Opinion Lexicon: https://www.cs.uic.edu/~liub/FBS/sentiment-analysis.html

from itertools import product, imap, ifilter, chain
import multiprocessing

def load_words(path):
    with open(path) as f:
        words = ifilter(lambda line: line.rstrip() and not line.startswith(";"), f)
        return map(lambda word: word.rstrip(), words)

jtbandes

node_modules
out
package-lock.json

jtbandes

type MaybeAwait<P> = P extends Promise<infer T> ? T : P;

function maybeAsync<Args extends unknown[], TYield, TReturn>(
  body: (...args: Args) => Generator<TYield, TReturn, MaybeAwait<TYield>>
): (...args: Args) => (TYield extends Promise<infer _P> ? Promise<TReturn> : TReturn);

function maybeAsync<Args extends unknown[], TYield, TReturn>(
  body: (...args: Args) => Generator<TYield, TReturn, MaybeAwait<TYield>>
): (...args: Args) => (Promise<TReturn> | TReturn) {
  return (...args: Args) => {

jtbandes

FROM ubuntu:jammy

RUN apt-get update && apt-get install -y --no-install-recommends --no-install-suggests \
    git \
    python3 \
    python3-pip \
    cmake \
    clang \
    llvm-dev \
    libclang-dev \