All perguntas(coding)

Tenho um projeto básico lendo a variável de ambiente para ColorScheme. O que notei é que, como meu aplicativo está no modo claro, quando coloco o aplicativo em segundo plano, o esquema de cores sempre alterna entre escuro e claro, mesmo que eu nunca altere o modo de cor.

  struct ContentView: View {
      @SwiftUI.Environment(\.colorScheme) var colorScheme

      var body: some View {
          VStack {
              let _ = Self._printChanges()
              let _ = print("====== colorscheme \(colorScheme)")
              Image(systemName: "globe")
                  .imageScale(.large)
                  .foregroundStyle(.tint)
              Text("Hello, world!")
          }
          .padding()
      }
  }

quando coloco o aplicativo em segundo plano ele imprime

ContentView: _colorScheme changed.
====== colorscheme dark
ContentView: _colorScheme changed.
====== colorscheme light

Alguém notou esse problema? Isso é um bug ou design? E como impedir que isso aconteça?

O código a seguir vem do GCC Wiki .

// -Thread 1-
y.store (20, memory_order_relaxed)
x.store (10, memory_order_relaxed)

// -Thread 2-
if (x.load (memory_order_relaxed) == 10)
 {
   assert (y.load(memory_order_relaxed) == 20) /* assert A */
   y.store (10, memory_order_relaxed)
 }

// -Thread 3-
if (y.load (memory_order_relaxed) == 10)
 assert (x.load(memory_order_relaxed) == 10) /* assert B */

Como os threads não precisam ser sincronizados no sistema, qualquer uma das asserções neste exemplo pode realmente FALHAR .

Eu consigo entender por que assert A pode falhar. Mas como assert B também pode falhar?

Isso y.load() == 10implica o fim do tópico 2, então x.load() == 10?

Estou criando um aplicativo Shiny que tem uma aba para documentação e pretendo usar tags$iframeum site Quarto renderizado para ele.

No Quarto, é possível definir um switch para display . Isso também mostrará um botão switch para controlar o tema do site.

O aplicativo de exemplo é mostrado abaixo:

Embora ambos suportem a alternância do modo claro para o escuro, os usuários precisam clicar em diferentes interruptores duas vezes, o que não é o ideal para a melhor experiência:

Apenas a entrada Brilhante mudou para escura:

Tanto a entrada Shiny quanto a entrada Quarto mudaram para escuro:

Minha pergunta é: É possível usar um botão de entrada do Shiny para controlar o tema no aplicativo Shiny e o tema no site do Quarto?

O código do aplicativo Shiny de exemplo é:

library(shiny)
library(bslib)
library(htmltools)

ui <- page_fillable(

    input_dark_mode(id = "shiny_control", mode = "light"),

    tags$iframe(
      src = "_site/index.html",

      style = "height:86vh"
    )
)

server <- function(input, output, session) {

}

shinyApp(ui, server)

E a estrutura completa do aplicativo está disponível no github :

├── app.R                                       <- Shiny app
├── control_quarto_theme_from_Shiny.Rproj
└── www               
    └── _site                                   <- Rendered Quarto Website files
        ├── about.html
        ├── index.html
        ├── search.json
        ├── site_libs
        │   ├── bootstrap
        │   │   ├── bootstrap-dark.min.css
        │   │   ├── bootstrap-icons.css
        │   │   ├── bootstrap-icons.woff
        │   │   ├── bootstrap.min.css
        │   │   └── bootstrap.min.js
        │   ├── clipboard
        │   │   └── clipboard.min.js
        │   ├── quarto-html
        │   │   ├── anchor.min.js
        │   │   ├── popper.min.js
        │   │   ├── quarto-syntax-highlighting-dark.css
        │   │   ├── quarto-syntax-highlighting.css
        │   │   ├── quarto.js
        │   │   ├── tippy.css
        │   │   └── tippy.umd.min.js
        │   ├── quarto-nav
        │   │   ├── headroom.min.js
        │   │   └── quarto-nav.js
        │   └── quarto-search
        │       ├── autocomplete.umd.js
        │       ├── fuse.min.js
        │       └── quarto-search.js
        └── styles.css

Tenho brincado com os componentes Flutter ShadCN recentemente e não consegui integrar o código de exemplo Tabs da documentação no código boilerplate ShadCN fornecido a nós aqui.

Eu simplesmente peguei o

══╡ EXCEPTION CAUGHT BY WIDGETS LIBRARY ╞═══════════════════════════════════════════════════════════
The following assertion was thrown building ShadTabs<String>(dirty, dependencies:
[UnmanagedRestorationScope], state: ShadTabsState<String>#57a89):
ShadTheme.of() called with a context that does not contain a ShadTheme.

    No ShadTheme ancestor could be found starting from the context that was passed to

ShadTheme.of().
This can happen because you do not have a ShadApp widget (which introduces a ShadTheme),
or it can happen if the context you use comes from a widget above this widget.

    The context used was: ShadTabs<String>(dirty, dependencies: [UnmanagedRestorationScope],

state: ShadTabsState<String>#57a89)

A única linha que alterei do código boilerplate foi que comentei Padding of child e substituí por const TabsExample()(Meu TabsExamplewidget foi copiado e colado diretamente da documentação de exemplo de guias )

import 'package:flutter/services.dart';
import 'package:flutter_test_1/screens/home_tabs.dart';
import 'package:shadcn_flutter/shadcn_flutter.dart';

void main() {
  WidgetsFlutterBinding.ensureInitialized();
  SystemChrome.setSystemUIOverlayStyle(
      const SystemUiOverlayStyle(systemNavigationBarColor: Colors.transparent));
  SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return ShadcnApp(
      title: 'My App',
      home: const TabsExample(),
      theme: ThemeData(
        colorScheme: ColorSchemes.darkZinc(),
        radius: 0.7,
      ),
    );
  }
}

class CounterPage extends StatefulWidget {
  const CounterPage({super.key});

  @override
  _CounterPageState createState() => _CounterPageState();
}

class _CounterPageState extends State<CounterPage> {
  int _counter = 0;

  int _selected = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });
  }

  NavigationItem _buildButton(String label, IconData icon) {
    return NavigationItem(
      label: Text(label),
      child: Icon(icon),
    );
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      headers: [
        AppBar(
          title: const Text('Counter App'),
          subtitle: const Text('Testing features'),
          leading: [
            GhostButton(
              onPressed: () {
                openDrawer(
                  context: context,
                  builder: (context) {
                    return Container(
                      alignment: Alignment.center,
                      constraints: const BoxConstraints(
                        maxWidth: 300,
                      ),
                      child: const Text('Drawer'),
                    );
                  },
                  position: OverlayPosition.left,
                );
              },
              density: ButtonDensity.icon,
              child: const Icon(Icons.menu),
            ),
          ],
          trailing: [
            GhostButton(
              density: ButtonDensity.icon,
              onPressed: () {
                openSheet(
                  context: context,
                  builder: (context) {
                    return Container(
                      alignment: Alignment.center,
                      constraints: const BoxConstraints(
                        maxWidth: 200,
                      ),
                      child: const Text('Sheet'),
                    );
                  },
                  position: OverlayPosition.right,
                );
              },
              child: const Icon(Icons.search),
            ),
          ],
        ),
        const Divider(),
      ],
      footers: [
        const Divider(),
        NavigationBar(
          onSelected: (i) {
            setState(() {
              _selected = i;
            });
          },
          index: _selected,
          children: [
            _buildButton('Home', Icons.home),
            _buildButton('Explore', Icons.explore),
            _buildButton('Library', Icons.library_music),
          ],
        ),
      ],
      child: 
      const TabsExample()
      // Padding(
      //   padding: const EdgeInsets.all(32.0),
      //   child: Center(
      //     child: Column(
      //       mainAxisAlignment: MainAxisAlignment.center,
      //       children: <Widget>[
      //         const Text(
      //           'You have pushed the button this many times:',
      //           textAlign: TextAlign.center,
      //         ).p(),
      //         Text(
      //           '$_counter',
      //         ).h1(),
      //         PrimaryButton(
      //           onPressed: _incrementCounter,
      //           density: ButtonDensity.icon,
      //           child: const Icon(Icons.add),
      //         ).p(),
      //       ],
      //     ),
      //   ),
      // ),
    );
  }
}

O que deu errado?

Este é meu serviço Angular:

uploadFiles(formData: FormData) {
   const headerOptions = {
       headers: new HttpHeaders({
           'X-CSRF-TOKEN': token
       })
   };

   return this.httpClient
       .post<string>(`${this.configurationService.apiUrl}/cancellationforms/upload`, formData, headerOptions);
}

for (let file in this.supportDocuments) {
  // file is a blob object
  formData.append("files", file);
}

this.uploadService.uploadFiles(formData)

Ponto de extremidade da API Web do ASP.NET Core:

routeBuilder.MapPost("api/cancellationforms/upload", ([FromForm] List<IFormFile> files, [FromServices] IServiceManager serviceManager, CancellationToken cancellationToken) =>
{
    return Results.Ok("Hello");
})
.WithName("CreateCancellationFormUpload")
.WithOpenApi();

Os arquivos dos endpoints são sempre nulos, se eu usar List. Se eu remover List, ele terá o valor do objeto blob mais recente que eu anexar na UI.

Alguém pode me dizer o que estou perdendo?

Obrigado

Estou tentando chamar uma função C x86, printf, em assembly, mas há um erro de vinculação: error LNK2019: unresolved external symbol _printf referenced in function _main.

.model flat, C
.code
extern printf: proc

main proc
    push offset msg
    push offset fmt
    call printf
    ret
main endp

.data
    msg db "Hello world!", 0
    fmt db "%s", 0
end

Como posso resolver esse problema?

Tenho uma função que retorna múltiplas variáveis ​​e estou tentando mapeá-la para um dataframe para acelerar o processamento de dados. No entanto, quando executo o código, ele não descompacta os dados e os adiciona às colunas.

código

import pandas as pd

def last_3_divisions(number: int, divide_by: int):
    last_3 = {3: None, 2: None, 1: None}
    for x in range(3, 0,-1):
        number = number / divide_by
        last_3[x] = number 
    return last_3[3], last_3[2], last_3[1]

mydf = pd.DataFrame([8,6,7,5,3,0,9], columns=["mynum"])

mydf["d3"], mydf["d2"], mydf["d1"] = mydf["mynum"].map(lambda x: last_3_divisions(x, 2))

executar o código funciona bem e irá gerar uma saída, no entanto, quando tento enviar as tuplas para colunas diferentes, ele produz um erro de valor

ValueError: muitos valores para descompactar (esperado 3)

Como descompactar as tuplas para classificá-las em colunas diferentes?

Criei um aplicativo React que usa uma barra lateral que deveria facilitar a entrada e saída, mas não faz isso. Ela simplesmente aparece enquanto empurra com sucesso o conteúdo para a direita e aparece quando clicada novamente.

O código usa

  transition: transform 0.3s ease-in-out; 
  transform: translateX(-250px);

para mover a barra lateral para dentro e para fora da tela. Mas não parece estar funcionando no exemplo do sandbox. Funciona no meu aplicativo real, mas não animado.

Aqui está uma foto que mostra expandido

Este mostra que ele entrou em colapso :

Observe que a barra lateral está toda branca. Não consigo deixá-la com uma cor diferente.

Eu olhei para muitos outros exemplos, mas todos eles têm problemas que eu não gosto. Eu quero que o botão permaneça no lugar quando a bandeja abaixo dele desliza para dentro e para fora. A maioria dos exemplos empurra o cabeçalho também, o que requer que você mova o mouse para um local diferente para fechá-lo.

Gostaria também que o usuário tivesse a opção de fechar a barra lateral após a seleção ou permanecer aberta.

Criei um pequeno exemplo de sandbox . Eu portei um snipped do aplicativo principal, mas agora o conteúdo vai para baixo do menu em vez de para a direita dele. Espero que um de vocês, especialistas, possa me mostrar o que estou perdendo!

Aqui está a definição da mônada de estado do capítulo 13 de Learn You a Haskell

instance Monad (State s) where
    return x = State $ \s -> (x,s)
    (State h) >>= f = State $ \s -> let (a, newState) = h s
                                        (State g) = f a
                                    in  g newState

Com base nessa definição, parece-me que o estado na tupla retornada por f aserá substituído por newStatemesmo que seja a versão mais recente. Para pegar um exemplo específico do capítulo 10 do Real World Haskell, onde isso claramente não é o que os autores pretendem (observe o uso de em vez de porque eles ainda não introduziram formalmente as mônadas)==>>>=

parseByte :: Parse Word8
parseByte =
    getState ==> \initState ->
    case L.uncons (string initState) of
      Nothing ->
          bail "no more input"
      Just (byte,remainder) ->
          putState newState ==> \_ ->
          identity byte
        where newState = initState { string = remainder,
                                     offset = newOffset }
              newOffset = offset initState + 1

Onde

newtype Parse a = Parse {
      runParse :: ParseState -> Either String (a, ParseState)
    }

identity :: a -> Parse a
identity a = Parse (\s -> Right (a, s))
 
(==>) :: Parse a -> (a -> Parse b) -> Parse b
firstParser ==> secondParser  =  Parse chainedParser
  where chainedParser initState   =
          case runParse firstParser initState of
            Left errMessage ->
                Left errMessage
            Right (firstResult, newState) ->
                runParse (secondParser firstResult) newState

Em parseByte, não vejo como initStatenão substitui newState.

Eu tenho um number[] | string[]e quero filtrá-lo. O problema é que a função de filtro muda o tipo para (number | string)[]instead.

// list of numbers OR list of strings
let myList = Math.random() < 0.5 ? [1, 2, 3] : ["a", "b", "c"];

// filter the list
const filtered = myList.filter((x) => { return true; });

// oh no, the result is Array<number | string> instead of (number[] | string[])
myList = filtered;

Erro na última linha:

Type '(string | number)[]' is not assignable to type 'number[] | string[]'.
  Type '(string | number)[]' is not assignable to type 'number[]'.
    Type 'string | number' is not assignable to type 'number'.
      Type 'string' is not assignable to type 'number'.(2322)

Como posso expressar o fato de que a matriz não pode ser mista , mas pode conter qualquer tipo de elemento?

Link do parque infantil