[rust-dev] Encapsulating mutiple generic types

[rust-dev] Encapsulating mutiple generic types

[Ryan Michael]

[-- Attachment #1: Type: text/plain, Size: 1508 bytes --]

I'm curious if the community has some design approaches to encapsulating
interfaces to multiple generic implementations.  For example, imagine I was
writing an abstract database interface with multiple backing
implementations for different stores (sqlite, pgsql, mysql, etc) and
logging data to different types of loggers (stdout, file, network-attached,
etc).  The goal would be to implement some shared methods (insert, query,
delete) to be delegated to different stores, with logging about the results.

My first approach to this was to create traits, and use them in a struct

trait Logger {
  fn log(&mut self, message: String),
}

trait Store {
  fn insert(&mut self, value: String),
  fn query(&mut self, conditions: String) -> Vec<String>,
  fn delete(&mut self, value: String),
}

struct Database {
  db: Store,
  logger: Logger,
}

AFAICT, this isn't possible - struct fields seem to require concrete types.

Another approach I've considered is using a function with a communication
channel, something like (code probably broken in multiple ways):

enum Event {
  Insert(value: String),
  Query(conditions, response: channel<String>),
  Delete(value: String),
}
fn database(db: Database, logger: Logger, events: chan<Event>) {
  loop {
    match events.recv() {
      // do stuff
    }
  }
}
let (tx, rx) = channel()
spawn {
  database(db, logger, rx);
}
tx.send(Query(my_query));

This seems like it would work, but feels like a hack.  Is there a better
way to do this than using channels?

-Ryan

[-- Attachment #2: Type: text/html, Size: 2078 bytes --]

Re: [rust-dev] Encapsulating mutiple generic types

[Federico Ravasio]

понедельник, 1 декабря 2014 г. в 16:59, Ryan Michael написал:
> I'm curious if the community has some design approaches to encapsulating interfaces to multiple generic implementations. For example, imagine I was writing an abstract database interface with multiple backing implementations for different stores (sqlite, pgsql, mysql, etc) and logging data to different types of loggers (stdout, file, network-attached, etc). The goal would be to implement some shared methods (insert, query, delete) to be delegated to different stores, with logging about the results.
>  
> My first approach to this was to create traits, and use them in a struct
>  
> trait Logger {
> fn log(&mut self, message: String),
> }
>  
> trait Store {
> fn insert(&mut self, value: String),
> fn query(&mut self, conditions: String) -> Vec<String>,
> fn delete(&mut self, value: String),
> }
>  
> struct Database {
> db: Store,
> logger: Logger,
> }
>  
> AFAICT, this isn't possible - struct fields seem to require concrete types.
>  
Hello Ryan,
I’ve had some luck by wrapping trait fields into boxes, with explicit lifetimes.

This should work:

struct Database<'a> {
    db: Box<Store + 'a>,
    logger: Box<Logger + 'a>,
}


Now, I’m not sure if that’s a community-accepted solution. Let’s see what the others think. :)

Cheers,
Federico

Re: [rust-dev] Encapsulating mutiple generic types

[Philippe Daouadi]

Hi,

In my project, I use something like:

struct Database {
     db: Box<Store + 'static>,
     logger: Box<Logger + 'static>,
}

Does anyone know what is the difference? They seem to work the same to me.

Philippe

On 12/01/2014 05:04 PM, Federico Ravasio wrote:
> понедельник, 1 декабря 2014 г. в 16:59, Ryan Michael написал:
>> I'm curious if the community has some design approaches to encapsulating interfaces to multiple generic implementations. For example, imagine I was writing an abstract database interface with multiple backing implementations for different stores (sqlite, pgsql, mysql, etc) and logging data to different types of loggers (stdout, file, network-attached, etc). The goal would be to implement some shared methods (insert, query, delete) to be delegated to different stores, with logging about the results.
>>   
>> My first approach to this was to create traits, and use them in a struct
>>   
>> trait Logger {
>> fn log(&mut self, message: String),
>> }
>>   
>> trait Store {
>> fn insert(&mut self, value: String),
>> fn query(&mut self, conditions: String) -> Vec<String>,
>> fn delete(&mut self, value: String),
>> }
>>   
>> struct Database {
>> db: Store,
>> logger: Logger,
>> }
>>   
>> AFAICT, this isn't possible - struct fields seem to require concrete types.
>>   
> Hello Ryan,
> I’ve had some luck by wrapping trait fields into boxes, with explicit lifetimes.
>
> This should work:
>
> struct Database<'a> {
>      db: Box<Store + 'a>,
>      logger: Box<Logger + 'a>,
> }
>
>
> Now, I’m not sure if that’s a community-accepted solution. Let’s see what the others think. :)
>
> Cheers,
> Federico
>
> _______________________________________________
> Rust-dev mailing list
> Rust-dev@mozilla.org
> https://mail.mozilla.org/listinfo/rust-dev

Re: [rust-dev] Encapsulating mutiple generic types

[Tim Kuehn]

[-- Attachment #1: Type: text/plain, Size: 2279 bytes --]

Can you use a trait for that?

trait Database: Store + Logger {}

On Mon, Dec 1, 2014 at 11:48 AM, Philippe Daouadi <blastrock0@free.fr>
wrote:

> Hi,
>
> In my project, I use something like:
>
> struct Database {
>     db: Box<Store + 'static>,
>     logger: Box<Logger + 'static>,
> }
>
> Does anyone know what is the difference? They seem to work the same to me.
>
> Philippe
>
>
> On 12/01/2014 05:04 PM, Federico Ravasio wrote:
>
>> понедельник, 1 декабря 2014 г. в 16:59, Ryan Michael написал:
>>
>>> I'm curious if the community has some design approaches to encapsulating
>>> interfaces to multiple generic implementations. For example, imagine I was
>>> writing an abstract database interface with multiple backing
>>> implementations for different stores (sqlite, pgsql, mysql, etc) and
>>> logging data to different types of loggers (stdout, file, network-attached,
>>> etc). The goal would be to implement some shared methods (insert, query,
>>> delete) to be delegated to different stores, with logging about the results.
>>>   My first approach to this was to create traits, and use them in a
>>> struct
>>>   trait Logger {
>>> fn log(&mut self, message: String),
>>> }
>>>   trait Store {
>>> fn insert(&mut self, value: String),
>>> fn query(&mut self, conditions: String) -> Vec<String>,
>>> fn delete(&mut self, value: String),
>>> }
>>>   struct Database {
>>> db: Store,
>>> logger: Logger,
>>> }
>>>   AFAICT, this isn't possible - struct fields seem to require concrete
>>> types.
>>>
>>>
>> Hello Ryan,
>> I’ve had some luck by wrapping trait fields into boxes, with explicit
>> lifetimes.
>>
>> This should work:
>>
>> struct Database<'a> {
>>      db: Box<Store + 'a>,
>>      logger: Box<Logger + 'a>,
>> }
>>
>>
>> Now, I’m not sure if that’s a community-accepted solution. Let’s see what
>> the others think. :)
>>
>> Cheers,
>> Federico
>>
>> _______________________________________________
>> Rust-dev mailing list
>> Rust-dev@mozilla.org
>> https://mail.mozilla.org/listinfo/rust-dev
>>
>
> _______________________________________________
> Rust-dev mailing list
> Rust-dev@mozilla.org
> https://mail.mozilla.org/listinfo/rust-dev
>

[-- Attachment #2: Type: text/html, Size: 3355 bytes --]

Re: [rust-dev] Encapsulating mutiple generic types

[Ben Foppa]

[-- Attachment #1: Type: text/plain, Size: 2494 bytes --]

I think 'static is the global lifetime - that might require that the
objects can exist for as long as the program does.

also FWIW, I'm pretty sure these kinds of discussions are better-suited for
stack overflow. The mailing list is somewhat deprecated, at least
unofficially.

On Mon, Dec 1, 2014 at 11:48 AM, Philippe Daouadi <blastrock0@free.fr>
wrote:

> Hi,
>
> In my project, I use something like:
>
> struct Database {
>     db: Box<Store + 'static>,
>     logger: Box<Logger + 'static>,
> }
>
> Does anyone know what is the difference? They seem to work the same to me.
>
> Philippe
>
>
> On 12/01/2014 05:04 PM, Federico Ravasio wrote:
>
>> понедельник, 1 декабря 2014 г. в 16:59, Ryan Michael написал:
>>
>>> I'm curious if the community has some design approaches to encapsulating
>>> interfaces to multiple generic implementations. For example, imagine I was
>>> writing an abstract database interface with multiple backing
>>> implementations for different stores (sqlite, pgsql, mysql, etc) and
>>> logging data to different types of loggers (stdout, file, network-attached,
>>> etc). The goal would be to implement some shared methods (insert, query,
>>> delete) to be delegated to different stores, with logging about the results.
>>>   My first approach to this was to create traits, and use them in a
>>> struct
>>>   trait Logger {
>>> fn log(&mut self, message: String),
>>> }
>>>   trait Store {
>>> fn insert(&mut self, value: String),
>>> fn query(&mut self, conditions: String) -> Vec<String>,
>>> fn delete(&mut self, value: String),
>>> }
>>>   struct Database {
>>> db: Store,
>>> logger: Logger,
>>> }
>>>   AFAICT, this isn't possible - struct fields seem to require concrete
>>> types.
>>>
>>>
>> Hello Ryan,
>> I’ve had some luck by wrapping trait fields into boxes, with explicit
>> lifetimes.
>>
>> This should work:
>>
>> struct Database<'a> {
>>      db: Box<Store + 'a>,
>>      logger: Box<Logger + 'a>,
>> }
>>
>>
>> Now, I’m not sure if that’s a community-accepted solution. Let’s see what
>> the others think. :)
>>
>> Cheers,
>> Federico
>>
>> _______________________________________________
>> Rust-dev mailing list
>> Rust-dev@mozilla.org
>> https://mail.mozilla.org/listinfo/rust-dev
>>
>
> _______________________________________________
> Rust-dev mailing list
> Rust-dev@mozilla.org
> https://mail.mozilla.org/listinfo/rust-dev
>

[-- Attachment #2: Type: text/html, Size: 3531 bytes --]