ClarkeRemy

fAtoB_optionA_optionB(_, none, none).
fAtoB_optionA_optionB(F, option(A), option(B)) :- C =.. [F,A,B], C.

functor_map(option, fAtoB_optionA_optionB).

fmapAtoB_fA_fB(Func, F_A, F_B) :-
    ( nonvar(F_A) -> F_A =.. [F| _]
    ; nonvar(F_B) -> F_B =.. [F| _]
    ),
    functor_map(F, Map),

ClarkeRemy

use std::marker::PhantomData;

/// We limit the size of a node to u16::MAX. If you want bigger, make a tree or use a Tensor
pub type Mem    = u16;
pub type Offset = usize;

type InternalHandleRepr = u32;
struct InternalHandle<T>{handle : InternalHandleRepr, _boo : PhantomData<T>}

pub type   ExtHandleRepr = u64;

ClarkeRemy

datatype 'a Tree = 
    Leaf 
  | Branch of {value : 'a, left : 'a Tree, right : 'a Tree}


fun flatten t = case t of
  Leaf => []
| Branch {value, left, right} => let

ClarkeRemy

// https://docs.rs/rust2fun/latest/src/rust2fun/combinator.rs.html#399-417


trait Rec<T, R> {
    fn apply(&self, x: T) -> R;
}

impl<T, R, F> Rec<T, R> for F
where
    F: Fn(&dyn Rec<T, R>, T) -> R,

ClarkeRemy

use core::ops::ControlFlow;
use std::{marker::PhantomData, sync::Arc};


// HKT

#[allow(non_camel_case_types)]
pub type a_<'a, F, T> = <F as A_Funct>::F<'a, T>;
#[allow(non_camel_case_types)]

ClarkeRemy

datatype expr = PLUS of expr * expr 
              | NUM  of int

fun eval_expr (NUM n)      = n
  | eval_expr (PLUS (l,r)) = eval_expr l + eval_expr r

fun pretty_expr (NUM n)      = Int.toString n
  | pretty_expr (PLUS (l,r)) = "( " ^ pretty_expr l ^ " + " ^ pretty_expr r ^ " )"

ClarkeRemy

fun y f x = f (y f) x


functor Fix(type 'a f )
= struct
  type 'a f = 'a f
  datatype fix = FIX of fix f
  fun inj      v  = FIX v
  fun prj (FIX v) = v
  end

ClarkeRemy

// // if it was C :
//
// enum t {
//   Plus = 0,
//   Mul = 1,
//   num = 2,
// }
// union e { plus : Plus<*const TG>, mul : Mul<*const TG>, num : u32 }
// struct TG { tag : int, val : e }

ClarkeRemy

// this is just to satisfy the type system as I don't have the function
mod boys { pub mod micb25 { pub fn boys(_:u64,_:f64)->f64 {1.0} }}
#[derive(Clone, Copy)]
pub struct Vector3<T> {x:T,y:T,z:T}
impl Vector3<f64> {
  fn norm_squared(&self)->f64 {self.x*self.x+self.y*self.y+self.z*self.z}
}

// direct style

ClarkeRemy

use std::marker::PhantomData;


enum Ast{};
enum Eval{};
trait Mode {}
impl Mode for Ast {}
impl Mode for Eval {}