schala/schala-repl/src/language.rs

use std::time;

pub trait ProgrammingLanguageInterface {
  fn get_language_name(&self) -> String;
  fn get_source_file_suffix(&self) -> String;

  fn run_computation(&mut self, _request: ComputationRequest) -> ComputationResponse {
    ComputationResponse {
      main_output: Err(format!("Computation pipeline not implemented")),
      global_output_stats: GlobalOutputStats::default(),
      debug_responses: vec![],
    }
  }

  fn repl_request(&self, repl_request: String) -> String {
    format!("<<No custom interpreter directives or help info specified>>")
  }

  fn request_meta(&mut self, _request: LangMetaRequest) -> LangMetaResponse {
    LangMetaResponse::Custom { kind: format!("not-implemented"), value: format!("") }
  }
}

pub struct ComputationRequest<'a> {
  pub source: &'a str,
  pub debug_requests: Vec<DebugRequest>,
}

pub struct ComputationResponse {
  pub main_output: Result<String, String>,
  pub global_output_stats: GlobalOutputStats,
  pub debug_responses: Vec<DebugResponse>,
}

pub struct DebugRequest {
  kind: String,
  value: String
}

pub struct DebugResponse {
  kind: String,
  value: String
}

pub enum LangMetaRequest {
  StageNames,
  Custom {
    kind: String,
    value: String
  }
}

pub enum LangMetaResponse {
  StageNames(Vec<String>),
  Custom {
    kind: String,
    value: String
  }
}

#[derive(Default, Debug)]
pub struct GlobalOutputStats {
  total_duration: Option<time::Duration>,
  stage_durations: Option<Vec<(String, time::Duration)>>
}

  /*
impl GlobalOutputStats {
  fn get_timing(&self) -> Option<String> {
    if self.durations.len() != 0 {
      let mut buf = String::new();
      write!(&mut buf, "Timing: ").unwrap();
      for duration in self.durations.iter() {
        let timing = (duration.as_secs() as f64) + (duration.subsec_nanos() as f64 * 1e-9);
        write!(&mut buf, "{}s, ", timing).unwrap()
      }
      write!(&mut buf, "\n").unwrap();
      Some(buf)
    } else {
      None
    }
  }
}
*/