transient_loop's questions

Estou recebendo uma string JSON muito longa de uma API.

Basicamente parece com isso: {"data":{.......},"needs_trial": false, "adjust_time": false,"attempts": 1234}

Preciso de tudo dentro da dataseção sem o "apêndice" como uma string .

Tentei usar a abordagem usual ao analisar JSON em Go:

//fetch the data with http.Get into resp.Body

type MyData struct {
   Data map[string]interface{}
}

var data MyData
if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
    return err
}

Eu entendi a seção certa, claro, mas agora como um map[string]interface{}óbvio. Que eu falhei em converter de volta para uma string...

Definir o Datacampo de MyDatacomo stringtambém falha.

Não posso simplesmente cortá-lo, porque a parte do prefixo é fixa ( {"data":), mas a parte final não.

Não acredito que não consegui fazer isso, por isso estou perguntando aqui... Já gastei tanto tempo nisso que posso aceitar os votos negativos...

Estou escrevendo um aplicativo de gerenciamento de tarefas de linha de comando para aprender Rust.

Até agora tenho um sqllite e uma fonte de dados de memória.

pub struct TaskManager {
    source: Datasource, // here rustc complains
}

O gerente tem uma referência a um Datasource, que é uma característica:

pub trait Datasource {
    type Settings;

    fn start(&self) -> Result<bool>;
}

O Main lê argumentos CLI e decide com base neles qual fonte de dados deve ser instanciada.

No entanto, Rust me diz

"- rustc: o valor do tipo associado Settingsem source::Datasourcedeve ser especificado [E0191]"

Entendo que os tipos devem ser especificados em tempo de compilação, e ambas as fontes até agora têm seus tipos especificados.

impl Datasource for SqlLiteDataSource {
    type Settings = SqlLiteSettings;
}

impl Datasource for MemoryDataSource {
    type Settings = MemorySettings;
}

E ao analisar os argumentos cli, todos os braços são avaliados:

    pub fn new(datasource: Datasources) -> Self {
        let ds: Datasource = match datasource {
            Datasources::SqlLite { path } => SqlLiteDataSource::new(path.to_string()),
            _ => MemoryDataSource::new(),
        };
   }

Na verdade, o rustc também está reclamando aqui com o mesmo erro.

A ideia era que cada implementação concreta tivesse suas próprias configurações. Como posso então atribuir uma variável de trait genérica ao TaskManager, para que um backend conclua o gerenciamento de tarefas dependendo da fonte fornecida?

 ~/rust/first
   src
  │  app
  │ │  src
  │ │ │  lib.rs
  │ │ └  entry.rs                  E
  │ └  Cargo.toml
  └  main.rs                     E 
   Cargo.lock                     
   Cargo.toml                     

Este é meu primeiro projeto que estou montando em Rust.

Há um struct Entry{}em . As listas src/app/src/entry.rsde nível superior em sua seção. O -level define .Cargo.tomlmembers = ["src/app"][workspace]appCargo.toml[package]name="app"

No nível superior main.rseu simplesmente tenho let app = app::Entry::new();, mas o compilador diz "uso de caixa ou módulo não declarado app".

Por que declarar o pacote "app" no subdiretório e depois defini-lo como um membro no espaço de trabalho no nível superior não é suficiente para Entryser visto no main.rs de nível superior?

Se eu adicionar app = { path = "./src/app" }à dependenciesseção, então funciona. Mas então por que ter membros do workspace?

O que estou perdendo?

pub enum State {
   Started(Vec<Id>),
   InProgress,
   Terminated
}

pub trait Locker {
  async fn start(&mut self, id: Id) -> State; 
}

#[tokio::test]
async fn test_locker() {
   let State::Started(ids) = locker.start().await;
}

Entendo que o compilador reclama test_lockerque nem todas as correspondências foram abordadas.

Mas falhei em identificar como consertar isso. Na verdade, neste teste, sei que só pode ser esse estado, então não preciso realmente de uma correspondência.

Eu tentei várias coisas:

let State::Started(ids) = locker.start().await;
assert!(matches!(ids, State::Started(ids)));

Eu esperava que isso falhasse, pois os idsna primeira linha já estão digitados como State::Started.

Também tentei declarar let ids:Vec<Id>antes, mas isso parece estar em algum tipo de escopo diferente, pois não posso fazer issolet State::Started(ids) = ...

Acho que eu poderia simplesmente fazer uma correspondência primeiro e ignorar todas as outras opções, mas acho que deveria haver uma maneira mais elegante?

Provavelmente essa pergunta já foi feita, talvez com uma formulação diferente, mas não consegui encontrá-la. Se isso for fechado por causa disso, peço desculpas, mas eu tentei antes.

Na verdade, o problema é simples:

use std::collections::BTreeSet;

pub struct Service {
    blobs: BTreeSet<u16>,
}

impl Service {
    fn new() -> Self {
        let bt: BTreeSet<u16> = BTreeSet::new();
        Self { blobs: bt }
    }

    fn insert(&self, val: u16) -> bool {
        &self.blobs.insert(val);
        true
    }
    fn print(&self) {
        println!("{}", self.blobs.len());
    }
}
fn main() {
    let s: Service = Service::new();
    s.print();
    s.insert(4);
    s.print();
}

Ao compilar isso, obtenho:

`self` is a `&` reference, so the data it refers to cannot be borrowed as mutable

O que eu entendo aqui é que, na verdade, não posso simplesmente atualizar o treeset, pois ele é imutável.

Então eu tentei com

pub struct Service {
    blobs: &'static mut BTreeSet<u16>,
}

e

  fn new() -> Self {
        let bt: &mut BTreeSet<u16> = &mut BTreeSet::new();
        Self { blobs: bt }
    }

mas isso produz creates a temporary value which is freed while still in use (enquanto o erro original ainda está lá, então agora tenho dois...)

Entendo que eu deveria, de alguma forma, tornar o BTreeSetmutável, mas como?

Estou fazendo hash de uma string.

let src = String::from("abcd12342020");
let h1 = sha2::Sha256::digest(&src.as_bytes());
let h2 = sha2::Sha256::digest(hex::decode(&src).expect("this is not hex"));

h1e h2são diferentes. Qual é a razão subjacente ? Qual é a diferença entre uma representação de bytes e uma representação hexadecimal? (Tentei fornecer um playground, mas a hexcriação não está disponível lá)

Primeiro: sou um novato no Rust; aprendizado.

Esta questão surge provavelmente do pensamento em termos de outras línguas. Então, provavelmente, a melhor solução é fazer isso de uma maneira completamente diferente. As coisas ainda nem compilam, então peço desculpas se o código tiver problemas fundamentais.

Estou definindo minha primeira característica. A função trait leva 2 parâmetros, que definirão a saída.

trait SkFormatter {
  fn to_sk(&self, key:Key, is_foreign: bool) -> String;
}

A ideia é que a implementação pegue uma variável de string, acrescente uma string dependendo da chave e acrescente uma string if is_foreign(esta última parte não é relevante para a questão).

Por exemplo

MT-1c2af34
WD-54bdf36-FX
WD-ad3425b

Como essas strings são constantes, pensei que poderia fazer isso como um mapeamento global. Então eu criei primeiro

pub enum Key {
  // there are 7 items, but keeping it short here
  Metal,
  Wood,
}

Aí quis criar o mapeamento e as coisas começaram a ficar complicadas. Tentei o HashMap primeiro:

use std::collections::HashMap;
static KEY_TO_PRE:HashMap<Key,&str> = HashMap::from([
  (Key::Metal,"MT-"),
  (Key::Wood, "WD-"),
]);

Mas isso estava reclamando com

o limite da característica Key: std::hash::Hashnão está satisfeito

O que é surpreendente para mim, pois parece sugerir que a chave não é hashável, mas não estou definindo um tipo para ela, e assumiria que um tipo enum "semelhante a uma unidade", conforme documentado, é algum tipo de número inteiro ou alguma coisa?

Eu vi o matchidioma, talvez eu devesse tentar isso apenas dentro da implementação (coisas globais e estáticas são fedorentas para mim), mas não está claro para mim se a coisa da correspondência otimiza para reutilização, pois será chamada repetidamente.

Apenas aprendendo...