crisu83

type OperatorFn<T> = (value: T) => T;

interface PipeFn {
  <T>(...fns: OperatorFn<T>[]): (value: T) => T;
}

const pipe: PipeFn = (...fns) => value =>
  fns.reduce((val, fn) => fn(val), value);

export default pipe;

swyxio

This is a micro RFC because i'm just jotting down an idea that I would love to have for Svelte, but I'm not sure if it belongs as an official RFC yet. the official RFC process offers no room for lightweight proposals so i am writing a gist.

see also Twitter discussion

---

The Problem

Svelte offers very useful event modifiers like preventDefault and once.

ClickerMonkey

// when T is any|unknown, Y is returned, otherwise N
type IsAnyUnknown<T, Y, N> = unknown extends T ? Y : N;
  
// when T is never, Y is returned, otherwise N
type IsNever<T, Y = true, N = false> = [T] extends [never] ? Y : N;

// when T is a tuple, Y is returned, otherwise N
// valid tuples = [string], [string, boolean], 
// invalid tuples = [], string[], (string | number)[]

sibelius

const arrayCompare = (a: string[], b: string[]) => {
  if (a.length !== b.length) {
    return false;
  }

  for (const item of a) {
    if (b.indexOf(item) === -1) {
      return false;
    }
  }

danielr18

import React from 'react'
import _ from 'lodash'
import PropTypes from 'prop-types'
import css from 'styled-jsx/css'
import { Responsive as SemanticResponsive } from 'semantic-ui-react'
import classNames from 'classnames'
import hoistNonReactStatics from 'hoist-non-react-statics'

class Responsive extends React.Component {
  static propTypes = {

ninoseki

import request from "request";
import puppeteer from "puppeteer";

const API_URL = "https://slack.com/api/files.upload";
const SLACK_API_TOKEN = process.env.SLACK_API_TOKEN as string;
const CHANNEL = "general";

(async () => {
  const url = "http://neverssl.com"
  const browser = await puppeteer.launch();

brudil

interface IProps {
  condition: boolean;
  wrap(wrapper: (children: any) => any): any;
  children: any;
}

export const ConditionalWrap = ({ condition, wrap, children }: IProps) =>
  condition ? wrap(children) : children;

kitze

import React from 'react';

const ConditionalWrap = ({condition, wrap, children}) => condition ? wrap(children) : children;

const Header = ({shouldLinkToHome}) => (
  <div>
    <ConditionalWrap
      condition={shouldLinkToHome}
      wrap={children => <a href="/">{children}</a>}
    >

maschill92

//----------------------------- MISC -------------------------------\\
//------------------------------------------------------------------\\
sv_cheats "1"
sv_showimpacts "0"
sv_showimpacts_time "2.5"

//---------------------------- BINDS -------------------------------\\
//------------------------------------------------------------------\\
bind    "SPACE"  "demo_togglepause"                     // pause/play demo
bind    "c"      "r_cleardecals"                        // get rid of bulletholes and black residue from grenade explosions

DmitrySoshnikov

/**
 * = Recursive descent parser =
 *
 * MIT Style License
 * By Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
 *
 * In this short lecture we'll cover the basic (non-predictive, backtracking)
 * recursive descent parsing algorithm.
 *
 * Recursive descent is an LL parser: scan from left to right, doing