Michel's questions

Em um aplicativo web (NextJS/React), estou usando react-tabs para manipular guias.

Gostaria de saber como manter os cabeçalhos das abas fixos. Isso está impedindo que eles rolem para cima e desapareçam quando eu rolar para cima o conteúdo da página.

Depois de pesquisar na internet, tentei usar react-sticky, mas parece que não funciona.

Eu até tenho a impressão de que react-tabs e react-sticky não devem funcionar juntos. Diga-me se estou errado.

Aqui está o código atual relevante:

import { Tabs,TabList,Tab,TabPanel } from 'react-tabs';
import 'react-tabs/style/react-tabs.css';
.....

return (
  <Tabs defaultIndex={tabInit()}>
    <TabList>
      <Tab>Title-One</Tab>
      <Tab>Title-Two</Tab>
      <Tab>Title-Three</Tab>
      <Tab>Title-Four</Tab>
      <Tab>Title-Five</Tab>
      <Tab>Title-Six</Tab>
    </TabList>
    <TabPanel><Contents-One/></TabPanel>
    <TabPanel><Contents-Two/></TabPanel>
    <TabPanel><Contents-Three/></TabPanel>
    <TabPanel><Contents-Four/></TabPanel>
    <TabPanel><Contents-Five/></TabPanel>
    <TabPanel><Contents-Six/></TabPanel>
  </Tabs>
)

Como posso obter o efeito que preciso ao usar react-tabs?

Em um banco de dados em tempo real (no Firebase), tenho as seguintes regras para a coleção chamada Resource:

{
  "rules": {
    ....
      "Resource": {
        ".read": true,
          ".indexOn": ["FieldOne","FieldTwo"]
      },
    ....
  }
}

As coisas funcionam do jeito que eu desejo. Gostaria, no entanto, de fazer algumas melhorias.

Aqui está meu problema. Neste ponto, posso adicionar um documento à coleção a partir da CLI usando um comando como este:

firebase database:push /..path../Resource --data '{"FieldOne":"field-1-value","FieldTwo":"field-2-value"}'

Claro que também posso adicionar documentos de diferentes maneiras. Mas meu problema é que posso repetir o mesmo comando acima e adicionar novamente o mesmo documento na coleção Resource.

Quero saber como alterar minhas regras para evitar a possibilidade de adicionar dados duplicados.

Exatamente isso é o que eu gostaria, depois de executar o comando acima, eu ainda deveria conseguir inserir esses documentos na coleção:

{"FieldOne":"field-3-value","FieldTwo":"field-4-value"}
{"FieldOne":"field-1-value","FieldTwo":"field-5-value"}
{"FieldOne":"field-7-value","FieldTwo":"field-2-value"}

Mas, eu não deveria conseguir inserir este:

{"FieldOne":"field-1-value","FieldTwo":"field-2-value"}

Eu poderia, é claro, escrever código para controlar o que está chegando, no caso de funções de nuvem ou no caso de dados sendo digitados por meio de uma interface da web. Mas esse não é o ponto da presente questão. Eu só quero saber se há uma maneira inteligente de configurar as regras para evitar a possibilidade de dados indesejados começarem.

Embora eu já use Common Lisp no Linux há algum tempo, minha experiência com SBCL no Mac ainda é quase nula.

Acabei de instalar o SBCL no Mac (Sonoma 14.2.1) usando homebrew.

Agora tenho: SBCL 2.4.1

Estou encontrando um problema com o seguinte teste.

Aqui está o programa de teste:

me % cat test.lisp
#!/opt/homebrew/bin/sbcl --script

(with-input-from-string (strm (car *args*)) (setf ArgOne (read strm)))
(with-input-from-string (strm (cadr *args*)) (setf ArgTwo (read strm)))

(format "Argument One = ~a~%" ArgOne)
(format "Argument Two = ~a~%" ArgTwo)
me % 

Quando este mesmo programa (exceto a primeira linha) foi executado sob clisp no debian como:

me % ./test.lisp 11 23

produziria:

Argument One = 11
Argument Two = 23

como eu esperava.

Mas quando executado em sbcl no Mac, como:

me % ./test.lisp 11 23

Produz esta saída inesperada:

; file: /...././test.lisp
; in: WITH-INPUT-FROM-STRING (STRM (CAR *ARGS*))
;     (CAR *ARGS*)
; 
; caught WARNING:
;   undefined variable: COMMON-LISP-USER::*ARGS*

;     (SETF ARGONE (READ STRM))
; 
; caught WARNING:
;   undefined variable: COMMON-LISP-USER::ARGONE
; 
; compilation unit finished
;   Undefined variables:
;     *ARGS* ARGONE
;   caught 2 WARNING conditions
Unhandled UNBOUND-VARIABLE in thread #<SB-THREAD:THREAD "main thread" RUNNING
                                        {7005550003}>:
  The variable *ARGS* is unbound.

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {7005550003}>
0: ((LAMBDA NIL :IN "/..../test.lisp"))
1: (SB-INT:SIMPLE-EVAL-IN-LEXENV (WITH-INPUT-FROM-STRING (STRM (CAR *ARGS*)) (SETF ARGONE (READ STRM)))     #<NULL-LEXENV>)
2: (EVAL-TLF (WITH-INPUT-FROM-STRING (STRM (CAR *ARGS*)) (SETF ARGONE (READ STRM))) 0 NIL)
3: ((LABELS SB-FASL::EVAL-FORM :IN SB-INT:LOAD-AS-SOURCE) (WITH-INPUT-FROM-STRING (STRM (CAR *ARGS*))     (SETF ARGONE (READ STRM))) 0)
4: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-INT:LOAD-AS-SOURCE)     (WITH-INPUT-FROM-STRING (STRM (CAR *ARGS*)) (SETF ARGONE (READ STRM))) :CURRENT-INDEX 0)
5: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS)     :IN SB-INT:LOAD-AS-SOURCE) {1005F0E1B}> #<SB-C::SOURCE-INFO {70055166F3}> SB-C::INPUT-ERROR-IN-LOAD)
6: (SB-INT:LOAD-AS-SOURCE #<SB-SYS:FD-STREAM for "file /...././test.lisp" {7005510D73}> :VERBOSE NIL    :PRINT NIL :CONTEXT "loading")
7: ((LABELS SB-FASL::LOAD-STREAM-1 :IN LOAD) #<SB-SYS:FD-STREAM for "file /...././test.lisp" {7005510D73}   > NIL)
8: (SB-FASL::CALL-WITH-LOAD-BINDINGS #<FUNCTION (LABELS SB-FASL::LOAD-STREAM-1 :IN LOAD) {1005F09EB}>     #<SB-SYS:FD-STREAM for "file /...././test.lisp" {7005510D73}> NIL #<SB-SYS:FD-STREAM for "file /...././   test.lisp" {7005510D73}>)
9: (LOAD #<SB-SYS:FD-STREAM for "file /...././test.lisp" {7005510D73}> :VERBOSE NIL :PRINT NIL    :IF-DOES-NOT-EXIST :ERROR :EXTERNAL-FORMAT :DEFAULT)
10: ((FLET SB-IMPL::LOAD-SCRIPT :IN SB-IMPL::PROCESS-SCRIPT) #<SB-SYS:FD-STREAM for "file /...././test.   lisp" {7005510D73}>)
11: ((FLET SB-UNIX::BODY :IN SB-IMPL::PROCESS-SCRIPT))
12: ((FLET "WITHOUT-INTERRUPTS-BODY-11" :IN SB-IMPL::PROCESS-SCRIPT))
13: (SB-IMPL::PROCESS-SCRIPT "./test.lisp")
14: (SB-IMPL::TOPLEVEL-INIT)
15: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
16: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
17: (SB-IMPL::%START-LISP)

unhandled condition in --disable-debugger mode, quitting
me % 

Obviamente, há questões relacionadas a como devo usar o SBCL das quais não tenho conhecimento.

Qualquer especialista em lisp ou melhor alguém com conhecimento de SBCL ficará muito grato em me dizer como as coisas devem ser feitas.

Estou iniciando um aplicativo de teste simples usando NextJS/React.

Abaixo está o código:

O conteúdo do arquivo Board.tsx:

import './Board.css';

export default function Board() {
    return <div className="board">
    <Row/>
    <Row/>
    <Row/>
  </div>
} /* End of Board */

function Row() {
    return <div className="row">
    <Cell/>
    <Cell/>
    <Cell/>
  </div>
} /* End of Row */

function Cell() {
    return <div className="cell"/>
} /* End of Cell */

E o conteúdo do arquivo Board.css:

.cell {
  width: 3rem;
  height: 3rem;
  background-color: rgb(255, 255, 0);
  border-width: 2px;
  border-color: rgb(55, 55, 55);
  margin: 11%;
}

.row {
  display: flex;
  flex-direction: row;
}

.board {
  display: flex;
  flex-direction: column;
}

No topo está o arquivo app/page.tsx:

import Image from 'next/image'
import Board from './components/Board'

export default function Home() {
  return (
    <main className="flex min-h-screen flex-col items-center justify-between p-24">
      X4C APP
      <Board/>
    </main>
  )
}

Aqui está o que aparece no navegador da web ao executar o aplicativo:

Finalmente tenho uma pergunta. Por que não vemos quadrados amarelos perfeitos, quando o CSS indica uma largura e altura fixas para o componente da célula?

Posso ver, experimentando, que se eu remover os dois blocos

.row {...}
.board {...}

do arquivo Board.css, obtenho quadrados perfeitos.

Então, o que está causando esse problema nesses dois blocos?

Ao usar a Firebase CLI com um Realtime Database, posso usar um comando como este para ler uma coleção:

 % firebase database:get DB_Path

Mas não consigo encontrar uma maneira de selecionar apenas os documentos necessários.

Tenho dificuldade em acreditar que isso possa ser impossível.

Algo como:

 % firebase database:get DB_Path where (name='Biden Joe')

Existe uma sintaxe adequada para fazer isso?

Preciso escrever uma consulta SQL para um banco de dados PostGres. O objetivo é criar uma visualização baseada no conteúdo de uma tabela.

Esta é minha tabela inicial:

Rank  Value
 1      4
 2      5
 3      8
 4      11
 5      19
 6      32
 7      55

Esta é a visão que eu gostaria de construir:

Rank  Value  SumUpTo
 1      4       4
 2      5       9
 3      8       17
 4      11      28
 5      19      47
 6      32      79
 7      55      134

As colunas Classificação e Valor foram apenas copiadas da tabela original. A coluna SumUpTo é calculada somando todos os valores da tabela original desde a classificação 1 até a classificação atual.

Eu tentei esse tipo de consulta, entre outras, mas tudo falhou:

CREATE VIEW myview AS SELECT rank,value,(SELECT SUM(value) FROM mytable WHERE (rank<rank)) as SumUpTo FROM mytable;
CREATE VIEW myview AS SELECT rank,value,(SELECT SUM(value) FROM mytable WHERE (rank<mytable.rank)) as SumUpTo FROM mytable;

Qual é a maneira correta de escrever a consulta para obter o resultado desejado?

Estou verificando como o CORS funciona e revisando os fundamentos do conceito cliente-servidor em um aplicativo node.JS. E eu tenho uma pergunta.

Aqui está o meu código para o servidor:

const express = require('express'),
      server = express(),
      cors = require('cors');

server.use(cors({origin: "http://localhost:3000"}));

server.get('/json-data', (req, res) => {
  res.status(200).send([
            {order:10,value:29},
            {order:100,value:541},
            {order:1000,value:7919}])
});

server.listen(8888);

Apontando o navegador da web para este URL:

http://localhost:8888/json-data

Posso confirmar que o servidor está funcionando conforme o esperado, retornando um array de 3 itens.

Minha pergunta vai ser relacionada ao cliente.

Quando eu uso o código a seguir para o cliente:

'use client'

function Receiver() {
  fetch("http://localhost:8888/json-data")
  .then(res => res.json())
  .then(data => {
    console.log('Receiver-0:'+JSON.stringify(data[0]))
    console.log('Receiver-1:'+JSON.stringify(data[1]))
    console.log('Receiver-2:'+JSON.stringify(data[2]))
  })

  return(
    <div>
      <h1>Hello Receiver !!</h1>
    </div>
  )
}

Recebo a resposta que espero no navegador da web:

Hello Receiver !!

E vejo os três itens esperados nos logs (ou seja, o console de ferramentas para desenvolvedores da web).

Por outro lado, se eu usar este código para o cliente:

async function Receiver() {
  const response = await fetch("http://localhost:8888/json-data");
  const primes = await response.json();
  const data = JSON.stringify(primes)
  return <h1>{data}</h1>;
}

export default Receiver;

Recebo esta resposta no navegador da web:

[{"order":10,"value":29},{"order":100,"value":541}]

Por que não estou recebendo os três itens do servidor e apenas dois?

Tomando como ponto de partida as 2 versões do cliente acima, existe uma maneira de estabelecer meu código para que eu receba na resposta todos os itens que o servidor fornece?

Como informação extra, é assim que o cliente é utilizado:

import Receiver from './components/receiver'

export default function Home() {
  return (
    <main className="flex min-h-screen flex-col items-center justify-between p-24">
      <div>
        <Receiver />
      </div>
    </main>
  )
}

Também tentei o código abaixo para o cliente (com base no código encontrado aqui: https://nextjs.org/docs/app/building-your-application/data-fetching/fetching-caching-and-revalidating#fetching- dados no servidor com busca )

async function getData() {
  const res = await fetch('http://localhost:8888/json-data')

  if (!res.ok) {
    throw new Error('Failed to fetch data')
  }

  return res.json()
}

export default async function Receiver() {
  const data = await getData()

  return <main>{JSON.stringify(data)}</main>
}

Mas ainda obtenho o mesmo resultado do teste anterior. Esta resposta no navegador da web:

[{"order":10,"value":29},{"order":100,"value":541}]

Sou iniciante nesta linguagem: GForth .

Alguém com alguma experiência pode me dizer qual é o problema no código abaixo?

Aqui está uma definição.

: collatzcount
variable count
0 count !
{ ini } ini
begin dup 1 <> while dup . syr repeat .
count ? ;
\ redefined collatzcount   ok

Neste ponto, aparentemente, nada está errado. Então vamos tentar:

1 collatzcount

saída

:213: Attempt to use zero-length string as a name
1 collatzcount>>><<<
Backtrace:
$7F21F04AB710 throw
$7F21F04B0008 name-too-short?
$7F21F04B1990 header
$7F21F04B1A00 Create
$7F21F04FD460 Variable

O que é essa misteriosa " Tentativa de usar string de comprimento zero como nome "?

Caso alguém queira saber, esta é a definição de syr :

: syr dup 2 mod 0 = if 2 / else 3 * 1 + endif ;

Mas isso provavelmente é irrelevante para a questão.