HerringtonDarkholme

// a generic node for example
interface GNode { text: string; kind: string; next(): GNode | null; children(): GNode[]; }
// Process one node during traversal
type Process<T> = (n: GNode, t: Traversal) => Promise<T> | T
// continue the traversal to process children/siblings
interface Next { <T>(f: Process<T>): Promise<T> | T }
// traversal context
interface Traversal {
  // past nodes will be ready in Array
  ancestors: GNode[]; prevSiblings: GNode[]

HerringtonDarkholme

Q: tell me how Gemini family models can scale context to millions of token?

A:

The Gemini family of models achieves its impressive context window scaling through a combination of architectural innovations and advanced training techniques. Here's a breakdown of how they manage to handle millions of tokens:

1. Large Context Windows:

• Gemini 1.5 Pro: This model boasts a standard context window of 2 million tokens. This is significantly larger than most other large language models, allowing it to process vast amounts of information in a single request.
• Gemini 1.5 Flash: This model has a context window of 1 million tokens and is designed for high-volume, cost-effective applications.

HerringtonDarkholme

function findCombinations(numbers, targetSum) {
    const result = [];
    function find(currentSum, index, currentCombination) {
        if (currentSum === targetSum) {
            result.push([...currentCombination]);
            return;
        }
        if (currentSum > targetSum || index === numbers.length) return;

        // Include the number at the current index.

HerringtonDarkholme

React Effect Syntax Extension

This syntax extension is a mere fantasy of future React Script syntax. It is not a RFC, proposal or suggestion to React team or community. It is just a fun idea to imagine how React could be in the future.

Read this like a fan-fiction, for fun. :)

Background

There are two recent new features in React community that are introducing new extensions to JavaScript, both syntax and semantics:

HerringtonDarkholme

#define ｴｽﾃｨｰﾃﾞｨｰ std
#define ｱｲｵｰｽﾄﾘｰﾑ <iostream>
#define ﾕｰｼﾞﾝｸﾞ using
#define ｲﾌ if
#define ｲﾝｸﾙｰﾄﾞ #include
#define ｲﾝﾄ int
#define ｼｰｱｳﾄ cout
#define ｼｰｲﾝ cin
#define ﾈｰﾑｽﾍﾟｰｽ namespace
#define ﾌﾞｰﾙ bool

HerringtonDarkholme

const emailRef = ref('')

const userBio = server(async () => {
  const findUser = await import('./server')
  const userRef = ref(null)
  watch(async () => {
    userRef.value = await findUser(emailRef.value)
  })
  return (props) => (
    h('div', [userRef.value.bio]),

HerringtonDarkholme

import annotation.tailrec

abstract class Tree(val left: Tree) {
  def o = new Ball(this)
  def x = new Spike(this)
  def * = new Candle(this)
  def oxo = new BigBall(this)
  def oo = new DoubleBall(this)
  def *** = new ElectricCandle(this)

HerringtonDarkholme

# Character
You're an ast-grep assistant. As a dedicated helper, you specialize in guiding users in and about the ast-grep tool.
ast-grep has three kinds of usage: using pattern, using YAML rule and using API. Your task is to identify the most proper 
use case.
* Pattern can match simple and straightforward expression/constructs in programming language.
* YAML can match complicate expressions and take the surrounding AST around the expression.
* API is the most flexible and powerful tool for users to implement their own matching logic. Custom matching should use API.

# Actions

HerringtonDarkholme

Using open source software can be a double-edged sword: We enjoy the latest features and innovations, but we hate frequent and sometimes tedious upgrades.

Bevy is a fast and flexible game engine written in Rust. It aims to provide a modern and modular architecture, notably Entity Component System(ECS), that allows developers to craft rich and interactive experiences. However, the shiny new engine is also an evolving project that periodically introduces breaking changes in its API. Bevy's migration guide is comprehensive, but daunting. It is sometimes overwhelmingly long because it covers many topics and scenarios.

In this article, we will show you how to make migration easier by using some command line tools such as git, cargo and ast-grep. These tools can help you track the changes, search for specific patterns in your code, and automate API migration. Hope

HerringtonDarkholme

type ComponentPublicInstance<C, Options> = {
  $options: Options & 'intersection anything'
} & ExtractComputedReturns<C>

type WhatEver<T> = T extends 1 ? true : false

type MixinToOptionTypes<T> = T extends ComponentOptionsBase<
  infer C, 1, 1
>
  ? OptionTypesType<C>