serjKim

interface Data {
    age?: number;
    a: string | null;
    c: string;
}

function f<T extends Partial<Data>>(d?: T & { [K in keyof T]: K extends keyof Data ? T[K] : never }): Pick<Data & T, keyof Data> {
    return {
        c: 'default',
        a: 'asd',

serjKim

git stash show -p -u stash@{0} > Stash0.patch
git apply Stash0.patch

serjKim

class UserStorage {
    private readonly reload$ = new Subject<void>();
    private readonly userId$ = new ReplaySubject<number>(1);
    public readonly user: Observable<string>;
    constructor() {
        this.user = combineLatest([
            this.reload$.pipe(startWith(undefined)),
            this.userId$
        ]).pipe(
            switchMap(([_, userId]) => this.loadUser(userId)),

serjKim

// Nominal types (branding)

module BrandedTypes {
    const BRAND = Symbol();

    type Branded<T, TBrand> = T & { readonly [BRAND]: TBrand };

    export type UserId = Branded<number, 'userId'>;
    export type RoleId = Branded<number, 'roleId'>;

serjKim

<ng-template cdkPortal>
  <div class="popup">
    <div class="arrow"></div>
    <ng-content></ng-content>
  </div>
</ng-template>

serjKim

<Project>
  <PropertyGroup>
    <CodeAnalysisRuleSet>..\MyRuleset.ruleset</CodeAnalysisRuleSet>
  </PropertyGroup>
  <ItemGroup>
    <AdditionalFiles Include="..\stylecop.json" Link="stylecop.json" />
  </ItemGroup>
</Project>

serjKim

module Redux =
    type Reducer<'S, 'A> = 'S option -> 'A -> 'S
    type IRootReducer = interface end
    type IStore = interface end
    type IDispatch<'A> = 'A -> unit

    let combineReducers (reducers: {| listReducer: Reducer<'S, 'A> |}): IRootReducer = importMember "redux"
    let createStore (rootReducer: IRootReducer): IStore = importMember "redux"
    let useSelector (selector: 'S -> 'TS) : 'TS = importMember "react-redux"
    let useDispatch<'A> () : IDispatch<'A> = importMember "react-redux"

serjKim

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="Program.fs" />
  </ItemGroup>

serjKim

type Entity = { ArrivalDate: DateTime }

type IDb =
    abstract member Conn: string

type Workflow<'Result> = Workflow of (IDb -> 'Result)

let db = { new IDb with member x.Conn = "asd"  }

let run idb (Workflow fn) = fn idb

serjKim

let inline (|HasLength|) x = 
  fun () -> (^a: (member Length: int) fst x)

let inline (|HasMethod|) x = 
  fun () -> (^a: (member Method: int with get) snd x)

let inline length (HasLength f1 & HasMethod f2) = 
    let a = f1()
    let b = f2()
    a + b