Grohden

import VibrantCore from '@vibrant/core';

import { pipeline } from './pipeline.ts';
import { ReactNativeImage } from './react-native-image.ts';

export const Vibrant = VibrantCore;


// Don't forget to add this to your app root:
// useEffect(() => {

Grohden

// this heavily uses ramda 
// this was done quickly to just make it work, its variale names essentialy do not have correct names
// this does not generate duration information


// you can just past it in ramda and it will run 
// https://ramdajs.com/repl
// take the result and feed it into the alphaTab

Grohden

module Prelude
  class Functor
    def initialize(value)
      @value = value
    end

    # All implementers must satisfy
    # (a -> b) -> f a -> f b
    def fmap
      self.class.new(yield @value)

Grohden

The [lookahead][1] feature is exposed through an [extra][2]:

field :organizations, [Organization], extras: [:lookahead]

By declaring the lookahead extra we can use it to know which fields the client is asking for (through selects?):

def organizations(lookahead:)

Grohden

void main() {  
  final sum2 = curry2((int a, int b) => a + b);
  final sum3 = curry3((int a, int b, int c) => a + b + c);
  
  print(sum2(1));
  print(sum2(1)(2));
  
  print(sum3(1));
  print(sum3(1)(2));
  print(sum3(1)(2)(3));

Grohden

# frozen_string_literal: true

dot = 'cuchi'
dash = 'paulo'

# our tree is based on this image
# https://upload.wikimedia.org/wikipedia/commons/thumb/1/19/Morse-code-tree.svg/1280px-Morse-code-tree.svg.png
$morse_tree = {
  dot => {
    char: 'e',

Grohden

const fs = require('fs');

const filterMap = (list, map) => {
  const mapped = [];

  for (let i = 0; i < list.length; i++) {
    const transformed = map(list[i]);
    if (transformed) {
      mapped.push(transformed);
    }

Grohden

const fs = require('fs');
const path = require('path');

const ts = require('typescript');

/**
 * Parses a barrel (index) file, extracts all it's export
 * names and returns an object that maps
 * a import name to the path + some meta infos.
 *

Grohden

type Foo = {
  // Assigning undefined here is wrong.
  // this value either HAVE A KEY WITH VALUE or DON'T HAVE A KEY
  [key: string]: { foo: string }
  // const foo: Foo = { key: undefined }
  // 'key' in foo // true, but should never be the case, because if there's a key, there's a value.
}

// note: the only case where the index signature might be correctly represented
// is when we use a proxy, that way we can guarantee that we always return something 

Grohden

function* map(morphism, itr) {
  let value;
  while(value = itr.next().value) {
    yield morphism(value);
  }
}


function* filter(predicate, itr) {
  let value;