nythrox

import React, { useRef } from "react";
export const state = <F extends (...args: any[]) => any>(create: F) => {
    const context = React.createContext<ReturnType<F>>(undefined as any)
    return {
        Provider: context.Provider,
        create,
        use: () => React.useContext(context),
        context,
    }
};

nythrox

// the [Scope] of a [Expression] holds unbound variables
// in this implementation, scope works from the bottom-up:
// Var consumes declares a variable as consumed: (Var "a") :: { scope: { a: true } }
// Lambda supplies a variable, making it fresh
// Application joins the dependencies of its expressions: (Apply (Var "a") (Var "b")) :: { scope: { a: true, b: true } }
// and guarantees that its Lambda body cannot consume variables that its Argument has marked as consumed
//  (Apply (Var "a") (Var "a")) will declare { a: false } so that its body can't use { a: true }

// The motivation for evaluating this bottom-up is that, on the type level, Typescript 
// would require Context to be passed as a separate parameter for every single expression if evaluated top-down. 

nythrox

Creating Generative Art using Capi and Polkadot NFTs

In this guide we'll learn how to create algorithmically generated NFTs. We'll cover creating a Deno project, generating the images using the Canvas API, uploading them to IPFS, and minting them to Westmint using Capi.

Getting stared

In this guide we'll be using Deno, but you can also use node. If you don't have deno installed, make sure to get it installed [here].(https://deno.land/[email protected]/getting_started/installation)

To create a new Deno application, you can open your command line and run these commands to setup the project folder and create main.ts:

mkdir gen-art-nfts

nythrox

extension on BuildContext {
  TextStyle get paragraph => TextStyle(fontSize: 22, color: Colors.grey[900]);
}

Widget build(BuildContext context) {
  return Column(
    children: [
      Text("Hello world", style: context.paragraph),
      Text("Hello world, again", style: context.paragraph(color: Colors.red)),
    ],

nythrox

const envars = { secret: "hello world" }

const stringifyEnv = (env) => {
  _= env
  _= Object.keys(_)
  _= _.map(envar => `${envar}=${envars[envar]}`)
  _= _.join('&')
  return _
}

nythrox

// user: Either<string, { name: string, age: number }>
const user = doEither(function*() {
  // name: string
  const name = yield* Right("test")
  // age: number
  const age = Math.random() > 0.5 ? yield* Right(100) : yield* Left("oopsies")
  return {
     name,
     age
  }

nythrox

main() {
  setupImmutable(() => User());

  final user1 = create(User()
  ..name = "uwu"
  ..age = 100);

  final user2 = copy(user1..name = "owo"..child = User());

  final user3 = copy(user2..name = "eheh");

nythrox

void main() {
  mainContext.config = mainContext.config.clone(writePolicy: ReactiveWritePolicy.never);
  runApp(MyApp());
}

class TestCounterStore {
  // ObservableInt
  final count = 0.obs;
  // ObservableString
  final name = "olá".obs;

nythrox

void main() {
  Greeting message = Hi();

  final result = match(message, {
    on((Hi hi) => "hello, ${hi.name}"),
    on((Bye bye) => "bye, see you at ${bye.seeYouAgain}"),
    otherwise(() => throw Error()),
  });

  print(result);

nythrox

main() {
  // Either<dynamic, int> result
  final result = Either.Do(() {
      final num1 = perform(Right(5));
      final num2 = perform(Right(2));
      return num1 * num2;
  });
  print(result.value); // 10
  // Option<int> result2
  final result2 = Option.Do(() {