cgsdev0

#!/usr/bin/env bash

function house_builder() {
  # floors,rooms,has_garage
  echo "0,0,0"
}

function set_field() {
  local f r g
  IFS=, read f r g

tjjfvi

type _I = Reduce<[S, K, K]>
//   ^?
type One = I
type Zero = Reduce<[K, I]>
//   ^?
type Add = { a: { b: { i: { z: ["a", "i", ["b", "i", "z"]] } } } }
type Mul = { a: { b: { i: ["a", ["b", "i"]] } } }
type Two = [Add, One, One]
type Three = [Add, Two, One]
type Six = [Add, Three, Two]

mattyellen

public static class ExtensionMethods
{
    public static TaskAwaiter GetAwaiter(this AsyncOperation asyncOp)
    {
        var tcs = new TaskCompletionSource<object>();
        asyncOp.completed += obj => { tcs.SetResult(null); };
        return ((Task)tcs.Task).GetAwaiter();
    }
}

Kavignon

Some of the books I'll be recommending are based on .NET. Do not be discouraged. We shouldn't strive to stick to a specific technology stack. Your ambitions and goals will evolve over time and that might lead you a completely new space. Moreover, there are lessons to be learned from an environment that's different from what you're used to.

Software Development

• "C# in depth" by Jon Skeet (Book)

• "F# for C# developers" by Tao Liu (Book)

• F# to C# interop tips by Scott Wlaschin (Gist)

• Effective F#, tips and tricks (Gist)

kognise

• Create a repository and set it to private if you want
• In your vault, run these commands substituting the values

  git init
  git add .
  git commit -m "Initial commit"
  git remote add origin git@github.com:<USERNAME>/<REPO_NAME>.git
  git push -u origin master
  

• Now...

acutmore

A compile-time 4-Bit Virtual Machine implemented in TypeScript's type system. Capable of running a sample 'FizzBuzz' program.

Syntax emits zero JavaScript.

type RESULT = VM<
  [
    ["push", N_1],         // 1
    ["push", False],       // 2
 ["peek", _], // 3

WebReflection

const env = {
  m1: `import {func} from './m2.mjs'; console.log(func());`,
  m2: `export function func() { return 'abc'; }`
};

const inlineModule = (env, text) => `data:text/javascript;base64,${
  btoa(inlineModules(env, text))
}`;

const inlineModules = (env, text) => text.replace(

simlrh

interface Composable<B,C> {
  (b: B): C;
  I: <D>(f: (c: C) => D) => Composable<B,D>;
  o: <A>(f: (a: A) => B) => Composable<A,C>;
}

/*
 * Non-type safe internal function - type safety of result is guaranteed by
 * allowing creation only through `I` and `o` functions and methods
 */

patroza

// "controller"
(ctx, next) => {
   let presenter = new Presenter(ctx)
   let interactor = new Interactor(presenter)
   interactor.handle(getRequestFrom(ctx))
}

class Presenter {
   constructor(ctx) { this.ctx = ctx }
   present(response) {

gusbicalho

START HERE: You are not so smart

• Predictably Irrational https://www.amazon.com.br/dp/0061353248/
• Rápido e devagar https://www.amazon.com.br/dp/853900383X/
• Misbehaving: A Construção Da Economia Comportamental https://www.amazon.com.br/dp/8551004131/
• Influence: Science and Practice https://www.amazon.com.br/dp/0205609996/

I recomend reading at least two of the above.

If you feel like you know enough about how your mind is fucked-up miscalibrated, you can move on to the lists below. Each one has a few sublists. The order of the sublists does not matter. For each sublist, the first link is the one I see as a good starting point, but the order does not matter too much, either.