Peeja

mapped types syntax and intro

https://www.typescriptlang.org/play?#code/C4TwDgpgBA8gRgKygXigbwFBW1AZge3wC4oBnYAJwEsA7AcwBosc4BDCkmgVwFs4IKGAL4YMoSFACSAEwg1gVUAB4AKgD4U6ZtgDaAaSi0oAawgh8uKCoC6JFfuvDR46AGVWPaKhlyFy+AhqGAD0wTgAegD8omLg0AAKFPg8VKRUuCCqGqiYOFD6hjQmZhZWtlAAFACUKBqJyakQqg5BIrES9SlpuFQQ0pqdqemZAUGhEdEYsgDGADbs0NP4NORQFGDTJIPdvdKiSyvAeFzAXBReaxsAdGwU1SFheU-PUFGiuCdnEFfAABZyFQqADdWLMasgNLkcCDZtooOM3kIqkA

a tweet that prompted the idea for the talk

https://twitter.com/kentcdodds/status/1608187990215655424

but since this isn't possible with satisfies (it doesn't participate in inference, in an example like that it only provides contextual types) the answer was to use a function with a reverse mapped type

Peeja

/**
 * @jest-environment jsdom
 */

import { useObservable } from "./useObservable";
import { renderHook, act } from "@testing-library/react-hooks";
import { Subject } from "rxjs";

describe("useObservable()", () => {
  it("returns each value emitted by the Observable", () => {

Peeja

class TeeIO
  # TeeIO will write to each of these IOs when it is written to.
  def initialize(*ios)
    @ios = ios
  end

  def write(data)
    @ios.each { |io| io.write(data) }
  end

Peeja

type PathSegments<Path extends string, Segments = never> = Path extends `${infer Segment}/${infer Rest}` ? PathSegments<Rest, Segments | Segment> : Segments | Path;
type ParamSegments<S extends string> = S extends `:${infer P}` ? P : never;

let segments: PathSegments<'/posts/:id/comments/:comment_id'>;

interface Routes {
    match<Path extends string>(path: Path, cb: (params: Record<ParamSegments<PathSegments<Path>>, string>) => void): void;
}

declare const routes: Routes

Peeja

source :rubygems

gem 'rake'
gem 'rspec', '2.12.0'
gem 'rcov'

Peeja

;; Re-render when Figwheel reloads.
(gevents/listen js/document.body
                "figwheel.js-reload"
                (fn []
                  (let [root-component (om-next/app-root (compassus/get-reconciler a))]
                    (letfn [(js-vals [o]
                              (map #(aget o %) (js-keys o)))
                            ;; Finds the children of a React internal instance of a component.
                            ;; That could be a single _renderedComponent or several
                            ;; _renderedChildren.

Peeja

(defn logged-parser [parser]
  (fn [env query target]
    (js/console.groupCollapsed "parser:" (if target (str "(" target ")") ""))
    (js/console.trace)
    (js/console.debug (with-out-str (pprint query)))
    (let [ret (parser env query target)]
      (js/console.debug (with-out-str (pprint ret)))
      (js/console.groupEnd)
      ret)))

Peeja

Peeja

$ rake --trace db:test:prepare
** Invoke db:test:prepare (first_time)
** Execute db:test:prepare

$ rake --trace test:prepare
** Invoke test:prepare (first_time)
** Invoke db:test:prepare (first_time)
** Execute db:test:prepare
** Invoke db:test:load (first_time)
** Invoke db:test:purge (first_time)

Peeja

# Say you're implementing a hash map, and you've got two
# sets of algorithms which are more efficient at
# different sizes:


class HashMap
  class << self
    def with_values(values)
      if values.size > 64
        LargeHashMap.new(values)