hachibeeDI

import 'package:meta/meta.dart';
import 'package:flutter/material.dart';

abstract class RouteSetting {
  List<Route> toInstance();
}

class Route<Arguments> {
  final String name;
  final bool initial;

hachibeeDI

import 'dart:async';

import 'package:equatable/equatable.dart';
import 'package:flutter/material.dart';

enum RemoteStatusType {
  NotAsked,
  Loading,
  Succeed,
  Failed,

hachibeeDI

import * as React from 'react';
import { useMemo, useContext, createContext, ReactNode } from 'react';
import { createPortal } from 'react-dom';

type Context = { portalID: string };
const PortalContext = createContext<Context>({} as any);

export function createSplitGate<T>(render: (arg: T) => ReactNode) {
  return {
    Zone: (props: Context & { children: ReactNode }) => {

hachibeeDI

unknown

unknown is safe version of any.

We should consider unknowon first then any.

Union types

When would like to take multiple type as argument.

hachibeeDI

/*
      <ListThrottle<string> items={strs}>
        {({renderPrevCreatives, renderNextCreatives, throttledItems}) => (
          <SomeAwesomeComponentSupportsScroll
            superHandlerCatchOnScrollTop={renderPrevCreatives}
            superHandlerCatchOnScrollEnd={renderNextCreatives}
          >
            <ul>
              {throttledItems.map(str => (
                <li>{str></li>

hachibeeDI

def mmp(f):
    def _m(x, prev=None):
        if prev:
            yield from prev
        yield f(x)
    return _m


def fft(f):
    def _m(x, prev=None):

hachibeeDI

const withStateToggle = (name, defaultValue) => ComposedChild => (
    class Container extends Component {
        constructor (props) {
            super(props);

            this.state = {
                [name]: defaultValue
            };

            this.toggle  = this.toggle.bind(this);

hachibeeDI

import {EventEmitter} from 'events';

import React, {Component} from 'react';

import Modal from 'components/modal';


export default function WithModal (id, title, trigger) {
  return (TargetComponent, key, descriptor) => class extends Component {
    constructor() {

hachibeeDI

import debounce from 'lodash.debounce';


export default function validationDebounceMiddlewareGenerator ({triggerActionTypes, validatorActionType, wait}) {

    const createValidateActionDebounced = debounce(
        dispatch => dispatch({type: validatorActionType}),
        wait
    );

hachibeeDI

import asyncio
from time import sleep, time


def blocker(txt):
    sleep(3)
    return 'aaa' + txt


def async_sample(loop):